Exemple #1
0
  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)
Exemple #2
0
 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()
Exemple #3
0
 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())
Exemple #4
0
  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)
Exemple #5
0
    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)
Exemple #6
0
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'])}
Exemple #7
0
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'])}
Exemple #8
0
    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)
Exemple #9
0
  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)
Exemple #10
0
 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([])
Exemple #11
0
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'])
Exemple #12
0
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'])
Exemple #13
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([]))
Exemple #14
0
 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'])
Exemple #15
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']))
Exemple #16
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([]))
Exemple #17
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']))
Exemple #18
0
 def has_ns(stmt):
     with temporary_file() as fp:
         fp.write(stmt)
         fp.flush()
         return SetupPy.declares_namespace_package(fp.name)
Exemple #19
0
 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())
Exemple #20
0
 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())
Exemple #21
0
 def has_ns(stmt):
   with temporary_file() as fp:
     fp.write(stmt)
     fp.flush()
     return SetupPy.declares_namespace_package(fp.name)
Exemple #22
0
def register_commands():
    SetupPy._register()
Exemple #23
0
def register_commands():
  SetupPy._register()