def test_init_with_manifest_filename(repos_tmpdir): # Test 'west init --mf' on a normal repo west_tmpdir = repos_tmpdir / 'workspace' manifest = repos_tmpdir / 'repos' / 'zephyr' with open(manifest / 'west.yml', 'r') as f: manifest_data = f.read() # also creates a west.yml with a syntax error to verify west doesn't even # try to load the file add_commit(str(manifest), 'rename manifest', files={ 'west.yml': '[', 'project.yml': manifest_data }) # syntax error with pytest.raises(subprocess.CalledProcessError): cmd(f'init -m "{manifest}" "{west_tmpdir}"') shutil.move(west_tmpdir, repos_tmpdir / 'workspace-syntaxerror') # success cmd(f'init -m "{manifest}" --mf project.yml "{west_tmpdir}"') west_tmpdir.chdir() config.read_config() cmd('update')
def test_import_project_rolling(repos_tmpdir): # Like test_import_project_release, but with a rolling downstream # that pulls master. We also use west init -l. remotes = repos_tmpdir / 'repos' zephyr = remotes / 'zephyr' ws = repos_tmpdir / 'ws' create_workspace(ws, and_git=True) manifest_repo = ws / 'mp' create_repo(manifest_repo) add_commit(manifest_repo, 'manifest repo commit', # zephyr revision is implicitly master: files={'west.yml': f''' manifest: projects: - name: zephyr url: {zephyr} import: true '''}) cmd(f'init -l {manifest_repo}') with pytest.raises(ManifestImportFailed): Manifest.from_file(topdir=ws) cmd('update', cwd=ws) actual = Manifest.from_file(topdir=ws).projects expected = [ManifestProject(path='mp', topdir=ws), Project('zephyr', zephyr, revision='master', topdir=ws), Project('Kconfiglib', remotes / 'Kconfiglib', revision='zephyr', path='subdir/Kconfiglib', topdir=ws), Project('tagged_repo', remotes / 'tagged_repo', revision='v1.0', topdir=ws), Project('net-tools', remotes / 'net-tools', clone_depth=1, topdir=ws, west_commands='scripts/west-commands.yml')] for a, e in zip(actual, expected): check_proj_consistency(a, e) # Add a commit in the remote zephyr repository and make sure it # *does* affect our local workspace, since we're rolling with its # master branch. zephyr_ws = ws / 'zephyr' head_before = rev_parse(zephyr_ws, 'HEAD') add_commit(zephyr, 'this better show up', files={'should-clone': ''}) cmd('update', cwd=ws) assert head_before != rev_parse(zephyr_ws, 'HEAD') assert (zephyr_ws / 'should-clone').check(file=1)
def update_helper(west_tmpdir, command): # Helper command for causing a change in two remote repositories, # then running a project command on the west installation. # # Adds a commit to both of the kconfiglib and net-tools projects # remotes, then run `command`. # # Captures the 'manifest-rev' and HEAD SHAs in both repositories # before and after running the command, returning them in a tuple # like this: # # (net-tools-manifest-rev-before, # net-tools-manifest-rev-after, # net-tools-HEAD-before, # net-tools-HEAD-after, # kconfiglib-manifest-rev-before, # kconfiglib-manifest-rev-after, # kconfiglib-HEAD-before, # kconfiglib-HEAD-after) nt_remote = str(west_tmpdir.join('..', 'repos', 'net-tools')) nt_local = str(west_tmpdir.join('net-tools')) kl_remote = str(west_tmpdir.join('..', 'repos', 'Kconfiglib')) kl_local = str(west_tmpdir.join('subdir', 'Kconfiglib')) nt_mr_0 = check_output([GIT, 'rev-parse', 'manifest-rev'], cwd=nt_local) kl_mr_0 = check_output([GIT, 'rev-parse', 'manifest-rev'], cwd=kl_local) nt_head_0 = check_output([GIT, 'rev-parse', 'HEAD'], cwd=nt_local) kl_head_0 = check_output([GIT, 'rev-parse', 'HEAD'], cwd=kl_local) add_commit(nt_remote, 'another net-tools commit') add_commit(kl_remote, 'another kconfiglib commit') cmd(command) nt_mr_1 = check_output([GIT, 'rev-parse', 'manifest-rev'], cwd=nt_local) kl_mr_1 = check_output([GIT, 'rev-parse', 'manifest-rev'], cwd=kl_local) nt_head_1 = check_output([GIT, 'rev-parse', 'HEAD'], cwd=nt_local) kl_head_1 = check_output([GIT, 'rev-parse', 'HEAD'], cwd=kl_local) return (nt_mr_0, nt_mr_1, nt_head_0, nt_head_1, kl_mr_0, kl_mr_1, kl_head_0, kl_head_1)
def updater(remotes): # Create a v2.0 tag on the remote tagged_repo repository. add_commit(remotes.tagged_repo, 'another tagged_repo tagged commit') add_tag(remotes.tagged_repo, 'v2.0') # Update the manifest file to point the project's revision at # the new tag. manifest = Manifest.from_file(topdir=west_init_tmpdir) for p in manifest.projects: if p.name == 'tagged_repo': p.revision = 'v2.0' break else: assert False, 'no tagged_repo' with open(west_init_tmpdir / 'zephyr' / 'west.yml', 'w') as f: f.write(manifest.as_yaml()) # NOT as_frozen_yaml(). # Pull down the v2.0 tag into west_init_tmpdir. cmd('update tagged_repo')
def test_update_west(west_init_tmpdir): # Test the 'west selfupdate' command. It calls through to the same backend # functions that are used for automatic updates and 'west init' # reinitialization. # update the net-tools repository cmd('update net-tools') west_prev = head_subject('.west/west') # Add commits to the local repos. We need to reconfigure # explicitly as these are clones, and west doesn't handle that for # us. for path in 'zephyr', '.west/west', 'net-tools': add_commit(path, 'test-update-local', reconfigure=True) # Check that resetting the west repository removes the local commit cmd('selfupdate') assert head_subject('zephyr') == 'test-update-local' # Unaffected assert head_subject('.west/west') == west_prev assert head_subject('net-tools') == 'test-update-local' # Unaffected
def test_update_projects_local_branch_commits(west_init_tmpdir): # Test the 'west update' command when working on local branch with local # commits and then updating project to upstream commit. # It calls through to the same backend functions that are used for # automatic updates and 'west init' reinitialization. # update all repositories cmd('update') # Create a local branch and add commits checkout_branch('net-tools', 'local_net_tools_test_branch', create=True) checkout_branch('subdir/Kconfiglib', 'local_kconfig_test_branch', create=True) add_commit('net-tools', 'test local branch commit', reconfigure=True) add_commit('subdir/Kconfiglib', 'test local branch commit', reconfigure=True) net_tools_prev = head_subject('net-tools') kconfiglib_prev = head_subject('subdir/Kconfiglib') # Add commits to the upstream repos. We need to reconfigure # explicitly as these are clones, and west doesn't handle that for # us. (nt_mr_0, nt_mr_1, nt_head_0, nt_head_1, kl_mr_0, kl_mr_1, kl_head_0, kl_head_1) = update_helper(west_init_tmpdir, 'update') assert nt_mr_0 != nt_mr_1, 'failed to update net-tools manifest-rev' assert nt_head_0 != nt_head_1, 'failed to update net-tools HEAD' assert kl_mr_0 != kl_mr_1, 'failed to update kconfiglib manifest-rev' assert kl_head_0 != kl_head_1, 'failed to update kconfiglib HEAD' # Verify local branch is still present and untouched assert net_tools_prev != head_subject('net-tools') assert kconfiglib_prev != head_subject('subdir/Kconfiglib') checkout_branch('net-tools', 'local_net_tools_test_branch') checkout_branch('subdir/Kconfiglib', 'local_kconfig_test_branch') assert net_tools_prev == head_subject('net-tools') assert kconfiglib_prev == head_subject('subdir/Kconfiglib')
def test_import_project_release_dir(tmpdir): # Tests for a workspace that imports a directory from a project # at a fixed release. remotes = tmpdir / 'remotes' empty_project = remotes / 'empty_project' create_repo(empty_project) add_commit(empty_project, 'empty-project empty commit') imported = remotes / 'imported' create_repo(imported) add_commit(imported, 'add directory of imports', files={'test.d/1.yml': f'''\ manifest: projects: - name: west.d/1.yml-p1 url: {empty_project} - name: west.d/1.yml-p2 url: {empty_project} ''', 'test.d/2.yml': f'''\ manifest: projects: - name: west.d/2.yml-p1 url: {empty_project} '''}) add_tag(imported, 'import-tag') ws = tmpdir / 'ws' create_workspace(ws, and_git=True) manifest_repo = ws / 'mp' add_commit(manifest_repo, 'manifest repo commit', files={'west.yml': f''' manifest: projects: - name: imported url: {imported} revision: import-tag import: test.d '''}) cmd(f'init -l {manifest_repo}') with pytest.raises(ManifestImportFailed): Manifest.from_file(topdir=ws) cmd('update', cwd=ws) actual = Manifest.from_file(topdir=ws).projects expected = [ManifestProject(path='mp', topdir=ws), Project('imported', imported, revision='import-tag', topdir=ws), Project('west.d/1.yml-p1', empty_project, topdir=ws), Project('west.d/1.yml-p2', empty_project, topdir=ws), Project('west.d/2.yml-p1', empty_project, topdir=ws)] for a, e in zip(actual, expected): check_proj_consistency(a, e)
def test_update_projects_local_branch_commits(west_init_tmpdir): # Test the 'west update' command when working on local branch with local # commits and then updating project to upstream commit. # It calls through to the same backend functions that are used for # automatic updates and 'west init' reinitialization. # update all repositories cmd('update') # Create a local branch and add commits checkout_branch('net-tools', 'local_net_tools_test_branch', create=True) checkout_branch('subdir/Kconfiglib', 'local_kconfig_test_branch', create=True) checkout_branch('tagged_repo', 'local_tagged_repo_test_branch', create=True) add_commit('net-tools', 'test local branch commit', reconfigure=True) add_commit('subdir/Kconfiglib', 'test local branch commit', reconfigure=True) add_commit('tagged_repo', 'test local branch commit', reconfigure=True) net_tools_prev = head_subject('net-tools') kconfiglib_prev = head_subject('subdir/Kconfiglib') tagged_repo_prev = head_subject('tagged_repo') # Update the upstream repositories, getting an UpdateResults tuple # back. ur = update_helper(west_init_tmpdir) # We updated all the repositories, so all paths and commits should # be valid refs (i.e. there shouldn't be a None or empty string # value in a ur attribute). assert all(ur) # Verify each repository has moved to a new manifest-rev, # except tagged_repo, which has a manifest-rev locked to a tag. # Its HEAD should change, though. assert ur.nt_mr_0 != ur.nt_mr_1, 'failed updating net-tools manifest-rev' assert ur.kl_mr_0 != ur.kl_mr_1, 'failed updating kconfiglib manifest-rev' assert ur.tr_mr_0 == ur.tr_mr_1, 'tagged_repo manifest-rev changed' assert ur.nt_head_0 != ur.nt_head_1, 'failed updating net-tools HEAD' assert ur.kl_head_0 != ur.kl_head_1, 'failed updating kconfiglib HEAD' assert ur.tr_head_0 != ur.tr_head_1, 'failed updating tagged_repo HEAD' # Verify local branch is still present and untouched assert net_tools_prev != head_subject('net-tools') assert kconfiglib_prev != head_subject('subdir/Kconfiglib') assert tagged_repo_prev != head_subject('tagged_repo') checkout_branch('net-tools', 'local_net_tools_test_branch') checkout_branch('subdir/Kconfiglib', 'local_kconfig_test_branch') checkout_branch('tagged_repo', 'local_tagged_repo_test_branch') assert net_tools_prev == head_subject('net-tools') assert kconfiglib_prev == head_subject('subdir/Kconfiglib') assert tagged_repo_prev == head_subject('tagged_repo')
def test_extension_command_multiproject(repos_tmpdir): # Test to ensure that multiple projects can define extension commands and # that those are correctly presented and executed. rr = repos_tmpdir.join('repos') remote_kconfiglib = str(rr.join('Kconfiglib')) remote_zephyr = str(rr.join('zephyr')) remote_west = str(rr.join('west')) # Update the manifest to specify extension commands in Kconfiglib. add_commit(remote_zephyr, 'test added extension command', files={ 'west.yml': textwrap.dedent('''\ west: url: file://{west} manifest: defaults: remote: test-local remotes: - name: test-local url-base: file://{rr} projects: - name: Kconfiglib revision: zephyr path: subdir/Kconfiglib west-commands: scripts/west-commands.yml - name: net-tools west-commands: scripts/west-commands.yml self: path: zephyr '''.format(west=remote_west, rr=str(rr))) }) # Add an extension command to the Kconfiglib remote. add_commit(remote_kconfiglib, 'add west commands', files={ 'scripts/west-commands.yml': textwrap.dedent('''\ west-commands: - file: scripts/test.py commands: - name: kconfigtest class: Test '''), 'scripts/test.py': textwrap.dedent('''\ from west.commands import WestCommand class Test(WestCommand): def __init__(self): super(Test, self).__init__( 'kconfigtest', 'Kconfig test application', '') def do_add_parser(self, parser_adder): parser = parser_adder.add_parser(self.name) return parser def do_run(self, args, ignored): print('Testing kconfig test') '''), }) west_tmpdir = repos_tmpdir.join('west_installation') cmd('init -m "{}" "{}"'.format(str(repos_tmpdir.join('repos', 'zephyr')), str(west_tmpdir))) west_tmpdir.chdir() config.read_config() cmd('update') help_text = cmd('-h') expected = textwrap.dedent('''\ commands from project at "subdir/Kconfiglib": kconfigtest: (no help provided; try "west kconfigtest -h") commands from project at "net-tools": test: test-help ''') assert expected in help_text actual = cmd('test') assert actual == 'Testing test command 1\n' actual = cmd('kconfigtest') assert actual == 'Testing kconfig test\n'
def test_import_project_release_fork(repos_tmpdir): # Like test_import_project_release(), but with a project fork, # and using west init -l. remotes = repos_tmpdir / 'repos' zephyr = remotes / 'zephyr' add_tag(zephyr, 'zephyr-tag') fork = remotes / 'my-kconfiglib-fork' create_repo(fork) add_commit(fork, 'fork kconfiglib') add_tag(fork, 'fork-tag') ws = repos_tmpdir / 'ws' create_workspace(ws, and_git=True) manifest_repo = ws / 'mp' create_repo(manifest_repo) add_commit(manifest_repo, 'manifest repo commit', files={ 'west.yml': f''' manifest: projects: - name: zephyr url: {zephyr} revision: zephyr-tag import: true - name: Kconfiglib url: {fork} revision: fork-tag ''' }) cmd(f'init -l {manifest_repo}') with pytest.raises(ManifestImportFailed): Manifest.from_file(topdir=ws) cmd('update', cwd=ws) actual = Manifest.from_file(topdir=ws).projects expected = [ ManifestProject(path='mp', topdir=ws), Project('zephyr', zephyr, revision='zephyr-tag', topdir=ws), Project('Kconfiglib', fork, revision='fork-tag', path='Kconfiglib', topdir=ws), Project('tagged_repo', remotes / 'tagged_repo', revision='v1.0', topdir=ws), Project('net-tools', remotes / 'net-tools', clone_depth=1, topdir=ws, west_commands='scripts/west-commands.yml') ] for a, e in zip(actual, expected): check_proj_consistency(a, e) zephyr_ws = ws / 'zephyr' head_before = rev_parse(zephyr_ws, 'HEAD') add_commit(zephyr, 'this better not show up', files={'should-not-clone': ''}) cmd('update', cwd=ws) assert head_before == rev_parse(zephyr_ws, 'HEAD') actual = Manifest.from_file(topdir=ws).projects for a, e in zip(actual, expected): check_proj_consistency(a, e) assert (zephyr_ws / 'should-not-clone').check(file=0)
def test_import_project_release(repos_tmpdir): # Tests for a workspace that's based off of importing from a # project at a fixed release, with no downstream project forks. remotes = repos_tmpdir / 'repos' zephyr = remotes / 'zephyr' add_tag(zephyr, 'test-tag') # For this test, we create a remote manifest repository. This # makes sure we can clone a manifest repository which contains # imports without issue (and we don't need to clone the imported # projects.) # # On subsequent tests, we won't bother with this step. We will # just put the manifest repository directly into the workspace and # use west init -l. This also provides coverage for the -l option # in the presence of imports. manifest_remote = remotes / 'mp' create_repo(manifest_remote) add_commit(manifest_remote, 'manifest repo commit', files={ 'west.yml': f''' manifest: projects: - name: zephyr url: {zephyr} revision: test-tag import: true ''' }) # Create the workspace and verify we can't load the manifest yet # (because some imported data is missing). ws = repos_tmpdir / 'ws' cmd(f'init -m {manifest_remote} {ws}') with pytest.raises(ManifestImportFailed): # We can't load this yet, because we haven't cloned zephyr. Manifest.from_file(topdir=ws) # Run west update and make sure we can load the manifest now. cmd('update', cwd=ws) actual = Manifest.from_file(topdir=ws).projects expected = [ ManifestProject(path='mp', topdir=ws), Project('zephyr', zephyr, revision='test-tag', topdir=ws), Project('Kconfiglib', remotes / 'Kconfiglib', revision='zephyr', path='subdir/Kconfiglib', topdir=ws), Project('tagged_repo', remotes / 'tagged_repo', revision='v1.0', topdir=ws), Project('net-tools', remotes / 'net-tools', clone_depth=1, topdir=ws, west_commands='scripts/west-commands.yml') ] for a, e in zip(actual, expected): check_proj_consistency(a, e) # Add a commit in the remote zephyr repository and make sure it # doesn't affect our local workspace, since we've locked it to a # tag. zephyr_ws = ws / 'zephyr' head_before = rev_parse(zephyr_ws, 'HEAD') add_commit(zephyr, 'this better not show up', files={'should-not-clone': ''}) cmd('update', cwd=ws) assert head_before == rev_parse(zephyr_ws, 'HEAD') actual = Manifest.from_file(topdir=ws).projects for a, e in zip(actual, expected): check_proj_consistency(a, e) assert (zephyr_ws / 'should-not-clone').check(file=0)
def default_updater(remotes): add_commit(remotes.net_tools, 'another net-tools commit') add_commit(remotes.kconfiglib, 'another kconfiglib commit') add_commit(remotes.tagged_repo, 'another tagged_repo commit') cmd('update')
def test_update_recovery(tmpdir): # Make sure that the final 'west update' can recover from the # following turn of events: # # 1. 'm' is the manifest repository, 'p' is a project # 2. m/west.yml imports p at revision 'rbad'; p/west.yml at rbad # contains an invalid manifest # 3. user runs 'west update', setting p's manifest-rev to rbad # (and failing the update) # 4. user updates m/west.yml to point at p revision 'rgood', # which contains good manifest data # 5. user runs 'west update' again # # The 'west update' in the last step should fix p's manifest-rev, # pointing it at rgood, and should succeed. # create path objects and string representations workspace = Path(tmpdir) / 'workspace' workspacestr = os.fspath(workspace) m = workspace / 'm' p = workspace / 'p' # Set up the workspace repositories. workspace.mkdir() create_repo(m) create_repo(p) # Create revision rbad, which contains a bogus manifest, in p. add_commit(p, 'rbad commit message', files={'west.yml': 'bogus_data'}, reconfigure=False) rbad = rev_parse(p, 'HEAD') # Create revision rgood, which contains a good manifest, in p. add_commit(p, 'rgood commit message', files={'west.yml': 'manifest:\n projects: []'}, reconfigure=False) rgood = rev_parse(p, 'HEAD') # Set up the initial, 'bad' manifest. # # Use an invalid local file as the fetch URL: there's no reason # west should be fetching from the remote. with open(m / 'west.yml', 'w') as m_manifest: m_manifest.write(f''' manifest: projects: - name: p url: file://{tmpdir}/should-not-be-fetched revision: {rbad} import: true ''') # Use west init -l + west update to point p's manifest-rev at rbad. cmd(f'init -l {m}', cwd=workspacestr) with pytest.raises(subprocess.CalledProcessError): cmd('update', cwd=workspacestr) # Make sure p's manifest-rev points to the bad revision as expected. prev = rev_parse(p, 'refs/heads/manifest-rev') assert prev == rbad # Fix the main manifest to point at rgood. with open(m / 'west.yml', 'w') as m_manifest: m_manifest.write(f''' manifest: projects: - name: p url: file://{tmpdir}/should-not-be-fetched revision: {rgood} import: true ''') # Run the update, making sure it succeeds and p's manifest-rev # is fixed. cmd('update', cwd=workspacestr) prev = rev_parse(p, 'refs/heads/manifest-rev') assert prev == rgood
def test_extension_command_multiproject(repos_tmpdir): # Test to ensure that multiple projects can define extension commands and # that those are correctly presented and executed. rr = repos_tmpdir.join('repos') remote_kconfiglib = str(rr.join('Kconfiglib')) remote_zephyr = str(rr.join('zephyr')) remote_west = str(rr.join('west')) # Update the manifest to specify extension commands in Kconfiglib. # This removes tagged_repo, but we're not using it, so that's fine. add_commit(remote_zephyr, 'test added extension command', files={ 'west.yml': textwrap.dedent(f'''\ west: url: file://{remote_west} manifest: defaults: remote: test-local remotes: - name: test-local url-base: file://{rr} projects: - name: Kconfiglib revision: zephyr path: subdir/Kconfiglib west-commands: scripts/west-commands.yml - name: net-tools west-commands: scripts/west-commands.yml self: path: zephyr ''') }) # Add an extension command to the Kconfiglib remote. add_commit(remote_kconfiglib, 'add west commands', files={ 'scripts/west-commands.yml': textwrap.dedent('''\ west-commands: - file: scripts/test.py commands: - name: kconfigtest class: Test '''), 'scripts/test.py': textwrap.dedent('''\ from west.commands import WestCommand class Test(WestCommand): def __init__(self): super(Test, self).__init__( 'kconfigtest', 'Kconfig test application', '') def do_add_parser(self, parser_adder): parser = parser_adder.add_parser(self.name) return parser def do_run(self, args, ignored): print('Testing kconfig test') '''), }) west_tmpdir = repos_tmpdir / 'workspace' zephyr = repos_tmpdir / 'repos' / 'zephyr' cmd(f'init -m "{zephyr}" "{west_tmpdir}"') west_tmpdir.chdir() config.read_config() cmd('update') # The newline shenanigans are for Windows. help_text = '\n'.join(cmd('-h').splitlines()) expected = '\n'.join([ 'extension commands from project Kconfiglib (path: subdir/Kconfiglib):', # noqa: E501 ' kconfigtest: (no help provided; try "west kconfigtest -h")', # noqa: E501 '', 'extension commands from project net-tools (path: net-tools):', ' test-extension: test-extension-help' ]) assert expected in help_text, help_text actual = cmd('test-extension') assert actual.rstrip() == 'Testing test command 1' actual = cmd('kconfigtest') assert actual.rstrip() == 'Testing kconfig test'
def test_update_some_with_imports(repos_tmpdir): # 'west update project1 project2' should work fine even when # imports are used, as long as the relevant projects are all # defined in the manifest repository. # # It currently should fail with a helpful message if the projects # are resolved via project imports. remotes = repos_tmpdir / 'repos' zephyr = remotes / 'zephyr' net_tools = remotes / 'net-tools' ws = repos_tmpdir / 'ws' create_workspace(ws, and_git=True) manifest_repo = ws / 'mp' create_repo(manifest_repo) add_commit( manifest_repo, 'manifest repo commit', # zephyr revision is implicitly master: files={ 'west.yml': f''' manifest: projects: - name: zephyr url: {zephyr} import: true self: import: foo.yml ''', 'foo.yml': f''' manifest: projects: - name: net-tools url: {net_tools} ''' }) cmd(f'init -l {manifest_repo}') # Updating unknown projects should fail as always. with pytest.raises(subprocess.CalledProcessError): cmd('update unknown-project', cwd=ws) # Updating a list of projects when some are resolved via project # imports must fail. with pytest.raises(subprocess.CalledProcessError): cmd('update Kconfiglib net-tools', cwd=ws) # Updates of projects defined in the manifest repository or all # projects must succeed, and behave the same as if no imports # existed. cmd('update net-tools', cwd=ws) with pytest.raises(ManifestImportFailed): Manifest.from_file(topdir=ws) manifest = Manifest.from_file(topdir=ws, import_flags=MIF.IGNORE_PROJECTS) projects = manifest.get_projects(['net-tools', 'zephyr']) net_tools_project = projects[0] zephyr_project = projects[1] assert net_tools_project.is_cloned() assert not zephyr_project.is_cloned() cmd('update zephyr', cwd=ws) assert zephyr_project.is_cloned() cmd('update', cwd=ws) manifest = Manifest.from_file(topdir=ws) assert manifest.get_projects(['Kconfiglib'])[0].is_cloned()
def test_extension_command_duplicate(repos_tmpdir): # Test to ensure that in case to subprojects introduces same command, it # will print a warning. rr = repos_tmpdir.join('repos') remote_kconfiglib = str(rr.join('Kconfiglib')) remote_zephyr = str(rr.join('zephyr')) remote_west = str(rr.join('west')) add_commit(remote_zephyr, 'test added extension command', files={ 'west.yml': textwrap.dedent('''\ west: url: file://{west} manifest: defaults: remote: test-local remotes: - name: test-local url-base: file://{rr} projects: - name: Kconfiglib revision: zephyr path: subdir/Kconfiglib west-commands: scripts/west-commands.yml - name: net-tools west-commands: scripts/west-commands.yml self: path: zephyr '''.format(west=remote_west, rr=str(rr))) }) # Initialize the net-tools repository. add_commit(remote_kconfiglib, 'add west commands', files={ 'scripts/west-commands.yml': textwrap.dedent('''\ west-commands: - file: scripts/test.py commands: - name: test class: Test '''), 'scripts/test.py': textwrap.dedent('''\ from west.commands import WestCommand class Test(WestCommand): def __init__(self): super(Test, self).__init__( 'test', 'test application', '') def do_add_parser(self, parser_adder): parser = parser_adder.add_parser(self.name) return parser def do_run(self, args, ignored): print('Testing kconfig test command') '''), }) west_tmpdir = repos_tmpdir.join('west_installation') cmd('init -m "{}" "{}"'.format(str(repos_tmpdir.join('repos', 'zephyr')), str(west_tmpdir))) west_tmpdir.chdir() config.read_config() cmd('update') actual = cmd('test', stderr=subprocess.STDOUT) warning = 'WARNING: ignoring project net-tools extension command "test";'\ ' command "test" already defined as extension command\n' command_out = 'Testing kconfig test command\n' assert actual == warning + command_out
def test_change_remote_conflict(west_update_tmpdir): # Test that `west update` will force fetch into local refs space when # remote has changed and cannot be fast forwarded. wct = west_update_tmpdir tmpdir = wct.join('..') rrepo = str(tmpdir.join('repos')) net_tools = str(tmpdir.join('repos', 'net-tools')) rwest = str(tmpdir.join('repos', 'west')) alt_repo = str(tmpdir.join('alt_repo')) alt_net_tools = str(tmpdir.join('alt_repo', 'net-tools')) create_repo(alt_net_tools) add_commit(alt_net_tools, 'test conflicting commit', files={'qemu-script.sh': 'echo alternate world net-tools\n'}) revision = rev_parse(net_tools, 'HEAD') west_yml_content = textwrap.dedent('''\ west: url: file://{west} manifest: defaults: remote: test-local remotes: - name: test-local url-base: file://{rr} projects: - name: net-tools revision: {rev} self: path: zephyr '''.format(west=rwest, rr=rrepo, rev=revision)) add_commit(str(wct.join('zephyr')), 'test update manifest', files={'west.yml': west_yml_content}) cmd('update') revision = rev_parse(alt_net_tools, 'HEAD') west_yml_content = textwrap.dedent('''\ west: url: file://{west} manifest: defaults: remote: test-local remotes: - name: test-local url-base: file://{rr} - name: test-alternate url-base: file://{ar} projects: - name: net-tools remote: test-alternate revision: {rev} self: path: zephyr '''.format(west=rwest, ar=alt_repo, rr=rrepo, rev=revision)) add_commit(str(wct.join('zephyr')), 'test update manifest conflict', files={'west.yml': west_yml_content}) cmd('update')
def test_extension_command_duplicate(repos_tmpdir): # Test to ensure that in case to subprojects introduces same command, it # will print a warning. rr = repos_tmpdir.join('repos') remote_kconfiglib = str(rr.join('Kconfiglib')) remote_zephyr = str(rr.join('zephyr')) remote_west = str(rr.join('west')) # This removes tagged_repo, but we're not using it, so that's fine. add_commit(remote_zephyr, 'test added extension command', files={ 'west.yml': textwrap.dedent(f'''\ west: url: file://{remote_west} manifest: defaults: remote: test-local remotes: - name: test-local url-base: file://{rr} projects: - name: Kconfiglib revision: zephyr path: subdir/Kconfiglib west-commands: scripts/west-commands.yml - name: net-tools west-commands: scripts/west-commands.yml self: path: zephyr ''') }) # Initialize the net-tools repository. add_commit(remote_kconfiglib, 'add west commands', files={ 'scripts/west-commands.yml': textwrap.dedent('''\ west-commands: - file: scripts/test.py commands: - name: test-extension class: Test '''), 'scripts/test.py': textwrap.dedent('''\ from west.commands import WestCommand class Test(WestCommand): def __init__(self): super(Test, self).__init__( 'test-extension', 'test application', '') def do_add_parser(self, parser_adder): parser = parser_adder.add_parser(self.name) return parser def do_run(self, args, ignored): print('Testing kconfig test command') '''), }) west_tmpdir = repos_tmpdir / 'workspace' zephyr = repos_tmpdir / 'repos' / 'zephyr' cmd(f'init -m "{zephyr}" "{west_tmpdir}"') west_tmpdir.chdir() config.read_config() cmd('update') actual = cmd('test-extension', stderr=subprocess.STDOUT).splitlines() expected = [ 'WARNING: ignoring project net-tools extension command "test-extension"; command "test-extension" is already defined as extension command', # noqa: E501 'Testing kconfig test command', ] assert actual == expected