def test_binary_target_injected_into_minified_dependencies(self):
foo_bin_dep = self.make_target(
spec = ':foo_bin_dep',
target_type = PythonLibrary,
)
foo_bin = self.make_target(
spec = ':foo_bin',
target_type = PythonBinary,
entry_point = 'foo.bin.foo',
dependencies = [
foo_bin_dep,
]
)
foo = self.make_target(
spec = ':foo',
target_type = PythonLibrary,
provides = PythonArtifact(
name = 'foo',
version = '0.0.0',
).with_binaries(
foo_binary = ':foo_bin',
)
)
assert SetupPy.minified_dependencies(foo) == OrderedSet([foo_bin, foo_bin_dep])
entry_points = dict(SetupPy.iter_entry_points(foo))
assert entry_points == {'foo_binary': 'foo.bin.foo'}
with self.run_execute(foo, recursive=False) as setup_py_command:
setup_py_command.run_one.assert_called_with(foo)
with self.run_execute(foo, recursive=True) as setup_py_command:
setup_py_command.run_one.assert_called_with(foo)
def test_minified_dependencies_2(self):
# foo --> baz
# | ^
# v |
# bar ----'
dep_map = {'foo': ['bar', 'baz'], 'bar': ['baz'], 'baz': []}
target_map = self.create_dependencies(dep_map)
assert SetupPy.minified_dependencies(target_map['foo']) == OrderedSet([target_map['bar']])
assert SetupPy.minified_dependencies(target_map['bar']) == OrderedSet([target_map['baz']])
assert SetupPy.minified_dependencies(target_map['baz']) == OrderedSet()
def test_minified_dependencies_2(self):
# foo --> baz
# | ^
# v |
# bar ----'
dep_map = OrderedDict(foo=['bar', 'baz'], bar=['baz'], baz=[])
target_map = self.create_dependencies(dep_map)
self.assertEqual(SetupPy.minified_dependencies(target_map['foo']),
OrderedSet([target_map['bar']]))
self.assertEqual(SetupPy.minified_dependencies(target_map['bar']),
OrderedSet([target_map['baz']]))
self.assertEqual(SetupPy.minified_dependencies(target_map['baz']), OrderedSet())
def test_binary_target_injected_into_minified_dependencies_with_provider(self):
bar_bin_dep = self.make_target(
spec = ':bar_bin_dep',
target_type = PythonLibrary,
provides = PythonArtifact(
name = 'bar_bin_dep',
version = '0.0.0',
)
)
bar_bin = self.make_target(
spec = ':bar_bin',
target_type = PythonBinary,
entry_point = 'bar.bin.bar',
dependencies = [
bar_bin_dep,
],
)
bar = self.make_target(
spec = ':bar',
target_type = PythonLibrary,
provides = PythonArtifact(
name = 'bar',
version = '0.0.0',
).with_binaries(
bar_binary = ':bar_bin'
)
)
# TODO(pl): Why is this set ordered? Does the order actually matter?
assert SetupPy.minified_dependencies(bar) == OrderedSet([bar_bin, bar_bin_dep])
assert SetupPy.install_requires(bar) == set(['bar_bin_dep==0.0.0'])
entry_points = dict(SetupPy.iter_entry_points(bar))
assert entry_points == {'bar_binary': 'bar.bin.bar'}
with self.run_execute(bar, recursive=False) as setup_py_command:
setup_py_command.run_one.assert_called_with(bar)
with self.run_execute(bar, recursive=True) as setup_py_command:
setup_py_command.run_one.assert_has_calls([
call(bar),
call(bar_bin_dep)
], any_order=True)
def test_binary_cycle(self):
foo = self.make_target(spec=':foo',
target_type=PythonLibrary,
provides=PythonArtifact(
name='foo',
version='0.0.0',
).with_binaries(foo_binary=':foo_bin', ))
foo_bin = self.make_target(
spec=':foo_bin',
target_type=PythonBinary,
entry_point='foo.bin.foo',
dependencies=[
foo,
],
)
with self.assertRaises(TargetDefinitionException):
SetupPy.minified_dependencies(foo)
def test_find_packages():
def assert_single_chroot(packages, namespace_packages, resources):
with yield_chroot(packages, namespace_packages, resources) as chroot:
p, n_p, r = SetupPy.find_packages(chroot)
assert p == set(packages + namespace_packages)
assert n_p == set(namespace_packages)
assert r == dict((k, set(v)) for (k, v) in resources.items())
# assert both packages and namespace packages work
assert_single_chroot(['foo'], [], {})
assert_single_chroot(['foo'], ['foo'], {})
# assert resources work
assert_single_chroot(['foo'], [], {'foo': ['blork.dat']})
resources = {
'foo': [
'f0',
os.path.join('bar', 'baz', 'f1'),
os.path.join('bar', 'baz', 'f2'),
]
}
assert_single_chroot(['foo'], [], resources)
# assert that nearest-submodule is honored
with yield_chroot(['foo', 'foo.bar'], [], resources) as chroot:
_, _, r = SetupPy.find_packages(chroot)
assert r == {
'foo': set(['f0']),
'foo.bar': set([
os.path.join('baz', 'f1'),
os.path.join('baz', 'f2'),
])
}
# assert that nearest submodule splits on module prefixes
with yield_chroot(
['foo', 'foo.bar'],
[],
{'foo.bar1': ['f0']}) as chroot:
_, _, r = SetupPy.find_packages(chroot)
assert r == {'foo': set(['bar1/f0'])}
def test_find_packages():
def assert_single_chroot(packages, namespace_packages, resources):
with yield_chroot(packages, namespace_packages, resources) as chroot:
p, n_p, r = SetupPy.find_packages(chroot)
assert p == set(packages + namespace_packages)
assert n_p == set(namespace_packages)
assert r == dict((k, set(v)) for (k, v) in resources.items())
# assert both packages and namespace packages work
assert_single_chroot(['foo'], [], {})
assert_single_chroot(['foo'], ['foo'], {})
# assert resources work
assert_single_chroot(['foo'], [], {'foo': ['blork.dat']})
resources = {
'foo': [
'f0',
os.path.join('bar', 'baz', 'f1'),
os.path.join('bar', 'baz', 'f2'),
]
}
assert_single_chroot(['foo'], [], resources)
# assert that nearest-submodule is honored
with yield_chroot(['foo', 'foo.bar'], [], resources) as chroot:
_, _, r = SetupPy.find_packages(chroot)
assert r == {
'foo':
set(['f0']),
'foo.bar':
set([
os.path.join('baz', 'f1'),
os.path.join('baz', 'f2'),
])
}
# assert that nearest submodule splits on module prefixes
with yield_chroot(['foo', 'foo.bar'], [], {'foo.bar1': ['f0']}) as chroot:
_, _, r = SetupPy.find_packages(chroot)
assert r == {'foo': set(['bar1/f0'])}
def test_binary_target_injected_into_minified_dependencies_with_provider(
self):
bar_bin_dep = self.make_target(spec=':bar_bin_dep',
target_type=PythonLibrary,
provides=PythonArtifact(
name='bar_bin_dep',
version='0.0.0',
))
bar_bin = self.make_target(
spec=':bar_bin',
target_type=PythonBinary,
entry_point='bar.bin.bar',
dependencies=[
bar_bin_dep,
],
)
bar = self.make_target(spec=':bar',
target_type=PythonLibrary,
provides=PythonArtifact(
name='bar',
version='0.0.0',
).with_binaries(bar_binary=':bar_bin'))
# TODO(pl): Why is this set ordered? Does the order actually matter?
assert SetupPy.minified_dependencies(bar) == OrderedSet(
[bar_bin, bar_bin_dep])
assert SetupPy.install_requires(bar) == set(['bar_bin_dep==0.0.0'])
entry_points = dict(SetupPy.iter_entry_points(bar))
assert entry_points == {'bar_binary': 'bar.bin.bar'}
with self.run_execute(bar, recursive=False) as setup_py_command:
setup_py_command.run_one.assert_called_with(bar)
with self.run_execute(bar, recursive=True) as setup_py_command:
setup_py_command.run_one.assert_has_calls(
[call(bar), call(bar_bin_dep)], any_order=True)
def test_binary_cycle(self):
foo = self.make_target(
spec = ':foo',
target_type = PythonLibrary,
provides = PythonArtifact(
name = 'foo',
version = '0.0.0',
).with_binaries(
foo_binary = ':foo_bin',
)
)
foo_bin = self.make_target(
spec = ':foo_bin',
target_type = PythonBinary,
entry_point = 'foo.bin.foo',
dependencies = [
foo,
],
)
with pytest.raises(TargetDefinitionException):
SetupPy.minified_dependencies(foo)
def test_minified_dependencies_1(self):
# foo -> bar -> baz
dep_map = {'foo': ['bar'], 'bar': ['baz'], 'baz': []}
target_map = self.create_dependencies(dep_map)
assert SetupPy.minified_dependencies(target_map['foo']) == OrderedSet([target_map['bar']])
assert SetupPy.minified_dependencies(target_map['bar']) == OrderedSet([target_map['baz']])
assert SetupPy.minified_dependencies(target_map['baz']) == OrderedSet()
assert SetupPy.install_requires(target_map['foo']) == set(['bar==0.0.0'])
assert SetupPy.install_requires(target_map['bar']) == set(['baz==0.0.0'])
assert SetupPy.install_requires(target_map['baz']) == set([])
def test_nearest_subpackage():
# degenerate
assert SetupPy.nearest_subpackage('foo', []) == 'foo'
assert SetupPy.nearest_subpackage('foo', ['foo']) == 'foo'
assert SetupPy.nearest_subpackage('foo', ['bar']) == 'foo'
# common prefix
assert 'foo' == SetupPy.nearest_subpackage('foo.bar', ['foo'])
assert 'foo.bar' == SetupPy.nearest_subpackage('foo.bar',
['foo', 'foo.bar'])
assert 'foo.bar' == SetupPy.nearest_subpackage('foo.bar.topo',
['foo', 'foo.bar'])
assert 'foo' == SetupPy.nearest_subpackage('foo.barization',
['foo', 'foo.bar'])
def test_nearest_subpackage():
# degenerate
assert SetupPy.nearest_subpackage('foo', []) == 'foo'
assert SetupPy.nearest_subpackage('foo', ['foo']) == 'foo'
assert SetupPy.nearest_subpackage('foo', ['bar']) == 'foo'
# common prefix
assert 'foo' == SetupPy.nearest_subpackage('foo.bar', ['foo'])
assert 'foo.bar' == SetupPy.nearest_subpackage(
'foo.bar', ['foo', 'foo.bar'])
assert 'foo.bar' == SetupPy.nearest_subpackage(
'foo.bar.topo', ['foo', 'foo.bar'])
assert 'foo' == SetupPy.nearest_subpackage(
'foo.barization', ['foo', 'foo.bar'])
def test_minified_dependencies_1(self):
# foo -> bar -> baz
dep_map = OrderedDict(foo=['bar'], bar=['baz'], baz=[])
target_map = self.create_dependencies(dep_map)
self.assertEqual(SetupPy.minified_dependencies(target_map['foo']),
OrderedSet([target_map['bar']]))
self.assertEqual(SetupPy.minified_dependencies(target_map['bar']),
OrderedSet([target_map['baz']]))
self.assertEqual(SetupPy.minified_dependencies(target_map['baz']), OrderedSet())
self.assertEqual(SetupPy.install_requires(target_map['foo']), set(['bar==0.0.0']))
self.assertEqual(SetupPy.install_requires(target_map['bar']), set(['baz==0.0.0']))
self.assertEqual(SetupPy.install_requires(target_map['baz']), set([]))
def test_minified_dependencies_diamond(self):
# bar <-- foo --> baz
# | |
# `----> bak <----'
dep_map = {'foo': ['bar', 'baz'], 'bar': ['bak'], 'baz': ['bak'], 'bak': []}
target_map = self.create_dependencies(dep_map)
assert SetupPy.minified_dependencies(target_map['foo']) == OrderedSet(
[target_map['baz'], target_map['bar']])
assert SetupPy.minified_dependencies(target_map['bar']) == OrderedSet([target_map['bak']])
assert SetupPy.minified_dependencies(target_map['baz']) == OrderedSet([target_map['bak']])
assert SetupPy.install_requires(target_map['foo']) == set(['bar==0.0.0', 'baz==0.0.0'])
assert SetupPy.install_requires(target_map['bar']) == set(['bak==0.0.0'])
assert SetupPy.install_requires(target_map['baz']) == set(['bak==0.0.0'])
def test_minified_dependencies_diamond(self):
# bar <-- foo --> baz
# | |
# `----> bak <----'
dep_map = OrderedDict(foo=['bar', 'baz'], bar=['bak'], baz=['bak'], bak=[])
target_map = self.create_dependencies(dep_map)
self.assertEqual(SetupPy.minified_dependencies(target_map['foo']),
OrderedSet([target_map['bar'], target_map['baz']]))
self.assertEqual(SetupPy.minified_dependencies(target_map['bar']),
OrderedSet([target_map['bak']]))
self.assertEqual(SetupPy.minified_dependencies(target_map['baz']),
OrderedSet([target_map['bak']]))
self.assertEqual(SetupPy.install_requires(target_map['foo']), set(['bar==0.0.0', 'baz==0.0.0']))
self.assertEqual(SetupPy.install_requires(target_map['bar']), set(['bak==0.0.0']))
self.assertEqual(SetupPy.install_requires(target_map['baz']), set(['bak==0.0.0']))
def test_minified_dependencies_1(self):
# foo -> bar -> baz
dep_map = OrderedDict(foo=['bar'], bar=['baz'], baz=[])
target_map = self.create_dependencies(dep_map)
self.assertEqual(SetupPy.minified_dependencies(target_map['foo']),
OrderedSet([target_map['bar']]))
self.assertEqual(SetupPy.minified_dependencies(target_map['bar']),
OrderedSet([target_map['baz']]))
self.assertEqual(SetupPy.minified_dependencies(target_map['baz']),
OrderedSet())
self.assertEqual(SetupPy.install_requires(target_map['foo']),
set(['bar==0.0.0']))
self.assertEqual(SetupPy.install_requires(target_map['bar']),
set(['baz==0.0.0']))
self.assertEqual(SetupPy.install_requires(target_map['baz']), set([]))
def test_minified_dependencies_diamond(self):
# bar <-- foo --> baz
# | |
# `----> bak <----'
dep_map = OrderedDict(foo=['bar', 'baz'],
bar=['bak'],
baz=['bak'],
bak=[])
target_map = self.create_dependencies(dep_map)
self.assertEqual(SetupPy.minified_dependencies(target_map['foo']),
OrderedSet([target_map['bar'], target_map['baz']]))
self.assertEqual(SetupPy.minified_dependencies(target_map['bar']),
OrderedSet([target_map['bak']]))
self.assertEqual(SetupPy.minified_dependencies(target_map['baz']),
OrderedSet([target_map['bak']]))
self.assertEqual(SetupPy.install_requires(target_map['foo']),
set(['bar==0.0.0', 'baz==0.0.0']))
self.assertEqual(SetupPy.install_requires(target_map['bar']),
set(['bak==0.0.0']))
self.assertEqual(SetupPy.install_requires(target_map['baz']),
set(['bak==0.0.0']))
def has_ns(stmt):
with temporary_file() as fp:
fp.write(stmt)
fp.flush()
return SetupPy.declares_namespace_package(fp.name)
def assert_single_chroot(packages, namespace_packages, resources):
with yield_chroot(packages, namespace_packages, resources) as chroot:
p, n_p, r = SetupPy.find_packages(chroot)
assert p == set(packages + namespace_packages)
assert n_p == set(namespace_packages)
assert r == dict((k, set(v)) for (k, v) in resources.items())
def assert_single_chroot(packages, namespace_packages, resources):
with yield_chroot(packages, namespace_packages, resources) as chroot:
p, n_p, r = SetupPy.find_packages(chroot)
assert p == set(packages + namespace_packages)
assert n_p == set(namespace_packages)
assert r == dict((k, set(v)) for (k, v) in resources.items())
def has_ns(stmt):
with temporary_file() as fp:
fp.write(stmt)
fp.flush()
return SetupPy.declares_namespace_package(fp.name)
def register_commands():
SetupPy._register()
def register_commands(): SetupPy._register()
