Example #1
0
    def test_transitive_closure_spec(self):
        with self.workspace('./BUILD', 'a/BUILD', 'a/b/BUILD') as root_dir:
            with open(os.path.join(root_dir, './BUILD'), 'w') as build:
                build.write(
                    dedent('''
          fake(name="foo",
               dependencies=[
                 'a',
               ])
        '''))

            with open(os.path.join(root_dir, 'a/BUILD'), 'w') as build:
                build.write(
                    dedent('''
          fake(name="a",
               dependencies=[
                 'a/b:bat',
               ])
        '''))

            with open(os.path.join(root_dir, 'a/b/BUILD'), 'w') as build:
                build.write(dedent('''
          fake(name="bat")
        '''))

            build_configuration = BuildConfiguration()
            build_configuration.register_target_alias('fake', Target)
            parser = BuildFileParser(build_configuration, root_dir=root_dir)
            build_graph = BuildGraph(self.address_mapper)
            parser.inject_spec_closure_into_build_graph(':foo', build_graph)
            self.assertEqual(
                len(build_graph.dependencies_of(
                    SyntheticAddress.parse(':foo'))), 1)
Example #2
0
  def test_transitive_closure_spec(self):
    with self.workspace('./BUILD', 'a/BUILD', 'a/b/BUILD') as root_dir:
      with open(os.path.join(root_dir, './BUILD'), 'w') as build:
        build.write(dedent('''
          fake(name="foo",
               dependencies=[
                 'a',
               ])
        '''))

      with open(os.path.join(root_dir, 'a/BUILD'), 'w') as build:
        build.write(dedent('''
          fake(name="a",
               dependencies=[
                 'a/b:bat',
               ])
        '''))

      with open(os.path.join(root_dir, 'a/b/BUILD'), 'w') as build:
        build.write(dedent('''
          fake(name="bat")
        '''))

      build_configuration = BuildConfiguration()
      build_configuration.register_target_alias('fake', Target)
      parser = BuildFileParser(build_configuration, root_dir=root_dir)
      build_graph = BuildGraph(self.address_mapper)
      parser.inject_spec_closure_into_build_graph(':foo', build_graph)
      self.assertEqual(len(build_graph.dependencies_of(SyntheticAddress.parse(':foo'))), 1)
class BuildConfigurationTest(unittest.TestCase):
  def setUp(self):
    self.build_configuration = BuildConfiguration()

  def test_register_target_alias(self):
    class Fred(Target):
      pass

    self.build_configuration.register_target_alias('fred', Fred)
    aliases = self.build_configuration.registered_aliases()
    self.assertEqual({}, aliases.objects)
    self.assertEqual({}, aliases.context_aware_object_factories)
    self.assertEqual(dict(fred=Fred), aliases.targets)

    build_file = FilesystemBuildFile('/tmp', 'fred', must_exist=False)
    parse_state = self.build_configuration.initialize_parse_state(build_file)

    self.assertEqual(0, len(parse_state.registered_addressable_instances))
    self.assertEqual(1, len(parse_state.parse_globals))

    target_call_proxy = parse_state.parse_globals['fred']
    target_call_proxy(name='jake')
    self.assertEqual(1, len(parse_state.registered_addressable_instances))
    name, target_proxy = parse_state.registered_addressable_instances.pop()
    self.assertEqual('jake', target_proxy.name)
    self.assertEqual(Fred, target_proxy.target_type)

  def test_register_bad_target_alias(self):
    with self.assertRaises(TypeError):
      self.build_configuration.register_target_alias('fred', object())

    target = Target('fred', SyntheticAddress.parse('a:b'), BuildGraph(address_mapper=None))
    with self.assertRaises(TypeError):
      self.build_configuration.register_target_alias('fred', target)

  def test_register_exposed_object(self):
    self.build_configuration.register_exposed_object('jane', 42)

    aliases = self.build_configuration.registered_aliases()
    self.assertEqual({}, aliases.targets)
    self.assertEqual({}, aliases.context_aware_object_factories)
    self.assertEqual(dict(jane=42), aliases.objects)

    build_file = FilesystemBuildFile('/tmp', 'jane', must_exist=False)
    parse_state = self.build_configuration.initialize_parse_state(build_file)

    self.assertEqual(0, len(parse_state.registered_addressable_instances))
    self.assertEqual(1, len(parse_state.parse_globals))
    self.assertEqual(42, parse_state.parse_globals['jane'])

  def test_register_bad_exposed_object(self):
    with self.assertRaises(TypeError):
      self.build_configuration.register_exposed_object('jane', Target)

  def test_register_exposed_context_aware_function(self):
    self.do_test_exposed_context_aware_function(lambda context: lambda: context.rel_path)
    self.do_test_exposed_context_aware_function(lambda context=None: lambda: context.rel_path)

  def george_method(self, parse_context):
    return lambda: parse_context.rel_path

  def test_register_exposed_context_aware_method(self):
    self.do_test_exposed_context_aware_function(self.george_method)

  @classmethod
  def george_classmethod(cls, parse_context):
    return lambda: parse_context.rel_path

  def test_register_exposed_context_aware_classmethod(self):
    self.do_test_exposed_context_aware_function(self.george_classmethod)

  @staticmethod
  def george_staticmethod(parse_context):
    return lambda: parse_context.rel_path

  def test_register_exposed_context_aware_staticmethod(self):
    self.do_test_exposed_context_aware_function(self.george_staticmethod)

  def do_test_exposed_context_aware_function(self, func, *args, **kwargs):
    with self.do_test_exposed_context_aware_object(func) as context_aware_object:
      self.assertEqual('george', context_aware_object(*args, **kwargs))

  def test_register_exposed_context_aware_class(self):
    class George(object):
      def __init__(self, parse_context):
        self._parse_context = parse_context

      def honorific(self):
        return len(self._parse_context.rel_path)

    with self.do_test_exposed_context_aware_object(George) as context_aware_object:
      self.assertEqual(6, context_aware_object.honorific())

  @contextmanager
  def do_test_exposed_context_aware_object(self, context_aware_object_factory):
    self.build_configuration.register_exposed_context_aware_object_factory(
        'george', context_aware_object_factory)

    aliases = self.build_configuration.registered_aliases()
    self.assertEqual({}, aliases.targets)
    self.assertEqual({}, aliases.objects)
    self.assertEqual(dict(george=context_aware_object_factory),
                     aliases.context_aware_object_factories)

    with temporary_dir() as root:
      build_file_path = os.path.join(root, 'george', 'BUILD')
      touch(build_file_path)
      build_file = FilesystemBuildFile(root, 'george')
      parse_state = self.build_configuration.initialize_parse_state(build_file)

      self.assertEqual(0, len(parse_state.registered_addressable_instances))
      self.assertEqual(1, len(parse_state.parse_globals))
      yield parse_state.parse_globals['george']

  def test_register_bad_exposed_context_aware_object(self):
    with self.assertRaises(TypeError):
      self.build_configuration.register_exposed_context_aware_object_factory('george', 1)
class BuildConfigurationTest(unittest.TestCase):
    def setUp(self):
        self.build_configuration = BuildConfiguration()

    def test_register_target_alias(self):
        class Fred(Target):
            pass

        self.build_configuration.register_target_alias('fred', Fred)
        aliases = self.build_configuration.registered_aliases()
        self.assertEqual({}, aliases.objects)
        self.assertEqual({}, aliases.context_aware_object_factories)
        self.assertEqual(dict(fred=Fred), aliases.targets)

        build_file = FilesystemBuildFile('/tmp', 'fred', must_exist=False)
        parse_state = self.build_configuration.initialize_parse_state(
            build_file)

        self.assertEqual(0, len(parse_state.registered_addressable_instances))
        self.assertEqual(1, len(parse_state.parse_globals))

        target_call_proxy = parse_state.parse_globals['fred']
        target_call_proxy(name='jake')
        self.assertEqual(1, len(parse_state.registered_addressable_instances))
        name, target_proxy = parse_state.registered_addressable_instances.pop()
        self.assertEqual('jake', target_proxy.name)
        self.assertEqual(Fred, target_proxy.target_type)

    def test_register_bad_target_alias(self):
        with self.assertRaises(TypeError):
            self.build_configuration.register_target_alias('fred', object())

        target = Target('fred', SyntheticAddress.parse('a:b'),
                        BuildGraph(address_mapper=None))
        with self.assertRaises(TypeError):
            self.build_configuration.register_target_alias('fred', target)

    def test_register_exposed_object(self):
        self.build_configuration.register_exposed_object('jane', 42)

        aliases = self.build_configuration.registered_aliases()
        self.assertEqual({}, aliases.targets)
        self.assertEqual({}, aliases.context_aware_object_factories)
        self.assertEqual(dict(jane=42), aliases.objects)

        build_file = FilesystemBuildFile('/tmp', 'jane', must_exist=False)
        parse_state = self.build_configuration.initialize_parse_state(
            build_file)

        self.assertEqual(0, len(parse_state.registered_addressable_instances))
        self.assertEqual(1, len(parse_state.parse_globals))
        self.assertEqual(42, parse_state.parse_globals['jane'])

    def test_register_bad_exposed_object(self):
        with self.assertRaises(TypeError):
            self.build_configuration.register_exposed_object('jane', Target)

    def test_register_exposed_context_aware_function(self):
        self.do_test_exposed_context_aware_function(
            lambda context: lambda: context.rel_path)
        self.do_test_exposed_context_aware_function(
            lambda context=None: lambda: context.rel_path)

    def george_method(self, parse_context):
        return lambda: parse_context.rel_path

    def test_register_exposed_context_aware_method(self):
        self.do_test_exposed_context_aware_function(self.george_method)

    @classmethod
    def george_classmethod(cls, parse_context):
        return lambda: parse_context.rel_path

    def test_register_exposed_context_aware_classmethod(self):
        self.do_test_exposed_context_aware_function(self.george_classmethod)

    @staticmethod
    def george_staticmethod(parse_context):
        return lambda: parse_context.rel_path

    def test_register_exposed_context_aware_staticmethod(self):
        self.do_test_exposed_context_aware_function(self.george_staticmethod)

    def do_test_exposed_context_aware_function(self, func, *args, **kwargs):
        with self.do_test_exposed_context_aware_object(
                func) as context_aware_object:
            self.assertEqual('george', context_aware_object(*args, **kwargs))

    def test_register_exposed_context_aware_class(self):
        class George(object):
            def __init__(self, parse_context):
                self._parse_context = parse_context

            def honorific(self):
                return len(self._parse_context.rel_path)

        with self.do_test_exposed_context_aware_object(
                George) as context_aware_object:
            self.assertEqual(6, context_aware_object.honorific())

    @contextmanager
    def do_test_exposed_context_aware_object(self,
                                             context_aware_object_factory):
        self.build_configuration.register_exposed_context_aware_object_factory(
            'george', context_aware_object_factory)

        aliases = self.build_configuration.registered_aliases()
        self.assertEqual({}, aliases.targets)
        self.assertEqual({}, aliases.objects)
        self.assertEqual(dict(george=context_aware_object_factory),
                         aliases.context_aware_object_factories)

        with temporary_dir() as root:
            build_file_path = os.path.join(root, 'george', 'BUILD')
            touch(build_file_path)
            build_file = FilesystemBuildFile(root, 'george')
            parse_state = self.build_configuration.initialize_parse_state(
                build_file)

            self.assertEqual(0,
                             len(parse_state.registered_addressable_instances))
            self.assertEqual(1, len(parse_state.parse_globals))
            yield parse_state.parse_globals['george']

    def test_register_bad_exposed_context_aware_object(self):
        with self.assertRaises(TypeError):
            self.build_configuration.register_exposed_context_aware_object_factory(
                'george', 1)