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_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 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_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 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_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
