[Notes] [Git][BuildStream/buildstream][willsalmon/defaultWorkspaces] 2 commits: tests/frontend/workspace.py: Refactor of support functions.



Title: GitLab

Will Salmon pushed to branch willsalmon/defaultWorkspaces at BuildStream / buildstream

Commits:

8 changed files:

Changes:

  • tests/examples/developing.py
    ... ... @@ -55,7 +55,7 @@ def test_open_workspace(cli, tmpdir, datafiles):
    55 55
         project = os.path.join(datafiles.dirname, datafiles.basename)
    
    56 56
         workspace_dir = os.path.join(str(tmpdir), "workspace_hello")
    
    57 57
     
    
    58
    -    result = cli.run(project=project, args=['workspace', 'open', '-f', 'hello.bst', workspace_dir])
    
    58
    +    result = cli.run(project=project, args=['workspace', 'open', '-f', '--directory', workspace_dir, 'hello.bst', ])
    
    59 59
         result.assert_success()
    
    60 60
     
    
    61 61
         result = cli.run(project=project, args=['workspace', 'list'])
    
    ... ... @@ -72,7 +72,7 @@ def test_make_change_in_workspace(cli, tmpdir, datafiles):
    72 72
         project = os.path.join(datafiles.dirname, datafiles.basename)
    
    73 73
         workspace_dir = os.path.join(str(tmpdir), "workspace_hello")
    
    74 74
     
    
    75
    -    result = cli.run(project=project, args=['workspace', 'open', '-f', 'hello.bst', workspace_dir])
    
    75
    +    result = cli.run(project=project, args=['workspace', 'open', '-f', '--directory', workspace_dir, 'hello.bst'])
    
    76 76
         result.assert_success()
    
    77 77
     
    
    78 78
         result = cli.run(project=project, args=['workspace', 'list'])
    

  • tests/examples/junctions.py
    ... ... @@ -44,7 +44,7 @@ def test_open_cross_junction_workspace(cli, tmpdir, datafiles):
    44 44
         workspace_dir = os.path.join(str(tmpdir), "workspace_hello_junction")
    
    45 45
     
    
    46 46
         result = cli.run(project=project,
    
    47
    -                     args=['workspace', 'open', 'hello-junction.bst:hello.bst', workspace_dir])
    
    47
    +                     args=['workspace', 'open', '--directory', workspace_dir, 'hello-junction.bst:hello.bst'])
    
    48 48
         result.assert_success()
    
    49 49
     
    
    50 50
         result = cli.run(project=project,
    

  • tests/frontend/buildcheckout.py
    ... ... @@ -509,7 +509,7 @@ def test_build_checkout_workspaced_junction(cli, tmpdir, datafiles):
    509 509
     
    
    510 510
         # Now open a workspace on the junction
    
    511 511
         #
    
    512
    -    result = cli.run(project=project, args=['workspace', 'open', 'junction.bst', workspace])
    
    512
    +    result = cli.run(project=project, args=['workspace', 'open', '--directory', workspace, 'junction.bst'])
    
    513 513
         result.assert_success()
    
    514 514
         filename = os.path.join(workspace, 'files', 'etc-files', 'etc', 'animal.conf')
    
    515 515
     
    

  • tests/frontend/cross_junction_workspace.py
    ... ... @@ -47,7 +47,7 @@ def open_cross_junction(cli, tmpdir):
    47 47
         workspace = tmpdir.join("workspace")
    
    48 48
     
    
    49 49
         element = 'sub.bst:data.bst'
    
    50
    -    args = ['workspace', 'open', element, str(workspace)]
    
    50
    +    args = ['workspace', 'open', '--directory', str(workspace), element]
    
    51 51
         result = cli.run(project=project, args=args)
    
    52 52
         result.assert_success()
    
    53 53
     
    

  • tests/frontend/workspace.py
    ... ... @@ -21,6 +21,7 @@
    21 21
     #           Phillip Smyth <phillip smyth codethink co uk>
    
    22 22
     #           Jonathan Maw <jonathan maw codethink co uk>
    
    23 23
     #           Richard Maw <richard maw codethink co uk>
    
    24
    +#           William Salmon <will salmon codethink co uk>
    
    24 25
     #
    
    25 26
     
    
    26 27
     import os
    
    ... ... @@ -43,72 +44,195 @@ DATA_DIR = os.path.join(
    43 44
     )
    
    44 45
     
    
    45 46
     
    
    47
    +class WorkspaceCreater():
    
    48
    +    def __init__(self, cli, tmpdir, datafiles, project_path=None):
    
    49
    +        self.cli = cli
    
    50
    +        self.tmpdir = tmpdir
    
    51
    +        self.datafiles = datafiles
    
    52
    +
    
    53
    +        if not project_path:
    
    54
    +            project_path = os.path.join(datafiles.dirname, datafiles.basename)
    
    55
    +        else:
    
    56
    +            shutil.copytree(os.path.join(datafiles.dirname, datafiles.basename), project_path)
    
    57
    +
    
    58
    +        self.project_path = project_path
    
    59
    +        self.bin_files_path = os.path.join(project_path, 'files', 'bin-files')
    
    60
    +
    
    61
    +        self.workspace_cmd = os.path.join(self.project_path, 'workspace_cmd')
    
    62
    +
    
    63
    +    def create_workspace_element(self, kind, track, suffix='', workspace_dir=None,
    
    64
    +                                 element_attrs=None):
    
    65
    +        element_name = 'workspace-test-{}{}.bst'.format(kind, suffix)
    
    66
    +        element_path = os.path.join(self.project_path, 'elements')
    
    67
    +        if not workspace_dir:
    
    68
    +            workspace_dir = os.path.join(self.workspace_cmd, element_name.rstrip('.bst'))
    
    69
    +
    
    70
    +        # Create our repo object of the given source type with
    
    71
    +        # the bin files, and then collect the initial ref.
    
    72
    +        repo = create_repo(kind, str(self.tmpdir))
    
    73
    +        ref = repo.create(self.bin_files_path)
    
    74
    +        if track:
    
    75
    +            ref = None
    
    76
    +
    
    77
    +        # Write out our test target
    
    78
    +        element = {
    
    79
    +            'kind': 'import',
    
    80
    +            'sources': [
    
    81
    +                repo.source_config(ref=ref)
    
    82
    +            ]
    
    83
    +        }
    
    84
    +        if element_attrs:
    
    85
    +            element = {**element, **element_attrs}
    
    86
    +        _yaml.dump(element,
    
    87
    +                   os.path.join(element_path,
    
    88
    +                                element_name))
    
    89
    +        return element_name, element_path, workspace_dir
    
    90
    +
    
    91
    +    def create_workspace_elements(self, kinds, track, suffixs=None, workspace_dir_usr=None,
    
    92
    +                                  element_attrs=None):
    
    93
    +
    
    94
    +        element_tuples = []
    
    95
    +
    
    96
    +        if suffixs is None:
    
    97
    +            suffixs = ['', ] * len(kinds)
    
    98
    +        else:
    
    99
    +            if len(suffixs) != len(kinds):
    
    100
    +                raise "terable error"
    
    101
    +
    
    102
    +        for suffix, kind in zip(suffixs, kinds):
    
    103
    +            element_name, element_path, workspace_dir = \
    
    104
    +                self.create_workspace_element(kind, track, suffix, workspace_dir_usr,
    
    105
    +                                              element_attrs)
    
    106
    +
    
    107
    +            # Assert that there is no reference, a track & fetch is needed
    
    108
    +            state = self.cli.get_element_state(self.project_path, element_name)
    
    109
    +            if track:
    
    110
    +                assert state == 'no reference'
    
    111
    +            else:
    
    112
    +                assert state == 'fetch needed'
    
    113
    +            element_tuples.append((element_name, workspace_dir))
    
    114
    +
    
    115
    +        return element_tuples
    
    116
    +
    
    117
    +    def open_workspaces(self, kinds, track, suffixs=None, workspace_dir=None,
    
    118
    +                        element_attrs=None):
    
    119
    +
    
    120
    +        element_tuples = self.create_workspace_elements(kinds, track, suffixs, workspace_dir,
    
    121
    +                                                 element_attrs)
    
    122
    +        os.makedirs(self.workspace_cmd, exist_ok=True)
    
    123
    +
    
    124
    +        # Now open the workspace, this should have the effect of automatically
    
    125
    +        # tracking & fetching the source from the repo.
    
    126
    +        args = ['workspace', 'open']
    
    127
    +        if track:
    
    128
    +            args.append('--track')
    
    129
    +        if workspace_dir is not None:
    
    130
    +            assert len(results) == 1, "test logic error"
    
    131
    +            _, workspace_dir = results[0]
    
    132
    +            args.extend(['--directory', workspace_dir])
    
    133
    +
    
    134
    +        args.extend([element_name for element_name, workspace_dir_suffix in element_tuples])
    
    135
    +        result = self.cli.run(cwd=self.workspace_cmd, project=self.project_path, args=args)
    
    136
    +
    
    137
    +        result.assert_success()
    
    138
    +
    
    139
    +        for element_name, workspace_dir in element_tuples:
    
    140
    +            # Assert that we are now buildable because the source is
    
    141
    +            # now cached.
    
    142
    +            assert self.cli.get_element_state(self.project_path, element_name) == 'buildable'
    
    143
    +
    
    144
    +            # Check that the executable hello file is found in the workspace
    
    145
    +            filename = os.path.join(workspace_dir, 'usr', 'bin', 'hello')
    
    146
    +            assert os.path.exists(filename)
    
    147
    +
    
    148
    +        return element_tuples
    
    149
    +
    
    150
    +
    
    46 151
     def open_workspace(cli, tmpdir, datafiles, kind, track, suffix='', workspace_dir=None,
    
    47 152
                        project_path=None, element_attrs=None):
    
    48
    -    if not workspace_dir:
    
    49
    -        workspace_dir = os.path.join(str(tmpdir), 'workspace{}'.format(suffix))
    
    50
    -    if not project_path:
    
    51
    -        project_path = os.path.join(datafiles.dirname, datafiles.basename)
    
    52
    -    else:
    
    53
    -        shutil.copytree(os.path.join(datafiles.dirname, datafiles.basename), project_path)
    
    54
    -    bin_files_path = os.path.join(project_path, 'files', 'bin-files')
    
    55
    -    element_path = os.path.join(project_path, 'elements')
    
    56
    -    element_name = 'workspace-test-{}{}.bst'.format(kind, suffix)
    
    153
    +    workspace_object = WorkspaceCreater(cli, tmpdir, datafiles, project_path)
    
    154
    +    workspaces = workspace_object.open_workspaces((kind, ), track, (suffix, ), workspace_dir,
    
    155
    +                                                  element_attrs)
    
    156
    +    assert len(workspaces) == 1
    
    157
    +    element_name, workspace = workspaces[0]
    
    158
    +    return element_name, workspace_object.project_path, workspace
    
    57 159
     
    
    58
    -    # Create our repo object of the given source type with
    
    59
    -    # the bin files, and then collect the initial ref.
    
    60
    -    #
    
    61
    -    repo = create_repo(kind, str(tmpdir))
    
    62
    -    ref = repo.create(bin_files_path)
    
    63
    -    if track:
    
    64
    -        ref = None
    
    65 160
     
    
    66
    -    # Write out our test target
    
    67
    -    element = {
    
    68
    -        'kind': 'import',
    
    69
    -        'sources': [
    
    70
    -            repo.source_config(ref=ref)
    
    71
    -        ]
    
    72
    -    }
    
    73
    -    if element_attrs:
    
    74
    -        element = {**element, **element_attrs}
    
    75
    -    _yaml.dump(element,
    
    76
    -               os.path.join(element_path,
    
    77
    -                            element_name))
    
    161
    +@pytest.mark.datafiles(DATA_DIR)
    
    162
    +@pytest.mark.parametrize("kind", repo_kinds)
    
    163
    +def test_open(cli, tmpdir, datafiles, kind):
    
    164
    +    open_workspace(cli, tmpdir, datafiles, kind, False)
    
    78 165
     
    
    79
    -    # Assert that there is no reference, a track & fetch is needed
    
    80
    -    state = cli.get_element_state(project_path, element_name)
    
    81
    -    if track:
    
    82
    -        assert state == 'no reference'
    
    83
    -    else:
    
    84
    -        assert state == 'fetch needed'
    
    166
    +
    
    167
    +@pytest.mark.datafiles(DATA_DIR)
    
    168
    +def test_open_multi(cli, tmpdir, datafiles):
    
    169
    +
    
    170
    +    workspace_object = WorkspaceCreater(cli, tmpdir, datafiles)
    
    171
    +    workspaces = workspace_object.open_workspaces(repo_kinds, False)
    
    172
    +
    
    173
    +    for (elname, workspace), kind in zip(workspaces, repo_kinds):
    
    174
    +        assert kind in elname
    
    175
    +        workspace_lsdir = os.listdir(workspace)
    
    176
    +        if kind == 'git':
    
    177
    +            assert('.git' in workspace_lsdir)
    
    178
    +        elif kind == 'bzr':
    
    179
    +            assert('.bzr' in workspace_lsdir)
    
    180
    +        else:
    
    181
    +            assert not ('.git' in workspace_lsdir)
    
    182
    +            assert not ('.bzr' in workspace_lsdir)
    
    183
    +
    
    184
    +
    
    185
    +@pytest.mark.datafiles(DATA_DIR)
    
    186
    +def test_open_multi_with_directory(cli, tmpdir, datafiles):
    
    187
    +    workspace_object = WorkspaceCreater(cli, tmpdir, datafiles)
    
    188
    +
    
    189
    +    element_tuples = workspace_object.create_workspace_elements(repo_kinds, False, repo_kinds)
    
    190
    +    os.makedirs(workspace_object.workspace_cmd, exist_ok=True)
    
    191
    +
    
    192
    +    # Now open the workspace, this should have the effect of automatically
    
    193
    +    # tracking & fetching the source from the repo.
    
    194
    +    args = ['workspace', 'open']
    
    195
    +    args.extend(['--directory', 'any/dir/should/fail'])
    
    196
    +
    
    197
    +    args.extend([element_name for element_name, workspace_dir_suffix in element_tuples])
    
    198
    +    result = workspace_object.cli.run(cwd=workspace_object.workspace_cmd, project=workspace_object.project_path,
    
    199
    +                                      args=args)
    
    200
    +
    
    201
    +    result.assert_main_error(ErrorDomain.ARTIFACT, None)
    
    202
    +    assert ("Directory option can only be used if a single element is given" in result.stderr)
    
    203
    +
    
    204
    +
    
    205
    +@pytest.mark.datafiles(DATA_DIR)
    
    206
    +def test_open_defaultlocation(cli, tmpdir, datafiles):
    
    207
    +    workspace_object = WorkspaceCreater(cli, tmpdir, datafiles)
    
    208
    +
    
    209
    +    ((element_name, workspace_dir), ) = workspace_object.create_workspace_elements(['git'], False, ['git'])
    
    210
    +    os.makedirs(workspace_object.workspace_cmd, exist_ok=True)
    
    85 211
     
    
    86 212
         # Now open the workspace, this should have the effect of automatically
    
    87 213
         # tracking & fetching the source from the repo.
    
    88 214
         args = ['workspace', 'open']
    
    89
    -    if track:
    
    90
    -        args.append('--track')
    
    91
    -    args.extend([element_name, workspace_dir])
    
    92
    -    result = cli.run(project=project_path, args=args)
    
    215
    +    args.append(element_name)
    
    216
    +
    
    217
    +    # In the other tests we set the cmd to workspace_object.workspace_cmd with the optional
    
    218
    +    # argument, cwd for the workspace_object.cli.run function. But hear we set the default
    
    219
    +    # workspace location to workspace_object.workspace_cmd and run the cli.run function with
    
    220
    +    # no cwd option so that it runs in the project directory.
    
    221
    +    cli.configure({'workspacedir': workspace_object.workspace_cmd})
    
    222
    +    result = workspace_object.cli.run(project=workspace_object.project_path,
    
    223
    +                                      args=args)
    
    93 224
     
    
    94 225
         result.assert_success()
    
    95 226
     
    
    96
    -    # Assert that we are now buildable because the source is
    
    97
    -    # now cached.
    
    98
    -    assert cli.get_element_state(project_path, element_name) == 'buildable'
    
    227
    +    assert cli.get_element_state(workspace_object.project_path, element_name) == 'buildable'
    
    99 228
     
    
    100 229
         # Check that the executable hello file is found in the workspace
    
    230
    +    # even though the cli.run function was not run with cwd = workspace_object.workspace_cmd
    
    231
    +    # the workspace should be created in there as we used the 'workspacedir' configuration
    
    232
    +    # option.
    
    101 233
         filename = os.path.join(workspace_dir, 'usr', 'bin', 'hello')
    
    102 234
         assert os.path.exists(filename)
    
    103 235
     
    
    104
    -    return (element_name, project_path, workspace_dir)
    
    105
    -
    
    106
    -
    
    107
    -@pytest.mark.datafiles(DATA_DIR)
    
    108
    -@pytest.mark.parametrize("kind", repo_kinds)
    
    109
    -def test_open(cli, tmpdir, datafiles, kind):
    
    110
    -    open_workspace(cli, tmpdir, datafiles, kind, False)
    
    111
    -
    
    112 236
     
    
    113 237
     @pytest.mark.datafiles(DATA_DIR)
    
    114 238
     def test_open_bzr_customize(cli, tmpdir, datafiles):
    
    ... ... @@ -150,7 +274,7 @@ def test_open_force(cli, tmpdir, datafiles, kind):
    150 274
     
    
    151 275
         # Now open the workspace again with --force, this should happily succeed
    
    152 276
         result = cli.run(project=project, args=[
    
    153
    -        'workspace', 'open', '--force', element_name, workspace
    
    277
    +        'workspace', 'open', '--force', '--directory', workspace, element_name
    
    154 278
         ])
    
    155 279
         result.assert_success()
    
    156 280
     
    
    ... ... @@ -165,7 +289,7 @@ def test_open_force_open(cli, tmpdir, datafiles, kind):
    165 289
     
    
    166 290
         # Now open the workspace again with --force, this should happily succeed
    
    167 291
         result = cli.run(project=project, args=[
    
    168
    -        'workspace', 'open', '--force', element_name, workspace
    
    292
    +        'workspace', 'open', '--force', '--directory', workspace, element_name
    
    169 293
         ])
    
    170 294
         result.assert_success()
    
    171 295
     
    
    ... ... @@ -196,7 +320,7 @@ def test_open_force_different_workspace(cli, tmpdir, datafiles, kind):
    196 320
     
    
    197 321
         # Now open the workspace again with --force, this should happily succeed
    
    198 322
         result = cli.run(project=project, args=[
    
    199
    -        'workspace', 'open', '--force', element_name2, workspace
    
    323
    +        'workspace', 'open', '--force', '--directory', workspace, element_name2
    
    200 324
         ])
    
    201 325
     
    
    202 326
         # Assert that the file in workspace 1 has been replaced
    
    ... ... @@ -504,7 +628,7 @@ def test_buildable_no_ref(cli, tmpdir, datafiles):
    504 628
         # Now open the workspace. We don't need to checkout the source though.
    
    505 629
         workspace = os.path.join(str(tmpdir), 'workspace-no-ref')
    
    506 630
         os.makedirs(workspace)
    
    507
    -    args = ['workspace', 'open', '--no-checkout', element_name, workspace]
    
    631
    +    args = ['workspace', 'open', '--no-checkout', '--directory', workspace, element_name]
    
    508 632
         result = cli.run(project=project, args=args)
    
    509 633
         result.assert_success()
    
    510 634
     
    
    ... ... @@ -766,7 +890,7 @@ def test_list_supported_workspace(cli, tmpdir, datafiles, workspace_cfg, expecte
    766 890
                                 element_name))
    
    767 891
     
    
    768 892
         # Make a change to the workspaces file
    
    769
    -    result = cli.run(project=project, args=['workspace', 'open', element_name, workspace])
    
    893
    +    result = cli.run(project=project, args=['workspace', 'open', '--directory', workspace, element_name])
    
    770 894
         result.assert_success()
    
    771 895
         result = cli.run(project=project, args=['workspace', 'close', '--remove-dir', element_name])
    
    772 896
         result.assert_success()
    

  • tests/integration/shell.py
    ... ... @@ -278,7 +278,7 @@ def test_workspace_visible(cli, tmpdir, datafiles):
    278 278
     
    
    279 279
         # Open a workspace on our build failing element
    
    280 280
         #
    
    281
    -    res = cli.run(project=project, args=['workspace', 'open', element_name, workspace])
    
    281
    +    res = cli.run(project=project, args=['workspace', 'open', '--directory', workspace, element_name])
    
    282 282
         assert res.exit_code == 0
    
    283 283
     
    
    284 284
         # Ensure the dependencies of our build failing element are built
    
    ... ... @@ -312,7 +312,7 @@ def test_sysroot_workspace_visible(cli, tmpdir, datafiles):
    312 312
     
    
    313 313
         # Open a workspace on our build failing element
    
    314 314
         #
    
    315
    -    res = cli.run(project=project, args=['workspace', 'open', element_name, workspace])
    
    315
    +    res = cli.run(project=project, args=['workspace', 'open', '--directory', workspace, element_name])
    
    316 316
         assert res.exit_code == 0
    
    317 317
     
    
    318 318
         # Ensure the dependencies of our build failing element are built
    

  • tests/integration/workspace.py
    ... ... @@ -23,7 +23,7 @@ def test_workspace_mount(cli, tmpdir, datafiles):
    23 23
         workspace = os.path.join(cli.directory, 'workspace')
    
    24 24
         element_name = 'workspace/workspace-mount.bst'
    
    25 25
     
    
    26
    -    res = cli.run(project=project, args=['workspace', 'open', element_name, workspace])
    
    26
    +    res = cli.run(project=project, args=['workspace', 'open', '--directory', workspace, element_name])
    
    27 27
         assert res.exit_code == 0
    
    28 28
     
    
    29 29
         res = cli.run(project=project, args=['build', element_name])
    
    ... ... @@ -39,7 +39,7 @@ def test_workspace_commanddir(cli, tmpdir, datafiles):
    39 39
         workspace = os.path.join(cli.directory, 'workspace')
    
    40 40
         element_name = 'workspace/workspace-commanddir.bst'
    
    41 41
     
    
    42
    -    res = cli.run(project=project, args=['workspace', 'open', element_name, workspace])
    
    42
    +    res = cli.run(project=project, args=['workspace', 'open', '--directory', workspace, element_name])
    
    43 43
         assert res.exit_code == 0
    
    44 44
     
    
    45 45
         res = cli.run(project=project, args=['build', element_name])
    
    ... ... @@ -75,7 +75,7 @@ def test_workspace_updated_dependency(cli, tmpdir, datafiles):
    75 75
         _yaml.dump(dependency, os.path.join(element_path, dep_name))
    
    76 76
     
    
    77 77
         # First open the workspace
    
    78
    -    res = cli.run(project=project, args=['workspace', 'open', element_name, workspace])
    
    78
    +    res = cli.run(project=project, args=['workspace', 'open', '--directory', workspace, element_name])
    
    79 79
         assert res.exit_code == 0
    
    80 80
     
    
    81 81
         # We build the workspaced element, so that we have an artifact
    
    ... ... @@ -130,7 +130,7 @@ def test_workspace_update_dependency_failed(cli, tmpdir, datafiles):
    130 130
         _yaml.dump(dependency, os.path.join(element_path, dep_name))
    
    131 131
     
    
    132 132
         # First open the workspace
    
    133
    -    res = cli.run(project=project, args=['workspace', 'open', element_name, workspace])
    
    133
    +    res = cli.run(project=project, args=['workspace', 'open', '--directory', workspace, element_name])
    
    134 134
         assert res.exit_code == 0
    
    135 135
     
    
    136 136
         # We build the workspaced element, so that we have an artifact
    
    ... ... @@ -205,7 +205,7 @@ def test_updated_dependency_nested(cli, tmpdir, datafiles):
    205 205
         _yaml.dump(dependency, os.path.join(element_path, dep_name))
    
    206 206
     
    
    207 207
         # First open the workspace
    
    208
    -    res = cli.run(project=project, args=['workspace', 'open', element_name, workspace])
    
    208
    +    res = cli.run(project=project, args=['workspace', 'open', '--directory', workspace, element_name])
    
    209 209
         assert res.exit_code == 0
    
    210 210
     
    
    211 211
         # We build the workspaced element, so that we have an artifact
    
    ... ... @@ -258,7 +258,7 @@ def test_incremental_configure_commands_run_only_once(cli, tmpdir, datafiles):
    258 258
         _yaml.dump(element, os.path.join(element_path, element_name))
    
    259 259
     
    
    260 260
         # We open a workspace on the above element
    
    261
    -    res = cli.run(project=project, args=['workspace', 'open', element_name, workspace])
    
    261
    +    res = cli.run(project=project, args=['workspace', 'open', '--directory', workspace, element_name])
    
    262 262
         res.assert_success()
    
    263 263
     
    
    264 264
         # Then we build, and check whether the configure step succeeded
    

  • tests/plugins/filter.py
    ... ... @@ -108,7 +108,7 @@ def test_filter_forbid_also_rdep(datafiles, cli):
    108 108
     def test_filter_workspace_open(datafiles, cli, tmpdir):
    
    109 109
         project = os.path.join(datafiles.dirname, datafiles.basename)
    
    110 110
         workspace_dir = os.path.join(tmpdir.dirname, tmpdir.basename, "workspace")
    
    111
    -    result = cli.run(project=project, args=['workspace', 'open', 'deps-permitted.bst', workspace_dir])
    
    111
    +    result = cli.run(project=project, args=['workspace', 'open', '--directory', workspace_dir, 'deps-permitted.bst'])
    
    112 112
         result.assert_success()
    
    113 113
         assert os.path.exists(os.path.join(workspace_dir, "foo"))
    
    114 114
         assert os.path.exists(os.path.join(workspace_dir, "bar"))
    
    ... ... @@ -120,7 +120,7 @@ def test_filter_workspace_build(datafiles, cli, tmpdir):
    120 120
         project = os.path.join(datafiles.dirname, datafiles.basename)
    
    121 121
         tempdir = os.path.join(tmpdir.dirname, tmpdir.basename)
    
    122 122
         workspace_dir = os.path.join(tempdir, "workspace")
    
    123
    -    result = cli.run(project=project, args=['workspace', 'open', 'output-orphans.bst', workspace_dir])
    
    123
    +    result = cli.run(project=project, args=['workspace', 'open', '--directory', workspace_dir, 'output-orphans.bst'])
    
    124 124
         result.assert_success()
    
    125 125
         src = os.path.join(workspace_dir, "foo")
    
    126 126
         dst = os.path.join(workspace_dir, "quux")
    
    ... ... @@ -138,7 +138,7 @@ def test_filter_workspace_close(datafiles, cli, tmpdir):
    138 138
         project = os.path.join(datafiles.dirname, datafiles.basename)
    
    139 139
         tempdir = os.path.join(tmpdir.dirname, tmpdir.basename)
    
    140 140
         workspace_dir = os.path.join(tempdir, "workspace")
    
    141
    -    result = cli.run(project=project, args=['workspace', 'open', 'output-orphans.bst', workspace_dir])
    
    141
    +    result = cli.run(project=project, args=['workspace', 'open', '--directory', workspace_dir, 'output-orphans.bst'])
    
    142 142
         result.assert_success()
    
    143 143
         src = os.path.join(workspace_dir, "foo")
    
    144 144
         dst = os.path.join(workspace_dir, "quux")
    
    ... ... @@ -158,7 +158,7 @@ def test_filter_workspace_reset(datafiles, cli, tmpdir):
    158 158
         project = os.path.join(datafiles.dirname, datafiles.basename)
    
    159 159
         tempdir = os.path.join(tmpdir.dirname, tmpdir.basename)
    
    160 160
         workspace_dir = os.path.join(tempdir, "workspace")
    
    161
    -    result = cli.run(project=project, args=['workspace', 'open', 'output-orphans.bst', workspace_dir])
    
    161
    +    result = cli.run(project=project, args=['workspace', 'open', '--directory', workspace_dir, 'output-orphans.bst'])
    
    162 162
         result.assert_success()
    
    163 163
         src = os.path.join(workspace_dir, "foo")
    
    164 164
         dst = os.path.join(workspace_dir, "quux")
    



  • [Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]