def test_magic_methods():
d1 = PackageDescriptor('/some/path')
d1.type = 'custom-type'
d1.name = 'custom-name'
d2 = PackageDescriptor('/some/path')
d2.type = 'custom-type'
d2.name = 'other-name'
assert d1 != d2
assert hash(d1) != hash(d2)
d2.name = 'custom-name'
assert d1 == d2
assert hash(d1) == hash(d2)
d1.dependencies['build'].add('build-depend')
d2.hooks.append('hook')
d2.metadata['key'] = 'value'
assert d1 == d2
assert hash(d1) == hash(d2)
d2.type = 'other-type'
assert d1 != d2
assert hash(d1) != hash(d2)
d2.type = 'custom-type'
assert d1 == d2
assert hash(d1) == hash(d2)
d2.path = Path('/other/path')
assert d1 != d2
# comparing with other types always returns False
assert d1 != []
def test_add_recursive_dependencies():
d = PackageDescriptor('/some/path')
d.name = 'A'
d.dependencies['build'].add('B')
d.dependencies['build'].add('c')
d.dependencies['run'].add('D')
d.dependencies['test'].add('e')
d1 = PackageDescriptor('/other/path')
d1.name = 'B'
d1.dependencies['build'].add('f')
d1.dependencies['run'].add('G')
d2 = PackageDescriptor('/other/path')
d2.name = 'D'
d2.dependencies['run'].add('h')
d3 = PackageDescriptor('/another/path')
d3.name = 'G'
d3.dependencies['build'].add('i')
decos = get_decorators([d, d1, d2, d3])
add_recursive_dependencies(decos,
direct_categories={'build', 'run'},
recursive_categories={'run'})
assert decos[0].recursive_dependencies is not None
assert decos[1].recursive_dependencies is not None
assert decos[2].recursive_dependencies is not None
assert decos[3].recursive_dependencies is not None
assert decos[0].recursive_dependencies == {'B', 'D', 'G'}
async def test_include_ros_base():
pkg = PackageDescriptor('package/path')
pkg.name = 'MyPackageName'
pkg.dependencies['run'] = {}
installers = {
'apt': MagicMock(),
}
top_level_args = MagicMock(build_base='build/base',
install_base='install/base',
bundle_base='bundle/base')
args = BundlePackageArguments(pkg, installers, top_level_args)
args.ros_distribution = 'kinetic'
args.exclude_ros_base = False
context = TaskContext(pkg=pkg, args=args, dependencies={})
task = RosBundle()
task.set_context(context=context)
# Concise read on why it's patched this way.
# http://www.voidspace.org.uk/python/mock/patch.html#where-to-patch
with patch('colcon_ros_bundle.task.ros_bundle.RosdepWrapper'
) as wrapper: # noqa: E501
with patch('os.environ') as environ:
environ.__getitem__.side_effect = access_var
wrapper().get_rule.side_effect = _get_rule_side_effect
wrapper().resolve.side_effect = _resolve_side_effect
await task.bundle()
installers['apt'].add_to_install_list.assert_called_with(
'ros-kinetic-ros-base')
def test_identify():
extension = PythonPackageIdentification()
with TemporaryDirectory(prefix='test_colcon_') as basepath:
desc = PackageDescriptor(basepath)
desc.type = 'other'
assert extension.identify(desc) is None
assert desc.name is None
desc.type = None
assert extension.identify(desc) is None
assert desc.name is None
assert desc.type is None
basepath = Path(basepath)
(basepath / 'setup.py').write_text('')
assert extension.identify(desc) is None
assert desc.name is None
assert desc.type is None
(basepath / 'setup.cfg').write_text('')
assert extension.identify(desc) is None
assert desc.name is None
assert desc.type is None
(basepath / 'setup.cfg').write_text('[metadata]\n' 'name = pkg-name\n')
assert extension.identify(desc) is None
assert desc.name == 'pkg-name'
assert desc.type == 'python'
desc.name = 'other-name'
with pytest.raises(RuntimeError) as e:
extension.identify(desc)
assert str(e).endswith('Package name already set to different value')
(basepath / 'setup.cfg').write_text(
'[metadata]\n'
'name = other-name\n'
'[options]\n'
'setup_requires =\n'
" build; sys_platform != 'win32'\n"
" build-windows; sys_platform == 'win32'\n"
'install_requires =\n'
' runA > 1.2.3\n'
' runB\n'
'tests_require = test == 2.0.0\n'
'zip_safe = false\n')
assert extension.identify(desc) is None
assert desc.name == 'other-name'
assert desc.type == 'python'
assert set(desc.dependencies.keys()) == {'build', 'run', 'test'}
assert desc.dependencies['build'] == {'build', 'build-windows'}
assert desc.dependencies['run'] == {'runA', 'runB'}
dep = next(x for x in desc.dependencies['run'] if x == 'runA')
assert dep.metadata['version_gt'] == '1.2.3'
assert desc.dependencies['test'] == {'test'}
assert callable(desc.metadata['get_python_setup_options'])
options = desc.metadata['get_python_setup_options'](None)
assert 'zip_safe' in options
async def test_rosdistro_not_defined():
pkg = PackageDescriptor('package/path')
pkg.name = 'MyPackageName'
pkg.dependencies['run'] = {}
installers = {
'apt': MagicMock(),
}
top_level_args = MagicMock(build_base='build/base',
install_base='install/base',
bundle_base='bundle/base')
args = BundlePackageArguments(pkg, installers, top_level_args)
context = TaskContext(pkg=pkg, args=args, dependencies={})
task = RosBundle()
task.set_context(context=context)
# Concise read on why it's patched this way.
# http://www.voidspace.org.uk/python/mock/patch.html#where-to-patch
with patch('colcon_ros_bundle.task.ros_bundle.RosdepWrapper') as wrapper: # noqa: E501
with pytest.raises(RuntimeError):
wrapper().get_rule.side_effect = _get_rule_side_effect
wrapper().resolve.side_effect = _resolve_side_effect
await task.bundle()
installers['apt'].add_to_install_list.assert_not_called()
async def test_bundle():
descriptor = PackageDescriptor('some/path')
descriptor.name = 'python_package'
deps = [DependencyDescriptor('pkg1', metadata={'version_eq': '1.3.2'}),
DependencyDescriptor('pkg_in_workspace'),
DependencyDescriptor('pkg2', metadata={'version_lt': '1.2'}),
'ignored_pkg']
descriptor.dependencies['run'] = deps
workspace = {'pkg_in_workspace': 'path/to/pkg'}
task_args = MagicMock(build_base='build/base',
install_base='install/base',
bundle_base='bundle/base')
pip_installer = MagicMock()
apt_installer = MagicMock()
args = BundlePackageArguments(
descriptor, {'pip3': pip_installer, 'apt': apt_installer}, task_args)
context = TaskContext(pkg=descriptor, args=args, dependencies=workspace)
task = PythonBundleTask()
task.set_context(context=context)
await task.bundle()
pip_installer.add_to_install_list.assert_called_once_with('pkg1==1.3.2')
apt_calls = apt_installer.add_to_install_list.call_args_list
assert len(apt_calls) == 2
assert apt_calls[0][0][0] == 'libpython3-dev'
assert apt_calls[1][0][0] == 'python3-pip'
def test_identifies_package():
d = PackageDescriptor('/some/path')
assert not d.identifies_package()
d.type = 'type'
assert not d.identifies_package()
d.type = None
d.name = 'name'
assert not d.identifies_package()
d.type = 'type'
assert d.identifies_package()
def test_build_package():
event_loop = new_event_loop()
asyncio.set_event_loop(event_loop)
try:
with TemporaryDirectory(prefix='test_colcon_') as tmp_path_str:
tmp_path = Path(tmp_path_str)
python_build_task = PythonBuildTask()
package = PackageDescriptor(tmp_path / 'src')
package.name = 'test_package'
package.type = 'python'
context = TaskContext(
pkg=package,
args=SimpleNamespace(
path=str(tmp_path / 'src'),
build_base=str(tmp_path / 'build'),
install_base=str(tmp_path / 'install'),
symlink_install=False,
),
dependencies={}
)
python_build_task.set_context(context=context)
pkg = python_build_task.context.pkg
pkg.path.mkdir()
(pkg.path / 'setup.py').write_text(
'from setuptools import setup\n'
'setup(\n'
' name="test_package",\n'
' packages=["my_module"],\n'
')\n'
)
(pkg.path / 'my_module').mkdir()
(pkg.path / 'my_module' / '__init__.py').touch()
src_base = Path(python_build_task.context.args.path)
source_files_before = set(src_base.rglob('*'))
event_loop.run_until_complete(python_build_task.build())
source_files_after = set(src_base.rglob('*'))
assert source_files_before == source_files_after
build_base = Path(python_build_task.context.args.build_base)
assert 1 == len(list(build_base.rglob('my_module/__init__.py')))
install_base = Path(python_build_task.context.args.install_base)
assert 1 == len(list(install_base.rglob('my_module/__init__.py')))
pkg_info, = install_base.rglob('PKG-INFO')
assert 'Name: test-package' in pkg_info.read_text().splitlines()
finally:
event_loop.close()
def test_dependencies_not_changed(self):
package_1_desc = PackageDescriptor('fake/path')
package_1_desc.name = 'baz'
package_1_desc.dependencies['run'] = ['foo']
package_1_desc.dependencies['test'] = ['bar']
package_1 = PackageDecorator(package_1_desc)
decorators = [package_1]
self.assertTrue(
package_dependencies_changed(self.path_context, decorators))
update_dependencies_cache(self.path_context)
self.assertFalse(
package_dependencies_changed(self.path_context, decorators))
def test_topological_order_packages_with_circular_dependency():
d1 = PackageDescriptor('/some/path')
d1.name = 'one'
d1.dependencies['run'].add('two')
d2 = PackageDescriptor('/other/path')
d2.name = 'two'
d2.dependencies['run'].add('three')
d3 = PackageDescriptor('/another/path')
d3.name = 'three'
d3.dependencies['run'].add('one')
d3.dependencies['run'].add('six')
d4 = PackageDescriptor('/yet-another/path')
d4.name = 'four'
d5 = PackageDescriptor('/more/path')
d5.name = 'five'
d5.dependencies['run'].add('four')
d6 = PackageDescriptor('/yet-more/path')
d6.name = 'six'
with pytest.raises(RuntimeError) as e:
topological_order_packages({d1, d2, d3, d4})
lines = str(e.value).splitlines()
assert len(lines) == 4
assert lines[0] == 'Unable to order packages topologically:'
assert lines[1] == "one: ['three', 'two']"
assert lines[2] == "three: ['one', 'two']"
assert lines[3] == "two: ['one', 'three']"
def test_topological_order_packages():
d1 = PackageDescriptor('/some/path')
d1.name = 'a'
d1.dependencies['build'].add('c')
d2 = PackageDescriptor('/other/path')
d2.name = 'b'
d2.dependencies['run'].add('c')
d3 = PackageDescriptor('/another/path')
d3.name = 'c'
d3.dependencies['build'].add('e')
d3.dependencies['run'].add('f')
d3.dependencies['test'].add('d')
d4 = PackageDescriptor('/yet-another/path')
d4.name = 'd'
d4.dependencies['run'].add('f')
d5 = PackageDescriptor('/more/path')
d5.name = 'e'
d5.dependencies['run'].add('f')
d6 = PackageDescriptor('/yet-more/path')
d6.name = 'f'
decos = topological_order_packages({d1, d2, d3, d4, d5, d6})
names = [d.descriptor.name for d in decos]
assert names == ['f', 'd', 'e', 'c', 'a', 'b']
# ensure that input order doesn't affect the result
decos = topological_order_packages({d6, d5, d4, d3, d2, d1})
names = [d.descriptor.name for d in decos]
assert names == ['f', 'd', 'e', 'c', 'a', 'b']
def test_update_metadata():
desc = PackageDescriptor('/some/path')
desc.name = 'name'
assert len(desc.metadata) == 0
update_metadata(desc, 'd', {1: 'one', 2: 'two'})
assert len(desc.metadata) == 1
assert 'd' in desc.metadata.keys()
assert desc.metadata['d'] == {1: 'one', 2: 'two'}
update_metadata(desc, 'd', {2: 'TWO', 3: 'THREE'})
assert len(desc.metadata) == 1
assert 'd' in desc.metadata.keys()
assert desc.metadata['d'] == {1: 'one', 2: 'TWO', 3: 'THREE'}
update_metadata(desc, 'l', [1, 2])
assert len(desc.metadata) == 2
assert 'l' in desc.metadata.keys()
assert desc.metadata['l'] == [1, 2]
update_metadata(desc, 'l', [2, 3])
assert len(desc.metadata) == 2
assert 'l' in desc.metadata.keys()
assert desc.metadata['l'] == [1, 2, 2, 3]
update_metadata(desc, 's', {1, 2})
assert len(desc.metadata) == 3
assert 's' in desc.metadata.keys()
assert desc.metadata['s'] == {1, 2}
update_metadata(desc, 's', {2, 3})
assert len(desc.metadata) == 3
assert 's' in desc.metadata.keys()
assert desc.metadata['s'] == {1, 2, 3}
with patch('colcon_core.package_augmentation.logger.warn') as warn:
update_metadata(desc, 's', 'different type')
warn.assert_called_once_with(
"update package 'name' metadata 's' from value '{1, 2, 3}' to "
"'different type'")
assert len(desc.metadata) == 3
assert 's' in desc.metadata.keys()
assert desc.metadata['s'] == 'different type'
with patch('colcon_core.package_augmentation.logger.warn') as warn:
update_metadata(desc, 's', 'same type')
assert warn.call_count == 0
assert len(desc.metadata) == 3
assert 's' in desc.metadata.keys()
assert desc.metadata['s'] == 'same type'
def test_get_packages():
args = Namespace()
d1 = PackageDescriptor('/some/path')
d1.name = 'one'
d2 = PackageDescriptor('/other/path')
d2.name = 'two'
with patch('colcon_core.package_selection.discover_packages',
return_value=[d1, d2]):
decos = get_packages(args)
assert len(decos) == 2
assert decos[0].descriptor.name == 'one'
assert decos[0].selected is True
assert decos[1].descriptor.name == 'two'
assert decos[1].selected is True
d2.name = 'one'
with patch('colcon_core.package_selection.discover_packages',
return_value=[d1, d2]):
with pytest.raises(RuntimeError) as e:
get_packages(args)
assert 'Duplicate package names not supported:' in str(e.value)
assert '- one:' in str(e.value)
assert '- {sep}some{sep}path'.format(sep=os.sep) in str(e.value)
assert '- {sep}other{sep}path'.format(sep=os.sep) in str(e.value)
def test_get_dependencies():
d1 = PackageDescriptor('/some/path')
d1.name = 'self'
d1.dependencies['build'].add('build-depend')
d1.dependencies['build'].add('depend')
d1.dependencies['run'].add('run-depend')
d1.dependencies['run'].add('depend')
assert d1.get_dependencies() == {'build-depend', 'run-depend', 'depend'}
d1.dependencies['test'].add('self')
assert d1.get_dependencies(categories=('build', )) == \
{'build-depend', 'depend'}
with pytest.raises(AssertionError) as e:
d1.get_dependencies()
assert "'self'" in str(e.value)
def test_dependencies_changed(self):
package_1_desc = PackageDescriptor('fake/path')
package_1_desc.name = 'package1'
package_1_desc.dependencies['run'] = [DependencyDescriptor('foo')]
package_1 = PackageDecorator(package_1_desc)
decorators = [package_1]
self.assertTrue(
package_dependencies_changed(self.path_context, decorators))
update_dependencies_cache(self.path_context)
package_1_desc.dependencies['run'] = [
DependencyDescriptor('foo'), 'baz'
]
package_1 = PackageDecorator(package_1_desc)
decorators = [package_1]
self.assertTrue(
package_dependencies_changed(self.path_context, decorators))
async def test_bundle():
pkg = PackageDescriptor('package/path')
pkg.name = 'MyPackageName'
pkg.dependencies['run'] = {
DependencyDescriptor('source_pkg'),
DependencyDescriptor('other_pkg'),
DependencyDescriptor('system_pkg')
}
installers = {
'rdmanifest': MagicMock(),
'system': MagicMock(),
'other': MagicMock()
}
top_level_args = MagicMock(build_base='build/base',
install_base='install/base',
bundle_base='bundle/base')
args = BundlePackageArguments(pkg, installers, top_level_args)
args.ros_distribution = 'kinetic'
args.exclude_ros_base = True
context = TaskContext(pkg=pkg, args=args, dependencies={})
task = RosBundle()
task.set_context(context=context)
# Concise read on why it's patched this way.
# http://www.voidspace.org.uk/python/mock/patch.html#where-to-patch
with patch('colcon_ros_bundle.task.ros_bundle.RosdepWrapper'
) as wrapper: # noqa: E501
wrapper().get_rule.side_effect = _get_rule_side_effect
wrapper().resolve.side_effect = _resolve_side_effect
await task.bundle()
installers['rdmanifest'].add_to_install_list.assert_called_with(
'source_pkg', {
's': 'ource',
'uri': 'rdmanifest'
})
installers['other'].add_to_install_list.assert_called_with(
'other_pkg_name')
installers['system'].add_to_install_list.assert_called_with(
'system_pkg_name')
async def test_task_test():
with TemporaryDirectory(prefix='test_colcon_') as basepath:
extension = BazelTestTask()
desc = PackageDescriptor(basepath)
desc.name = "test"
args_verb = MockArgs(basepath)
args_pkg = TestPackageArguments(desc, args_verb)
args_pkg.path = basepath
args_pkg.build_base = args_verb.build_base
args_pkg.install_base = args_verb.install_base
args_pkg.merge_install = args_verb.merge_install
args_pkg.test_result_base = args_verb.test_result_base
context = TaskContext(pkg=desc, args=args_pkg, dependencies=set())
extension.set_context(context=context)
ret = await extension.test()
assert ret
def test_pytest_match():
extension = PytestPythonTestingStep()
env = {}
desc = PackageDescriptor('/dev/null')
context = TaskContext(pkg=desc, args=None, dependencies=None)
desc.name = 'pkg-name'
desc.type = 'python'
# no test requirements
desc.metadata['get_python_setup_options'] = lambda env: {}
assert not extension.match(context, env, get_setup_data(desc, env))
# pytest not in tests_require
desc.metadata['get_python_setup_options'] = lambda env: {
'tests_require': ['nose'],
}
assert not extension.match(context, env, get_setup_data(desc, env))
# pytest not in extras_require.test
desc.metadata['get_python_setup_options'] = lambda env: {
'extras_require': {
'test': ['nose']
},
}
assert not extension.match(context, env, get_setup_data(desc, env))
# pytest in tests_require
desc.metadata['get_python_setup_options'] = lambda env: {
'tests_require': ['pytest'],
}
assert extension.match(context, env, get_setup_data(desc, env))
# pytest in extras_require.test
desc.metadata['get_python_setup_options'] = lambda env: {
'extras_require': {
'test': ['pytest']
},
}
assert extension.match(context, env, get_setup_data(desc, env))
def test_str():
d = PackageDescriptor('/some/path')
d.type = 'custom-type'
d.name = 'custom-name'
d.dependencies['build'].add('build-depend')
d.dependencies['run'].add('run-depend')
d.hooks += ('hook-a', 'hook-b')
d.metadata['key'] = 'value'
s = str(d)
assert s.startswith('{')
assert s.endswith('}')
assert 'path: ' in s
assert '/some/path'.replace('/', os.sep) in s
assert 'type: ' in s
assert 'custom-type' in s
assert 'name: ' in s
assert 'custom-name' in s
assert 'dependencies: ' in s
assert 'build-depend' in s
assert 'run-depend' in s
assert 'hooks: ' in s
assert 'hook-a' in s
assert 'metadata: ' in s
assert 'value' in s
def test_get_recursive_dependencies():
d = PackageDescriptor('/some/path')
d.name = 'A'
d.dependencies['build'].add('B')
d.dependencies['run'].add('c')
d.dependencies['test'].add('d')
d1 = PackageDescriptor('/other/path')
d1.name = 'B'
d1.dependencies['build'].add('e')
d1.dependencies['run'].add('F')
d1.dependencies['test'].add('G')
d2 = PackageDescriptor('/another/path')
d2.name = 'd'
d3 = PackageDescriptor('/yet-another/path')
d3.name = 'F'
d3.dependencies['build'].add('h')
d3.dependencies['test'].add('G')
d3.dependencies['test'].add('I')
d4 = PackageDescriptor('/more/path')
d4.name = 'G'
d4.dependencies['test'].add('I')
d5 = PackageDescriptor('/yet-more/path')
d5.name = 'I'
# circular dependencies should be ignored
d5.dependencies['run'].add('A')
rec_deps = d.get_recursive_dependencies({d, d1, d2, d3, d4, d5},
direct_categories=('build', 'run'),
recursive_categories=('run',
'test'))
assert rec_deps == {
# direct dependencies
'B',
# recursive dependencies
'F',
'G',
'I',
}
def update_descriptor(desc: PackageDescriptor,
data: dict,
*,
additional_argument_names=None):
"""
Update the package descriptor with additional information.
For the keys `name` and `type` the values from `data` are set on the
descriptor attributes with the same names.
For the key `dependencies` the values are being added to the dependencies
in each of the following categories: `build`, `run`, and `test`.
For the keys `build_dependencies`, `run_dependencies`, and
`test_dependencies` the values are being added to the dependencies in the
category with the same name.
For the key `hooks` the values are being added to the list of hooks.
Any key-value pair not explicitly mentioned above is being used to update
the metadata if the key is in the list of additional argument names.
See :function:`update_metadata` for details how the metadata is updated.
If the additional argument names is a list with the single value `*` all
keys not explicitly mentioned above are being used to update the metadata.
:param desc: the package descriptor
:param data: The dictionary with additional information
:param additional_argument_names: A dict of option names to destination
names or a list of argument names
"""
# explicit key updates
try:
desc.name = data['name']
except KeyError:
pass
try:
desc.type = data['type']
except KeyError:
pass
dep_types = ('build', 'run', 'test')
# transfer generic dependencies to each specific type
if 'dependencies' in data:
for d in data['dependencies']:
for dep_type in dep_types:
desc.dependencies[dep_type].add(d)
# transfer type specific dependencies
for dep_type in dep_types:
key = '{dep_type}-dependencies'.format_map(locals())
if key in data:
for d in data[key]:
desc.dependencies[dep_type].add(d)
# transfer hooks
if 'hooks' in data:
for d in data['hooks']:
desc.hooks.append(d)
# transfer any other metadata
if additional_argument_names == ['*']:
additional_argument_names = []
# skip any of the already explicitly handled names
ignored_names = ['name', 'type', 'dependencies', 'hooks']
for dep_type in dep_types:
ignored_names.append('{dep_type}-dependencies'.format_map(
locals()))
for name in data.keys():
if name in ignored_names:
continue
additional_argument_names.append(name)
if isinstance(additional_argument_names, list):
additional_argument_names = OrderedDict([
(name, name) for name in additional_argument_names
])
for option, dest in (additional_argument_names or {}).items():
if option in data:
update_metadata(desc, dest, data[option])
def test_identify():
extension = BazelPackageIdentification()
with TemporaryDirectory(prefix='test_colcon_') as basepath:
desc = PackageDescriptor(basepath)
desc.type = 'other'
assert extension.identify(desc) is None
assert desc.name is None
desc.type = None
assert extension.identify(desc) is None
assert desc.name is None
assert desc.type is None
basepath = Path(basepath)
(basepath / 'BUILD.bazel').write_text('')
assert extension.identify(desc) is None
assert desc.name is not None
assert desc.type is 'bazel'
desc.name = None
(basepath / 'BUILD').write_text('')
assert extension.identify(desc) is None
assert desc.name is not None
assert desc.type is 'bazel'
desc.name = None
(basepath / 'BUILD.bazel').write_text(
'java_binary(\n'
' name = "pkg-name",\n'
')\n')
assert extension.identify(desc) is None
assert desc.name == 'pkg-name'
assert desc.type == 'bazel'
desc.name = 'other-name'
with pytest.raises(RuntimeError) as einfo:
extension.identify(desc)
assert str(einfo.value).endswith('Package name already set to different value')
(basepath / 'BUILD.bazel').write_text(
'java_binary(\n'
' name = "other-name",\n'
' deps = [":build-depA", ":build-depB"]\n'
' runtime_deps = [":run-depA", ":run-depB"]\n'
')\n'
'\n'
'java_library(\n'
' name = "other-name-lib",\n'
' deps = [":lib-dep", "@log4j//jar", "other-name"]\n'
' runtime_deps = [":lib-run-dep"]\n'
')\n'
'\n'
'java_test(\n'
' name = "other-name-test",\n'
' deps = [":test-dep"],\n'
' runtime_deps = [":test-run-dep"]\n'
')\n')
assert extension.identify(desc) is None
assert desc.name == 'other-name'
assert desc.type == 'bazel'
assert set(desc.dependencies.keys()) == {'build', 'run', 'test'}
assert desc.dependencies['build'] == {'build-depA', 'build-depB',
'lib-dep'}
assert desc.dependencies['run'] == {'run-depA', 'run-depB',
'lib-run-dep'}
assert desc.dependencies['test'] == {'test-dep', 'test-run-dep'}
desc.name = None
(basepath / 'sub1/sub2/sub3').mkdir(parents=True, exist_ok=True)
assert extension.identify(desc) is None
assert desc.name == 'other-name'
assert desc.type == 'bazel'