Ejemplo n.º 1
0
 def test_multiple(self):
   exactly_a_or_b = Exactly(self.A, self.B)
   self.assertEqual((self.A, self.B), exactly_a_or_b.types)
   self.assertTrue(exactly_a_or_b.satisfied_by(self.A()))
   self.assertTrue(exactly_a_or_b.satisfied_by(self.B()))
   self.assertFalse(exactly_a_or_b.satisfied_by(self.BPrime()))
   self.assertFalse(exactly_a_or_b.satisfied_by(self.C()))
Ejemplo n.º 2
0
 def test_single(self):
   exactly_b = Exactly(self.B)
   self.assertEqual((self.B,), exactly_b.types)
   self.assertFalse(exactly_b.satisfied_by(self.A()))
   self.assertTrue(exactly_b.satisfied_by(self.B()))
   self.assertFalse(exactly_b.satisfied_by(self.BPrime()))
   self.assertFalse(exactly_b.satisfied_by(self.C()))
Ejemplo n.º 3
0
    def test_ruleset_with_explicit_type_constraint(self):
        rules = [(Exactly(A), (Select(B), ), noop), (B, (Select(A), ), noop)]
        validator = RulesetValidator(
            RuleIndex.create(rules, tuple()),
            goal_to_product={},
            root_subject_fns={k: lambda p: Select(p)
                              for k in (SubA, )})

        validator.validate()
Ejemplo n.º 4
0
def constraint_for(type_or_constraint):
    """Given a type or an `Exactly` constraint, returns an `Exactly` constraint."""
    if isinstance(type_or_constraint, Exactly):
        return type_or_constraint
    elif isinstance(type_or_constraint, type):
        return Exactly(type_or_constraint)
    else:
        raise TypeError("Expected a type or constraint: got: {}".format(
            type_or_constraint))
Ejemplo n.º 5
0
    def test_noop_removal_full_single_subject_type(self):
        rules = _suba_root_rules + [
            TaskRule(Exactly(A), [Select(C)], noop),
            TaskRule(Exactly(A), [], noop),
        ]

        fullgraph = self.create_full_graph(RuleIndex.create(rules))

        self.assert_equal_with_printing(
            dedent("""
                     digraph {
                       // root subject types: SubA
                       // root entries
                         "Select(A) for SubA" [color=blue]
                         "Select(A) for SubA" -> {"(A, (,), noop) of SubA"}
                       // internal entries
                         "(A, (,), noop) of SubA" -> {}
                     }""").strip(), fullgraph)
Ejemplo n.º 6
0
 def type_constraint(self):
     if isinstance(self.product, Exactly):
         return self.product
     elif isinstance(self.product, type):
         return Exactly(self.product)
     else:
         raise TypeError(
             "unexpected product_type type for selector: {}".format(
                 self.product))
Ejemplo n.º 7
0
  def test_smallest_full_test_multiple_root_subject_types(self):
    rules = [
      (Exactly(A), (Select(SubA),), noop),
      (Exactly(B), (Select(A),), noop)
    ]
    select_p = lambda p: Select(p)
    graphmaker = GraphMaker(NodeBuilder.create(rules, tuple()),
      root_subject_fns=OrderedDict([(SubA, select_p), (A, select_p)]))
    fullgraph = graphmaker.full_graph()

    self.assert_equal_with_printing(dedent("""
                                      {
                                        root_subject_types: (SubA, A,)
                                        root_rules: (Exactly(A), (Select(SubA),), noop) of SubA, (Exactly(B), (Select(A),), noop) of A, (Exactly(B), (Select(A),), noop) of SubA, SubjectIsProduct(A)
                                        (Exactly(A), (Select(SubA),), noop) of SubA => (SubjectIsProduct(SubA),)
                                        (Exactly(B), (Select(A),), noop) of A => (SubjectIsProduct(A),)
                                        (Exactly(B), (Select(A),), noop) of SubA => ((Exactly(A), (Select(SubA),), noop) of SubA,)
                                      }""").strip(),
                                    fullgraph)
Ejemplo n.º 8
0
    def test_noop_removal_in_subgraph(self):
        rules = [
            TaskRule(Exactly(A), [Select(C)], noop),
            TaskRule(Exactly(A), [], noop),
            SingletonRule(B, B()),
        ]

        subgraph = self.create_subgraph(A, rules, SubA())

        self.assert_equal_with_printing(
            dedent("""
                     digraph {
                       // root subject types: SubA
                       // root entries
                         "Select(A) for SubA" [color=blue]
                         "Select(A) for SubA" -> {"(A, (,), noop) of SubA"}
                       // internal entries
                         "(A, (,), noop) of SubA" -> {}
                     }""").strip(), subgraph)
Ejemplo n.º 9
0
  def test_select_dependencies_multiple_field_types_all_resolvable(self):
    rules = [
      (Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop),
      (B, (Select(Exactly(C, D)),), noop),
    ]

    graphmaker = GraphMaker(NodeBuilder.create(rules, tuple()),
      root_subject_fns=_suba_root_subject_fns)
    subgraph = graphmaker.generate_subgraph(SubA(), requested_product=A)

    self.assert_equal_with_printing(dedent("""
                                      {
                                        root_subject_types: (SubA,)
                                        root_rules: (Exactly(A), (SelectDependencies(B, SubA, u'dependencies', field_types=(C, D,)),), noop) of SubA
                                        (B, (Select(Exactly(C, D)),), noop) of C => (SubjectIsProduct(C),)
                                        (B, (Select(Exactly(C, D)),), noop) of D => (SubjectIsProduct(D),)
                                        (Exactly(A), (SelectDependencies(B, SubA, u'dependencies', field_types=(C, D,)),), noop) of SubA => (SubjectIsProduct(SubA), (B, (Select(Exactly(C, D)),), noop) of C, (B, (Select(Exactly(C, D)),), noop) of D,)
                                      }""").strip(),
                                    subgraph)
Ejemplo n.º 10
0
  def test_noop_removal_full_single_subject_type(self):
    intrinsics = {(B, C): BoringRule(C)}
    rules = [
      # C is provided by an intrinsic, but only if the subject is B.
      (Exactly(A), (Select(C),), noop),
      (Exactly(A), tuple(), noop),
    ]

    graphmaker = GraphMaker(NodeBuilder.create(rules,
      intrinsic_providers=(IntrinsicProvider(intrinsics),)),
      root_subject_fns=_suba_root_subject_fns)
    fullgraph = graphmaker.full_graph()

    self.assert_equal_with_printing(dedent("""
                               {
                                 root_subject_types: (SubA,)
                                 root_rules: (Exactly(A), (), noop) of SubA
                                 (Exactly(A), (), noop) of SubA => (,)
                               }""").strip(), fullgraph)
Ejemplo n.º 11
0
    def create(cls,
               task_entries,
               intrinsic_providers=(FilesystemIntrinsicRule,
                                    SnapshotIntrinsicRule)):
        """Creates a NodeBuilder with tasks indexed by their output type."""
        # NB make tasks ordered so that gen ordering is deterministic.
        serializable_tasks = OrderedDict()

        def add_task(product_type, rule):
            if product_type not in serializable_tasks:
                serializable_tasks[product_type] = OrderedSet()
            serializable_tasks[product_type].add(rule)

        for entry in task_entries:
            if isinstance(entry, Rule):
                add_task(entry.output_product_type, entry)
            elif isinstance(entry, (tuple, list)) and len(entry) == 3:
                output_type, input_selectors, task = entry
                if isinstance(output_type, Exactly):
                    constraint = output_type
                elif isinstance(output_type, type):
                    constraint = Exactly(output_type)
                else:
                    raise TypeError(
                        "Unexpected product_type type {}, for rule {}".format(
                            output_type, entry))

                factory = TaskRule(tuple(input_selectors), task, output_type,
                                   constraint)
                for kind in constraint.types:
                    # NB Ensure that interior types from SelectDependencies / SelectProjections work by
                    # indexing on the list of types in the constraint.
                    add_task(kind, factory)
                add_task(constraint, factory)
            else:
                raise TypeError(
                    "Unexpected rule type: {}."
                    " Rules either extend Rule, or are 3 elem tuples.".format(
                        type(entry)))

        intrinsics = dict()
        for provider in intrinsic_providers:
            as_intrinsics = provider.as_intrinsics()
            duplicate_keys = [
                k for k in as_intrinsics.keys() if k in intrinsics
            ]
            if duplicate_keys:
                key_list = '\n  '.join(
                    '{}, {}'.format(sub.__name__, prod.__name__)
                    for sub, prod in duplicate_keys)
                raise ValueError(
                    'intrinsics provided by {} have already provided subject-type, '
                    'product-type keys:\n  {}'.format(provider, key_list))
            intrinsics.update(as_intrinsics)
        return cls(serializable_tasks, intrinsics)
Ejemplo n.º 12
0
  def test_select_dependencies_multiple_field_types_all_resolvable(self):
    rules = [
      TaskRule(Exactly(A), [SelectDependencies(B, SubA, field_types=(C, D,))], noop),
      TaskRule(B, [Select(Exactly(C, D))], noop),
    ]

    subgraph = self.create_subgraph(A, rules, SubA())

    self.assert_equal_with_printing(dedent("""
                     digraph {
                       // root subject types: SubA
                       // root entries
                         "Select(A) for SubA" [color=blue]
                         "Select(A) for SubA" -> {"(A, (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of SubA"}
                       // internal entries
                         "(A, (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of SubA" -> {"SubjectIsProduct(SubA)" "(B, (Select(Exactly(C, D)),), noop) of C" "(B, (Select(Exactly(C, D)),), noop) of D"}
                         "(B, (Select(Exactly(C, D)),), noop) of C" -> {"SubjectIsProduct(C)"}
                         "(B, (Select(Exactly(C, D)),), noop) of D" -> {"SubjectIsProduct(D)"}
                     }""").strip(),
      subgraph)
Ejemplo n.º 13
0
    def test_noop_removal_transitive(self):
        # If a noop-able rule has rules that depend on it,
        # they should be removed from the graph.
        rules = [
            TaskRule(Exactly(B), [Select(C)], noop),
            TaskRule(Exactly(A), [Select(B)], noop),
            TaskRule(Exactly(A), [], noop),
        ]
        subgraph = self.create_subgraph(A, rules, SubA())

        self.assert_equal_with_printing(
            dedent("""
                     digraph {
                       // root subject types: SubA
                       // root entries
                         "Select(A) for SubA" [color=blue]
                         "Select(A) for SubA" -> {"(A, (,), noop) of SubA"}
                       // internal entries
                         "(A, (,), noop) of SubA" -> {}
                     }""").strip(), subgraph)
Ejemplo n.º 14
0
    def test_root_tuple_removed_when_no_matches(self):
        rules = [
            RootRule(C),
            RootRule(D),
            TaskRule(Exactly(A), [Select(C)], noop),
            TaskRule(Exactly(B), [Select(D), Select(A)], noop),
        ]

        fullgraph = self.create_full_graph(RuleIndex.create(rules))

        self.assert_equal_with_printing(
            dedent("""
                     digraph {
                       // root subject types: C, D
                       // root entries
                         "Select(A) for C" [color=blue]
                         "Select(A) for C" -> {"(A, (Select(C),), noop) of C"}
                       // internal entries
                         "(A, (Select(C),), noop) of C" -> {"SubjectIsProduct(C)"}
                     }""").strip(), fullgraph)
Ejemplo n.º 15
0
  def test_select_dependencies_non_matching_subselector_because_of_singleton(self):
    rules = [
      TaskRule(Exactly(A), [SelectDependencies(B, SubA, field_types=(D,))], noop),
      SingletonRule(C, C()),
    ]
    subgraph = self.create_subgraph(A, rules, SubA())

    self.assert_equal_with_printing(dedent("""
                     digraph {
                       // empty graph
                     }""").strip(),
      subgraph)
Ejemplo n.º 16
0
  def test_noop_removal_transitive(self):
    # If a noop-able rule has rules that depend on it,
    # they should be removed from the graph.
    rules = [
      (Exactly(B), (Select(C),), noop),
      (Exactly(A), (Select(B),), noop),
      (Exactly(A), tuple(), noop),
    ]

    graphmaker = GraphMaker(NodeBuilder.create(rules, (IntrinsicProvider({(D, C): BoringRule(C)}),)),
      root_subject_fns=_suba_root_subject_fns,

    )
    subgraph = graphmaker.generate_subgraph(SubA(), requested_product=A)

    self.assert_equal_with_printing(dedent("""
                               {
                                 root_subject_types: (SubA,)
                                 root_rules: (Exactly(A), (), noop) of SubA
                                 (Exactly(A), (), noop) of SubA => (,)
                               }""").strip(), subgraph)
Ejemplo n.º 17
0
    def __new__(cls, output_type, value):
        # Validate result type.
        if isinstance(output_type, Exactly):
            constraint = output_type
        elif isinstance(output_type, type):
            constraint = Exactly(output_type)
        else:
            raise TypeError("Expected an output_type for rule; got: {}".format(
                output_type))

        # Create.
        return super(SingletonRule, cls).__new__(cls, constraint, value)
Ejemplo n.º 18
0
  def test_noop_removal_in_subgraph(self):
    rules = [
      # C is provided by an intrinsic, but only if the subject is B.
      (Exactly(A), (Select(C),), noop),
      (Exactly(A), tuple(), noop),
    ]
    intrinsics = [
      (B, C, noop),
    ]

    graphmaker = GraphMaker(NodeBuilder.create(rules,
                                               intrinsics),
      root_subject_fns=_suba_root_subject_fns)
    subgraph = graphmaker.generate_subgraph(SubA(), requested_product=A)

    self.assert_equal_with_printing(dedent("""
                               {
                                 root_subject_types: (SubA,)
                                 root_rules: (Exactly(A), (), noop) of SubA
                                 (Exactly(A), (), noop) of SubA => (,)
                               }""").strip(), subgraph)
Ejemplo n.º 19
0
 def test_single(self):
     exactly_b = Exactly(self.B)
     self.assertEqual((self.B, ), exactly_b.types)
     self.assertFalse(exactly_b.satisfied_by(self.A()))
     self.assertTrue(exactly_b.satisfied_by(self.B()))
     self.assertFalse(exactly_b.satisfied_by(self.BPrime()))
     self.assertFalse(exactly_b.satisfied_by(self.C()))
Ejemplo n.º 20
0
  def create(cls, task_entries, intrinsic_entries=None, singleton_entries=None):
    """Creates a NodeBuilder with tasks indexed by their output type."""
    intrinsic_entries = intrinsic_entries or tuple()
    singleton_entries = singleton_entries or tuple()
    # NB make tasks ordered so that gen ordering is deterministic.
    serializable_tasks = OrderedDict()

    def add_task(product_type, rule):
      if product_type not in serializable_tasks:
        serializable_tasks[product_type] = OrderedSet()
      serializable_tasks[product_type].add(rule)

    for entry in task_entries:
      if isinstance(entry, Rule):
        add_task(entry.output_product_type, entry)
      elif isinstance(entry, (tuple, list)) and len(entry) == 3:
        output_type, input_selectors, task = entry
        if isinstance(output_type, Exactly):
          constraint = output_type
        elif isinstance(output_type, type):
          constraint = Exactly(output_type)
        else:
          raise TypeError("Unexpected product_type type {}, for rule {}".format(output_type, entry))

        factory = TaskRule(tuple(input_selectors), task, output_type, constraint)
        # TODO: The heterogenity here has some confusing implications here:
        # see https://github.com/pantsbuild/pants/issues/4005
        for kind in constraint.types:
          # NB Ensure that interior types from SelectDependencies / SelectProjections work by
          # indexing on the list of types in the constraint.
          add_task(kind, factory)
        add_task(constraint, factory)
      else:
        raise TypeError("Unexpected rule type: {}."
                        " Rules either extend Rule, or are 3 elem tuples.".format(type(entry)))

    intrinsics = dict()
    for output_type, input_type, func in intrinsic_entries:
      key = (input_type, output_type)
      if key in intrinsics:
        raise ValueError('intrinsic provided by {} has already been provided by: {}'.format(
          func.__name__, intrinsics[key]))
      intrinsics[key] = IntrinsicRule(input_type, output_type, func)

    singletons = dict()
    for output_type, func in singleton_entries:
      if output_type in singletons:
        raise ValueError('singleton provided by {} has already been provided by: {}'.format(
          func.__name__, singletons[output_type]))
      singletons[output_type] = SingletonRule(output_type, func)
    return cls(serializable_tasks, intrinsics, singletons)
Ejemplo n.º 21
0
    def test_smallest_full_test(self):
        rules = [TaskRule(Exactly(A), [Select(SubA)], noop)]
        fullgraph = self.create_full_graph({SubA}, RuleIndex.create(rules))

        self.assert_equal_with_printing(
            dedent("""
                     digraph {
                       // root subject types: SubA
                       // root entries
                         "Select(A) for SubA" [color=blue]
                         "Select(A) for SubA" -> {"(A, (Select(SubA),), noop) of SubA"}
                       // internal entries
                         "(A, (Select(SubA),), noop) of SubA" -> {"SubjectIsProduct(SubA)"}
                     }""").strip(), fullgraph)
Ejemplo n.º 22
0
    def test_noop_removal_full_single_subject_type(self):
        rules = [
            # C is provided by an intrinsic, but only if the subject is B.
            (Exactly(A), (Select(C), ), noop),
            (Exactly(A), tuple(), noop),
        ]
        intrinsics = [
            (B, C, noop),
        ]

        graphmaker = GraphMaker(RuleIndex.create(rules, intrinsics),
                                root_subject_fns=_suba_root_subject_fns)
        fullgraph = graphmaker.full_graph()

        self.assert_equal_with_printing(
            dedent("""
                               {
                                 root_subject_types: (SubA,)
                                 root_rules:
                                 Select(A) for SubA => ((Exactly(A), (), noop) of SubA,)
                                 all_rules:
                                 (Exactly(A), (), noop) of SubA => (,)
                               }""").strip(), fullgraph)
Ejemplo n.º 23
0
  def test_noop_removal_full_single_subject_type(self):
    rules = [
      # C is provided by an intrinsic, but only if the subject is B.
      (Exactly(A), (Select(C),), noop),
      (Exactly(A), tuple(), noop),
    ]
    intrinsics = [
      (B, C, noop),
    ]

    fullgraph = self.create_full_graph(_suba_root_subject_types,
                                       RuleIndex.create(rules, intrinsics))

    self.assert_equal_with_printing(dedent("""
                     digraph {
                       // root subject types: SubA
                       // root entries
                         "Select(A) for SubA" [color=blue]
                         "Select(A) for SubA" -> {"(A, (,), noop) of SubA"}
                       // internal entries
                         "(A, (,), noop) of SubA" -> {}
                     }""").strip(),
      fullgraph)
Ejemplo n.º 24
0
  def test_select_dependencies_non_matching_subselector_because_of_intrinsic(self):
    rules = [
      (Exactly(A), (SelectDependencies(B, SubA, field_types=(D,)),), noop),
    ]
    intrinsics = [
      (C, B, noop),
    ]
    subgraph = self.create_subgraph_with_intrinsics(intrinsics, A, rules, SubA(),
                                                    _suba_root_subject_types)

    self.assert_equal_with_printing(dedent("""
                     digraph {
                       // empty graph
                     }""").strip(),
      subgraph)
Ejemplo n.º 25
0
  def test_single_rule_depending_on_subject_selection(self):
    rules = [
      (Exactly(A), (Select(SubA),), noop)
    ]

    graphmaker = GraphMaker(NodeBuilder.create(rules, tuple()),
      root_subject_fns=_suba_root_subject_fns)
    subgraph = graphmaker.generate_subgraph(SubA(), requested_product=A)

    self.assert_equal_with_printing(dedent("""
                               {
                                 root_subject_types: (SubA,)
                                 root_rules: (Exactly(A), (Select(SubA),), noop) of SubA
                                 (Exactly(A), (Select(SubA),), noop) of SubA => (SubjectIsProduct(SubA),)
                               }""").strip(), subgraph)
Ejemplo n.º 26
0
  def test_smallest_full_test(self):
    rules = [
      (Exactly(A), (Select(SubA),), noop)
    ]

    graphmaker = GraphMaker(NodeBuilder.create(rules, tuple()),
      root_subject_fns={k: lambda p: Select(p) for k in (SubA,)})
    fullgraph = graphmaker.full_graph()

    self.assert_equal_with_printing(dedent("""
                               {
                                 root_subject_types: (SubA,)
                                 root_rules: (Exactly(A), (Select(SubA),), noop) of SubA
                                 (Exactly(A), (Select(SubA),), noop) of SubA => (SubjectIsProduct(SubA),)
                               }""").strip(), fullgraph)
Ejemplo n.º 27
0
    def test_single_rule_depending_on_subject_selection(self):
        rules = [TaskRule(Exactly(A), [Select(SubA)], noop)]

        subgraph = self.create_subgraph(A, rules, SubA())

        self.assert_equal_with_printing(
            dedent("""
                     digraph {
                       // root subject types: SubA
                       // root entries
                         "Select(A) for SubA" [color=blue]
                         "Select(A) for SubA" -> {"(A, (Select(SubA),), noop) of SubA"}
                       // internal entries
                         "(A, (Select(SubA),), noop) of SubA" -> {"SubjectIsProduct(SubA)"}
                     }""").strip(), subgraph)
Ejemplo n.º 28
0
    def test_initial_select_projection_failure(self):
        rules = _suba_root_rules + [
            TaskRule(Exactly(A), [SelectProjection(B, D, 'some', C)], noop),
        ]
        validator = self.create_validator({}, rules)

        with self.assertRaises(ValueError) as cm:
            validator.assert_ruleset_valid()

        self.assert_equal_with_printing(
            dedent("""
                      Rules with errors: 1
                        (A, (SelectProjection(B, D, 'some', C),), noop):
                          no matches for Select(C) when resolving SelectProjection(B, D, 'some', C) with subject types: SubA
                      """).strip(), str(cm.exception))
Ejemplo n.º 29
0
    def test_secondary_select_projection_failure(self):
        rules = [(Exactly(A), (SelectProjection(B, D, ('some', ), C), ), noop),
                 (C, tuple(), noop)]

        validator = RulesetValidator(RuleIndex.create(rules, tuple()),
                                     goal_to_product={},
                                     root_subject_fns=_suba_root_subject_fns)

        with self.assertRaises(ValueError) as cm:
            validator.validate()

        self.assert_equal_with_printing(
            dedent("""
                      Rules with errors: 1
                        (Exactly(A), (SelectProjection(B, D, (u'some',), C),), noop):
                          no matches for Select(B) when resolving SelectProjection(B, D, (u'some',), C) with subject types: D
                      """).strip(), str(cm.exception))
Ejemplo n.º 30
0
class JvmAppAdaptor(TargetAdaptor):
    def __init__(self, bundles=None, **kwargs):
        """
    :param list bundles: A list of `BundleAdaptor` objects
    """
        super(JvmAppAdaptor, self).__init__(**kwargs)
        self.bundles = bundles

    @addressable_list(Exactly(BundleAdaptor))
    def bundles(self):
        """The BundleAdaptors for this JvmApp."""
        return self.bundles

    @property
    def field_adaptors(self):
        with exception_logging(logger,
                               'Exception in `field_adaptors` property'):
            field_adaptors = super(JvmAppAdaptor, self).field_adaptors
            if getattr(self, 'bundles', None) is None:
                return field_adaptors
            # Construct a field for the `bundles` argument.
            filespecs_list = []
            path_globs_list = []
            excluded_path_globs_list = []
            for bundle in self.bundles:
                # Short circuit in the case of `bundles=[..., bundle(), ...]`.
                if not hasattr(bundle, 'fileset'):
                    # N.B. This notice is duplicated in jvm_app.py::Bundle.__call__() for the old engine.
                    deprecated_conditional(
                        lambda: True, '1.2.0',
                        'bare bundle() without `fileset=` param',
                        "Pass a `fileset=` parameter: `bundle(fileset=globs('*.config')`"
                    )
                    logger.warn(
                        'Ignoring `bundle()` without `fileset` parameter.')
                    continue
                base_globs = BaseGlobs.from_sources_field(bundle.fileset)
                filespecs_list.append(base_globs.filespecs)
                path_globs, excluded_path_globs = base_globs.to_path_globs(
                    self.address.spec_path)
                path_globs_list.append(path_globs)
                excluded_path_globs_list.append(excluded_path_globs)
            bundles_field = BundlesField(self.address, self.bundles,
                                         filespecs_list, path_globs_list,
                                         excluded_path_globs_list)
            return field_adaptors + (bundles_field, )
Ejemplo n.º 31
0
  def test_secondary_select_projection_failure(self):
    rules = [
      (Exactly(A), (SelectProjection(B, D, ('some',), C),), noop),
      (C, tuple(), noop)
    ]

    validator = self.create_validator({}, tuple(), _suba_root_subject_types, rules)

    with self.assertRaises(ValueError) as cm:
      validator.assert_ruleset_valid()

    self.assert_equal_with_printing(dedent("""
                     Rules with errors: 1
                       (A, (SelectProjection(B, D, ('some',), C),), noop):
                         no matches for Select(B) when resolving SelectProjection(B, D, ('some',), C) with subject types: D
                     """).strip(),
                                    str(cm.exception))
Ejemplo n.º 32
0
  def test_select_dependencies_non_matching_subselector_because_of_intrinsic(self):
    rules = [
      (Exactly(A), (SelectDependencies(B, SubA, field_types=(D,)),), noop),
    ]
    intrinsics = [
      (C, B, noop),
    ]
    graphmaker = GraphMaker(NodeBuilder.create(rules, intrinsics),
                            root_subject_fns=_suba_root_subject_fns)
    subgraph = graphmaker.generate_subgraph(SubA(), requested_product=A)

    self.assert_equal_with_printing('{empty graph}', subgraph)
    self.assert_equal_with_printing(dedent("""
                         Rules with errors: 1
                           (Exactly(A), (SelectDependencies(B, SubA, u'dependencies', field_types=(D,)),), noop):
                             no matches for Select(B) when resolving SelectDependencies(B, SubA, u'dependencies', field_types=(D,)) with subject types: D""").strip(),
                                    subgraph.error_message())