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 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 register_commands(): SetupPy._register()