sdk/cwl/tests/test_container.py

   1 # Copyright (C) The Arvados Authors. All rights reserved.
   2 #
   3 # SPDX-License-Identifier: Apache-2.0
   4
   5 import arvados_cwl
   6 from arvados_cwl.arvdocker import arv_docker_clear_cache
   7 import logging
   8 import mock
   9 import unittest
  10 import os
  11 import functools
  12 import cwltool.process
  13 import cwltool.secrets
  14 from schema_salad.ref_resolver import Loader
  15 from schema_salad.sourceline import cmap
  16
  17 from .matcher import JsonDiffMatcher
  18
  19 if not os.getenv('ARVADOS_DEBUG'):
  20     logging.getLogger('arvados.cwl-runner').setLevel(logging.WARN)
  21     logging.getLogger('arvados.arv-run').setLevel(logging.WARN)
  22
  23
  24 class TestContainer(unittest.TestCase):
  25
  26     # The test passes no builder.resources
  27     # Hence the default resources will apply: {'cores': 1, 'ram': 1024, 'outdirSize': 1024, 'tmpdirSize': 1024}
  28     @mock.patch("arvados.commands.keepdocker.list_images_in_arv")
  29     def test_run(self, keepdocker):
  30         for enable_reuse in (True, False):
  31             arv_docker_clear_cache()
  32
  33             runner = mock.MagicMock()
  34             runner.project_uuid = "zzzzz-8i9sb-zzzzzzzzzzzzzzz"
  35             runner.ignore_docker_for_reuse = False
  36             runner.intermediate_output_ttl = 0
  37             runner.secret_store = cwltool.secrets.SecretStore()
  38
  39             keepdocker.return_value = [("zzzzz-4zz18-zzzzzzzzzzzzzz3", "")]
  40             runner.api.collections().get().execute.return_value = {
  41                 "portable_data_hash": "99999999999999999999999999999993+99"}
  42
  43             document_loader, avsc_names, schema_metadata, metaschema_loader = cwltool.process.get_schema("v1.0")
  44
  45             tool = cmap({
  46                 "inputs": [],
  47                 "outputs": [],
  48                 "baseCommand": "ls",
  49                 "arguments": [{"valueFrom": "$(runtime.outdir)"}],
  50                 "id": "#",
  51                 "class": "CommandLineTool"
  52             })
  53             make_fs_access=functools.partial(arvados_cwl.CollectionFsAccess,
  54                                          collection_cache=arvados_cwl.CollectionCache(runner.api, None, 0))
  55             arvtool = arvados_cwl.ArvadosCommandTool(runner, tool, work_api="containers", avsc_names=avsc_names,
  56                                                      basedir="", make_fs_access=make_fs_access, loader=Loader({}))
  57             arvtool.formatgraph = None
  58             for j in arvtool.job({}, mock.MagicMock(), basedir="", name="test_run_"+str(enable_reuse),
  59                                  make_fs_access=make_fs_access, tmpdir="/tmp"):
  60                 j.run(enable_reuse=enable_reuse, priority=500)
  61                 runner.api.container_requests().create.assert_called_with(
  62                     body=JsonDiffMatcher({
  63                         'environment': {
  64                             'HOME': '/var/spool/cwl',
  65                             'TMPDIR': '/tmp'
  66                         },
  67                         'name': 'test_run_'+str(enable_reuse),
  68                         'runtime_constraints': {
  69                             'vcpus': 1,
  70                             'ram': 1073741824
  71                         },
  72                         'use_existing': enable_reuse,
  73                         'priority': 500,
  74                         'mounts': {
  75                             '/tmp': {'kind': 'tmp',
  76                                      "capacity": 1073741824
  77                                  },
  78                             '/var/spool/cwl': {'kind': 'tmp',
  79                                                "capacity": 1073741824 }
  80                         },
  81                         'state': 'Committed',
  82                         'owner_uuid': 'zzzzz-8i9sb-zzzzzzzzzzzzzzz',
  83                         'output_path': '/var/spool/cwl',
  84                         'output_ttl': 0,
  85                         'container_image': 'arvados/jobs',
  86                         'command': ['ls', '/var/spool/cwl'],
  87                         'cwd': '/var/spool/cwl',
  88                         'scheduling_parameters': {},
  89                         'properties': {},
  90                         'secret_mounts': {}
  91                     }))
  92
  93     # The test passes some fields in builder.resources
  94     # For the remaining fields, the defaults will apply: {'cores': 1, 'ram': 1024, 'outdirSize': 1024, 'tmpdirSize': 1024}
  95     @mock.patch("arvados.commands.keepdocker.list_images_in_arv")
  96     def test_resource_requirements(self, keepdocker):
  97         arv_docker_clear_cache()
  98         runner = mock.MagicMock()
  99         runner.project_uuid = "zzzzz-8i9sb-zzzzzzzzzzzzzzz"
 100         runner.ignore_docker_for_reuse = False
 101         runner.intermediate_output_ttl = 3600
 102         runner.secret_store = cwltool.secrets.SecretStore()
 103
 104         document_loader, avsc_names, schema_metadata, metaschema_loader = cwltool.process.get_schema("v1.0")
 105
 106         keepdocker.return_value = [("zzzzz-4zz18-zzzzzzzzzzzzzz3", "")]
 107         runner.api.collections().get().execute.return_value = {
 108             "portable_data_hash": "99999999999999999999999999999993+99"}
 109
 110         tool = cmap({
 111             "inputs": [],
 112             "outputs": [],
 113             "hints": [{
 114                 "class": "ResourceRequirement",
 115                 "coresMin": 3,
 116                 "ramMin": 3000,
 117                 "tmpdirMin": 4000,
 118                 "outdirMin": 5000
 119             }, {
 120                 "class": "http://arvados.org/cwl#RuntimeConstraints",
 121                 "keep_cache": 512
 122             }, {
 123                 "class": "http://arvados.org/cwl#APIRequirement",
 124             }, {
 125                 "class": "http://arvados.org/cwl#PartitionRequirement",
 126                 "partition": "blurb"
 127             }, {
 128                 "class": "http://arvados.org/cwl#IntermediateOutput",
 129                 "outputTTL": 7200
 130             }, {
 131                 "class": "http://arvados.org/cwl#ReuseRequirement",
 132                 "enableReuse": False
 133             }],
 134             "baseCommand": "ls",
 135             "id": "#",
 136             "class": "CommandLineTool"
 137         })
 138         make_fs_access=functools.partial(arvados_cwl.CollectionFsAccess,
 139                                          collection_cache=arvados_cwl.CollectionCache(runner.api, None, 0))
 140         arvtool = arvados_cwl.ArvadosCommandTool(runner, tool, work_api="containers",
 141                                                  avsc_names=avsc_names, make_fs_access=make_fs_access,
 142                                                  loader=Loader({}))
 143         arvtool.formatgraph = None
 144         for j in arvtool.job({}, mock.MagicMock(), basedir="", name="test_resource_requirements",
 145                              make_fs_access=make_fs_access, tmpdir="/tmp"):
 146             j.run(enable_reuse=True, priority=500)
 147
 148         call_args, call_kwargs = runner.api.container_requests().create.call_args
 149
 150         call_body_expected = {
 151             'environment': {
 152                 'HOME': '/var/spool/cwl',
 153                 'TMPDIR': '/tmp'
 154             },
 155             'name': 'test_resource_requirements',
 156             'runtime_constraints': {
 157                 'vcpus': 3,
 158                 'ram': 3145728000,
 159                 'keep_cache_ram': 536870912,
 160                 'API': True
 161             },
 162             'use_existing': False,
 163             'priority': 500,
 164             'mounts': {
 165                 '/tmp': {'kind': 'tmp',
 166                          "capacity": 4194304000 },
 167                 '/var/spool/cwl': {'kind': 'tmp',
 168                                    "capacity": 5242880000 }
 169             },
 170             'state': 'Committed',
 171             'owner_uuid': 'zzzzz-8i9sb-zzzzzzzzzzzzzzz',
 172             'output_path': '/var/spool/cwl',
 173             'output_ttl': 7200,
 174             'container_image': 'arvados/jobs',
 175             'command': ['ls'],
 176             'cwd': '/var/spool/cwl',
 177             'scheduling_parameters': {
 178                 'partitions': ['blurb']
 179             },
 180             'properties': {},
 181             'secret_mounts': {}
 182         }
 183
 184         call_body = call_kwargs.get('body', None)
 185         self.assertNotEqual(None, call_body)
 186         for key in call_body:
 187             self.assertEqual(call_body_expected.get(key), call_body.get(key))
 188
 189
 190     # The test passes some fields in builder.resources
 191     # For the remaining fields, the defaults will apply: {'cores': 1, 'ram': 1024, 'outdirSize': 1024, 'tmpdirSize': 1024}
 192     @mock.patch("arvados.commands.keepdocker.list_images_in_arv")
 193     @mock.patch("arvados.collection.Collection")
 194     def test_initial_work_dir(self, collection_mock, keepdocker):
 195         arv_docker_clear_cache()
 196         runner = mock.MagicMock()
 197         runner.project_uuid = "zzzzz-8i9sb-zzzzzzzzzzzzzzz"
 198         runner.ignore_docker_for_reuse = False
 199         runner.intermediate_output_ttl = 0
 200         runner.secret_store = cwltool.secrets.SecretStore()
 201
 202         document_loader, avsc_names, schema_metadata, metaschema_loader = cwltool.process.get_schema("v1.0")
 203
 204         keepdocker.return_value = [("zzzzz-4zz18-zzzzzzzzzzzzzz3", "")]
 205         runner.api.collections().get().execute.return_value = {
 206             "portable_data_hash": "99999999999999999999999999999993+99"}
 207
 208         sourcemock = mock.MagicMock()
 209         def get_collection_mock(p):
 210             if "/" in p:
 211                 return (sourcemock, p.split("/", 1)[1])
 212             else:
 213                 return (sourcemock, "")
 214         runner.fs_access.get_collection.side_effect = get_collection_mock
 215
 216         vwdmock = mock.MagicMock()
 217         collection_mock.return_value = vwdmock
 218         vwdmock.portable_data_hash.return_value = "99999999999999999999999999999996+99"
 219
 220         tool = cmap({
 221             "inputs": [],
 222             "outputs": [],
 223             "hints": [{
 224                 "class": "InitialWorkDirRequirement",
 225                 "listing": [{
 226                     "class": "File",
 227                     "basename": "foo",
 228                     "location": "keep:99999999999999999999999999999995+99/bar"
 229                 },
 230                 {
 231                     "class": "Directory",
 232                     "basename": "foo2",
 233                     "location": "keep:99999999999999999999999999999995+99"
 234                 },
 235                 {
 236                     "class": "File",
 237                     "basename": "filename",
 238                     "location": "keep:99999999999999999999999999999995+99/baz/filename"
 239                 },
 240                 {
 241                     "class": "Directory",
 242                     "basename": "subdir",
 243                     "location": "keep:99999999999999999999999999999995+99/subdir"
 244                 }                        ]
 245             }],
 246             "baseCommand": "ls",
 247             "id": "#",
 248             "class": "CommandLineTool"
 249         })
 250         make_fs_access=functools.partial(arvados_cwl.CollectionFsAccess,
 251                                          collection_cache=arvados_cwl.CollectionCache(runner.api, None, 0))
 252         arvtool = arvados_cwl.ArvadosCommandTool(runner, tool, work_api="containers",
 253                                                  avsc_names=avsc_names, make_fs_access=make_fs_access,
 254                                                  loader=Loader({}))
 255         arvtool.formatgraph = None
 256         for j in arvtool.job({}, mock.MagicMock(), basedir="", name="test_initial_work_dir",
 257                              make_fs_access=make_fs_access, tmpdir="/tmp"):
 258             j.run(priority=500)
 259
 260         call_args, call_kwargs = runner.api.container_requests().create.call_args
 261
 262         vwdmock.copy.assert_has_calls([mock.call('bar', 'foo', source_collection=sourcemock)])
 263         vwdmock.copy.assert_has_calls([mock.call('', 'foo2', source_collection=sourcemock)])
 264         vwdmock.copy.assert_has_calls([mock.call('baz/filename', 'filename', source_collection=sourcemock)])
 265         vwdmock.copy.assert_has_calls([mock.call('subdir', 'subdir', source_collection=sourcemock)])
 266
 267         call_body_expected = {
 268             'environment': {
 269                 'HOME': '/var/spool/cwl',
 270                 'TMPDIR': '/tmp'
 271             },
 272             'name': 'test_initial_work_dir',
 273             'runtime_constraints': {
 274                 'vcpus': 1,
 275                 'ram': 1073741824
 276             },
 277             'use_existing': True,
 278             'priority': 500,
 279             'mounts': {
 280                 '/tmp': {'kind': 'tmp',
 281                          "capacity": 1073741824 },
 282                 '/var/spool/cwl': {'kind': 'tmp',
 283                                    "capacity": 1073741824 },
 284                 '/var/spool/cwl/foo': {
 285                     'kind': 'collection',
 286                     'path': 'foo',
 287                     'portable_data_hash': '99999999999999999999999999999996+99'
 288                 },
 289                 '/var/spool/cwl/foo2': {
 290                     'kind': 'collection',
 291                     'path': 'foo2',
 292                     'portable_data_hash': '99999999999999999999999999999996+99'
 293                 },
 294                 '/var/spool/cwl/filename': {
 295                     'kind': 'collection',
 296                     'path': 'filename',
 297                     'portable_data_hash': '99999999999999999999999999999996+99'
 298                 },
 299                 '/var/spool/cwl/subdir': {
 300                     'kind': 'collection',
 301                     'path': 'subdir',
 302                     'portable_data_hash': '99999999999999999999999999999996+99'
 303                 }
 304             },
 305             'state': 'Committed',
 306             'owner_uuid': 'zzzzz-8i9sb-zzzzzzzzzzzzzzz',
 307             'output_path': '/var/spool/cwl',
 308             'output_ttl': 0,
 309             'container_image': 'arvados/jobs',
 310             'command': ['ls'],
 311             'cwd': '/var/spool/cwl',
 312             'scheduling_parameters': {
 313             },
 314             'properties': {},
 315             'secret_mounts': {}
 316         }
 317
 318         call_body = call_kwargs.get('body', None)
 319         self.assertNotEqual(None, call_body)
 320         for key in call_body:
 321             self.assertEqual(call_body_expected.get(key), call_body.get(key))
 322
 323
 324     # Test redirecting stdin/stdout/stderr
 325     @mock.patch("arvados.commands.keepdocker.list_images_in_arv")
 326     def test_redirects(self, keepdocker):
 327         arv_docker_clear_cache()
 328
 329         runner = mock.MagicMock()
 330         runner.project_uuid = "zzzzz-8i9sb-zzzzzzzzzzzzzzz"
 331         runner.ignore_docker_for_reuse = False
 332         runner.intermediate_output_ttl = 0
 333         runner.secret_store = cwltool.secrets.SecretStore()
 334
 335         keepdocker.return_value = [("zzzzz-4zz18-zzzzzzzzzzzzzz3", "")]
 336         runner.api.collections().get().execute.return_value = {
 337             "portable_data_hash": "99999999999999999999999999999993+99"}
 338
 339         document_loader, avsc_names, schema_metadata, metaschema_loader = cwltool.process.get_schema("v1.0")
 340
 341         tool = cmap({
 342             "inputs": [],
 343             "outputs": [],
 344             "baseCommand": "ls",
 345             "stdout": "stdout.txt",
 346             "stderr": "stderr.txt",
 347             "stdin": "/keep/99999999999999999999999999999996+99/file.txt",
 348             "arguments": [{"valueFrom": "$(runtime.outdir)"}],
 349             "id": "#",
 350             "class": "CommandLineTool"
 351         })
 352         make_fs_access=functools.partial(arvados_cwl.CollectionFsAccess,
 353                                          collection_cache=arvados_cwl.CollectionCache(runner.api, None, 0))
 354         arvtool = arvados_cwl.ArvadosCommandTool(runner, tool, work_api="containers", avsc_names=avsc_names,
 355                                                  basedir="", make_fs_access=make_fs_access, loader=Loader({}))
 356         arvtool.formatgraph = None
 357         for j in arvtool.job({}, mock.MagicMock(), basedir="", name="test_run_redirect",
 358                              make_fs_access=make_fs_access, tmpdir="/tmp"):
 359             j.run(priority=500)
 360             runner.api.container_requests().create.assert_called_with(
 361                 body=JsonDiffMatcher({
 362                     'environment': {
 363                         'HOME': '/var/spool/cwl',
 364                         'TMPDIR': '/tmp'
 365                     },
 366                     'name': 'test_run_redirect',
 367                     'runtime_constraints': {
 368                         'vcpus': 1,
 369                         'ram': 1073741824
 370                     },
 371                     'use_existing': True,
 372                     'priority': 500,
 373                     'mounts': {
 374                         '/tmp': {'kind': 'tmp',
 375                                  "capacity": 1073741824 },
 376                         '/var/spool/cwl': {'kind': 'tmp',
 377                                            "capacity": 1073741824 },
 378                         "stderr": {
 379                             "kind": "file",
 380                             "path": "/var/spool/cwl/stderr.txt"
 381                         },
 382                         "stdin": {
 383                             "kind": "collection",
 384                             "path": "file.txt",
 385                             "portable_data_hash": "99999999999999999999999999999996+99"
 386                         },
 387                         "stdout": {
 388                             "kind": "file",
 389                             "path": "/var/spool/cwl/stdout.txt"
 390                         },
 391                     },
 392                     'state': 'Committed',
 393                     'owner_uuid': 'zzzzz-8i9sb-zzzzzzzzzzzzzzz',
 394                     'output_path': '/var/spool/cwl',
 395                     'output_ttl': 0,
 396                     'container_image': 'arvados/jobs',
 397                     'command': ['ls', '/var/spool/cwl'],
 398                     'cwd': '/var/spool/cwl',
 399                     'scheduling_parameters': {},
 400                     'properties': {},
 401                     'secret_mounts': {}
 402                 }))
 403
 404     @mock.patch("arvados.collection.Collection")
 405     def test_done(self, col):
 406         api = mock.MagicMock()
 407
 408         runner = mock.MagicMock()
 409         runner.api = api
 410         runner.project_uuid = "zzzzz-8i9sb-zzzzzzzzzzzzzzz"
 411         runner.num_retries = 0
 412         runner.ignore_docker_for_reuse = False
 413         runner.intermediate_output_ttl = 0
 414         runner.secret_store = cwltool.secrets.SecretStore()
 415
 416         runner.api.containers().get().execute.return_value = {"state":"Complete",
 417                                                               "output": "abc+123",
 418                                                               "exit_code": 0}
 419
 420         col().open.return_value = []
 421
 422         arvjob = arvados_cwl.ArvadosContainer(runner)
 423         arvjob.name = "testjob"
 424         arvjob.builder = mock.MagicMock()
 425         arvjob.output_callback = mock.MagicMock()
 426         arvjob.collect_outputs = mock.MagicMock()
 427         arvjob.successCodes = [0]
 428         arvjob.outdir = "/var/spool/cwl"
 429         arvjob.output_ttl = 3600
 430
 431         arvjob.collect_outputs.return_value = {"out": "stuff"}
 432
 433         arvjob.done({
 434             "state": "Final",
 435             "log_uuid": "zzzzz-4zz18-zzzzzzzzzzzzzz1",
 436             "output_uuid": "zzzzz-4zz18-zzzzzzzzzzzzzz2",
 437             "uuid": "zzzzz-xvhdp-zzzzzzzzzzzzzzz",
 438             "container_uuid": "zzzzz-8i9sb-zzzzzzzzzzzzzzz",
 439             "modified_at": "2017-05-26T12:01:22Z"
 440         })
 441
 442         self.assertFalse(api.collections().create.called)
 443
 444         arvjob.collect_outputs.assert_called_with("keep:abc+123")
 445         arvjob.output_callback.assert_called_with({"out": "stuff"}, "success")
 446         runner.add_intermediate_output.assert_called_with("zzzzz-4zz18-zzzzzzzzzzzzzz2")
 447
 448     # The test passes no builder.resources
 449     # Hence the default resources will apply: {'cores': 1, 'ram': 1024, 'outdirSize': 1024, 'tmpdirSize': 1024}
 450     @mock.patch("arvados.commands.keepdocker.list_images_in_arv")
 451     def test_mounts(self, keepdocker):
 452         arv_docker_clear_cache()
 453
 454         runner = mock.MagicMock()
 455         runner.project_uuid = "zzzzz-8i9sb-zzzzzzzzzzzzzzz"
 456         runner.ignore_docker_for_reuse = False
 457         runner.intermediate_output_ttl = 0
 458         runner.secret_store = cwltool.secrets.SecretStore()
 459
 460         keepdocker.return_value = [("zzzzz-4zz18-zzzzzzzzzzzzzz3", "")]
 461         runner.api.collections().get().execute.return_value = {
 462             "portable_data_hash": "99999999999999999999999999999993+99"}
 463
 464         document_loader, avsc_names, schema_metadata, metaschema_loader = cwltool.process.get_schema("v1.0")
 465
 466         tool = cmap({
 467             "inputs": [
 468                 {"id": "p1",
 469                  "type": "Directory"}
 470             ],
 471             "outputs": [],
 472             "baseCommand": "ls",
 473             "arguments": [{"valueFrom": "$(runtime.outdir)"}],
 474             "id": "#",
 475             "class": "CommandLineTool"
 476         })
 477         make_fs_access=functools.partial(arvados_cwl.CollectionFsAccess,
 478                                      collection_cache=arvados_cwl.CollectionCache(runner.api, None, 0))
 479         arvtool = arvados_cwl.ArvadosCommandTool(runner, tool, work_api="containers", avsc_names=avsc_names,
 480                                                  basedir="", make_fs_access=make_fs_access, loader=Loader({}))
 481         arvtool.formatgraph = None
 482         job_order = {
 483             "p1": {
 484                 "class": "Directory",
 485                 "location": "keep:99999999999999999999999999999994+44",
 486                 "listing": [
 487                     {
 488                         "class": "File",
 489                         "location": "keep:99999999999999999999999999999994+44/file1",
 490                     },
 491                     {
 492                         "class": "File",
 493                         "location": "keep:99999999999999999999999999999994+44/file2",
 494                     }
 495                 ]
 496             }
 497         }
 498         for j in arvtool.job(job_order, mock.MagicMock(), basedir="", name="test_run_mounts",
 499                              make_fs_access=make_fs_access, tmpdir="/tmp"):
 500             j.run(priority=500)
 501             runner.api.container_requests().create.assert_called_with(
 502                 body=JsonDiffMatcher({
 503                     'environment': {
 504                         'HOME': '/var/spool/cwl',
 505                         'TMPDIR': '/tmp'
 506                     },
 507                     'name': 'test_run_mounts',
 508                     'runtime_constraints': {
 509                         'vcpus': 1,
 510                         'ram': 1073741824
 511                     },
 512                     'use_existing': True,
 513                     'priority': 500,
 514                     'mounts': {
 515                         "/keep/99999999999999999999999999999994+44": {
 516                             "kind": "collection",
 517                             "portable_data_hash": "99999999999999999999999999999994+44"
 518                         },
 519                         '/tmp': {'kind': 'tmp',
 520                                  "capacity": 1073741824 },
 521                         '/var/spool/cwl': {'kind': 'tmp',
 522                                            "capacity": 1073741824 }
 523                     },
 524                     'state': 'Committed',
 525                     'owner_uuid': 'zzzzz-8i9sb-zzzzzzzzzzzzzzz',
 526                     'output_path': '/var/spool/cwl',
 527                     'output_ttl': 0,
 528                     'container_image': 'arvados/jobs',
 529                     'command': ['ls', '/var/spool/cwl'],
 530                     'cwd': '/var/spool/cwl',
 531                     'scheduling_parameters': {},
 532                     'properties': {},
 533                     'secret_mounts': {}
 534                 }))
 535
 536     # The test passes no builder.resources
 537     # Hence the default resources will apply: {'cores': 1, 'ram': 1024, 'outdirSize': 1024, 'tmpdirSize': 1024}
 538     @mock.patch("arvados.commands.keepdocker.list_images_in_arv")
 539     def test_secrets(self, keepdocker):
 540         arv_docker_clear_cache()
 541
 542         runner = mock.MagicMock()
 543         runner.project_uuid = "zzzzz-8i9sb-zzzzzzzzzzzzzzz"
 544         runner.ignore_docker_for_reuse = False
 545         runner.intermediate_output_ttl = 0
 546         runner.secret_store = cwltool.secrets.SecretStore()
 547
 548         keepdocker.return_value = [("zzzzz-4zz18-zzzzzzzzzzzzzz3", "")]
 549         runner.api.collections().get().execute.return_value = {
 550             "portable_data_hash": "99999999999999999999999999999993+99"}
 551
 552         document_loader, avsc_names, schema_metadata, metaschema_loader = cwltool.process.get_schema("v1.0")
 553
 554         tool = cmap({"arguments": ["md5sum", "example.conf"],
 555                      "class": "CommandLineTool",
 556                      "hints": [
 557                          {
 558                              "class": "http://commonwl.org/cwltool#Secrets",
 559                              "secrets": [
 560                                  "#secret_job.cwl/pw"
 561                              ]
 562                          }
 563                      ],
 564                      "id": "#secret_job.cwl",
 565                      "inputs": [
 566                          {
 567                              "id": "#secret_job.cwl/pw",
 568                              "type": "string"
 569                          }
 570                      ],
 571                      "outputs": [
 572                      ],
 573                      "requirements": [
 574                          {
 575                              "class": "InitialWorkDirRequirement",
 576                              "listing": [
 577                                  {
 578                                      "entry": "username: user\npassword: $(inputs.pw)\n",
 579                                      "entryname": "example.conf"
 580                                  }
 581                              ]
 582                          }
 583                      ]})
 584         make_fs_access=functools.partial(arvados_cwl.CollectionFsAccess,
 585                                      collection_cache=arvados_cwl.CollectionCache(runner.api, None, 0))
 586         arvtool = arvados_cwl.ArvadosCommandTool(runner, tool, work_api="containers", avsc_names=avsc_names,
 587                                                  basedir="", make_fs_access=make_fs_access, loader=Loader({}))
 588         arvtool.formatgraph = None
 589
 590         job_order = {"pw": "blorp"}
 591         runner.secret_store.store(["pw"], job_order)
 592
 593         for j in arvtool.job(job_order, mock.MagicMock(), basedir="", name="test_secrets",
 594                              make_fs_access=make_fs_access, tmpdir="/tmp"):
 595             j.run(enable_reuse=True, priority=500)
 596             runner.api.container_requests().create.assert_called_with(
 597                 body=JsonDiffMatcher({
 598                     'environment': {
 599                         'HOME': '/var/spool/cwl',
 600                         'TMPDIR': '/tmp'
 601                     },
 602                     'name': 'test_secrets',
 603                     'runtime_constraints': {
 604                         'vcpus': 1,
 605                         'ram': 1073741824
 606                     },
 607                     'use_existing': True,
 608                     'priority': 500,
 609                     'mounts': {
 610                         '/tmp': {'kind': 'tmp',
 611                                  "capacity": 1073741824
 612                              },
 613                         '/var/spool/cwl': {'kind': 'tmp',
 614                                            "capacity": 1073741824 }
 615                     },
 616                     'state': 'Committed',
 617                     'owner_uuid': 'zzzzz-8i9sb-zzzzzzzzzzzzzzz',
 618                     'output_path': '/var/spool/cwl',
 619                     'output_ttl': 0,
 620                     'container_image': 'arvados/jobs',
 621                     'command': ['md5sum', 'example.conf'],
 622                     'cwd': '/var/spool/cwl',
 623                     'scheduling_parameters': {},
 624                     'properties': {},
 625                     "secret_mounts": {
 626                         "/var/spool/cwl/example.conf": {
 627                             "content": "username: user\npassword: blorp\n",
 628                             "kind": "text"
 629                         }
 630                     }
 631                 }))