def test_select_dependencies_recurse_with_different_type(self): rules = [(Exactly(A), (SelectDependencies(B, SubA, field_types=( C, D, )), ), noop), (B, (Select(A), ), noop), (C, (Select(SubA), ), noop), (SubA, tuple(), noop)] graphmaker = GraphMaker(RuleIndex.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: Select(A) for SubA => ((Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of SubA,) all_rules: (B, (Select(A),), noop) of C => ((Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of C,) (B, (Select(A),), noop) of D => ((Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of D,) (Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of C => ((SubA, (), noop) of C, (B, (Select(A),), noop) of C, (B, (Select(A),), noop) of D,) (Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of D => ((SubA, (), noop) of D, (B, (Select(A),), noop) of C, (B, (Select(A),), noop) of D,) (Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of SubA => (SubjectIsProduct(SubA), (B, (Select(A),), noop) of C, (B, (Select(A),), noop) of D,) (SubA, (), noop) of C => (,) (SubA, (), noop) of D => (,) }""").strip(), subgraph)
def test_full_graph_for_planner_example(self): symbol_table_cls = TargetTable address_mapper = AddressMapper(symbol_table_cls, JsonParser, '*.BUILD.json') tasks = create_graph_tasks(address_mapper, symbol_table_cls) + create_fs_tasks() intrinsics = create_fs_intrinsics('Let us pretend that this is a ProjectTree!') rule_index = RuleIndex.create(tasks, intrinsics) graphmaker = GraphMaker(rule_index, root_subject_fns={k: lambda p: Select(p) for k in (Address, # TODO, use the actual fns. PathGlobs, SingleAddress, SiblingAddresses, DescendantAddresses, AscendantAddresses )}) fullgraph = graphmaker.full_graph() print('---diagnostic------') print(fullgraph.error_message()) print('/---diagnostic------') print(fullgraph) # Assert that all of the rules specified the various task fns are present declared_rules = rule_index.all_rules() rules_remaining_in_graph_strs = set(str(r.rule) for r in fullgraph.rule_dependencies.keys()) declared_rule_strings = set(str(r) for r in declared_rules) self.assertEquals(declared_rule_strings, rules_remaining_in_graph_strs ) # statically assert that the number of dependency keys is fixed self.assertEquals(41, len(fullgraph.rule_dependencies))
def test_select_dependencies_recurse_with_different_type(self): rules = [ (Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop), (B, (Select(A),), noop), (C, (Select(SubA),), noop), (SubA, tuple(), noop) ] graphmaker = GraphMaker(RuleIndex.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: Select(A) for SubA => ((Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of SubA,) all_rules: (B, (Select(A),), noop) of C => ((Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of C,) (B, (Select(A),), noop) of D => ((Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of D,) (Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of C => ((SubA, (), noop) of C, (B, (Select(A),), noop) of C, (B, (Select(A),), noop) of D,) (Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of D => ((SubA, (), noop) of D, (B, (Select(A),), noop) of C, (B, (Select(A),), noop) of D,) (Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of SubA => (SubjectIsProduct(SubA), (B, (Select(A),), noop) of C, (B, (Select(A),), noop) of D,) (SubA, (), noop) of C => (,) (SubA, (), noop) of D => (,) }""").strip(), subgraph)
def test_full_graph_for_planner_example(self): symbol_table_cls = TargetTable address_mapper = AddressMapper(symbol_table_cls, JsonParser, '*.BUILD.json') tasks = create_graph_tasks(address_mapper, symbol_table_cls) + create_fs_tasks() intrinsics = create_fs_intrinsics('Let us pretend that this is a ProjectTree!') rule_index = NodeBuilder.create(tasks, intrinsics) graphmaker = GraphMaker(rule_index, root_subject_fns={k: lambda p: Select(p) for k in (Address, # TODO, use the actual fns. PathGlobs, SingleAddress, SiblingAddresses, DescendantAddresses, AscendantAddresses )}) fullgraph = graphmaker.full_graph() print('---diagnostic------') print(fullgraph.error_message()) print('/---diagnostic------') print(fullgraph) # Assert that all of the rules specified the various task fns are present declared_rules = rule_index.all_rules() rules_remaining_in_graph_strs = set(str(r.rule) for r in fullgraph.rule_dependencies.keys()) declared_rule_strings = set(str(r) for r in declared_rules) self.assertEquals(declared_rule_strings, rules_remaining_in_graph_strs )
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), ] intrinsics = [ (D, C, BoringRule(C)) ] graphmaker = GraphMaker(RuleIndex.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: Select(A) for SubA => ((Exactly(A), (), noop) of SubA,) all_rules: (Exactly(A), (), noop) of SubA => (,) }""").strip(), subgraph)
def test_select_dependencies_multiple_field_types_all_resolvable_with_deps( self): rules = [ (Exactly(A), (SelectDependencies(B, SubA, field_types=( C, D, )), ), noop), # for the C type, it'll just be a literal, but for D, it'll traverse one more edge (B, (Select(C), ), noop), (C, (Select(D), ), noop), ] graphmaker = GraphMaker(RuleIndex.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: Select(A) for SubA => ((Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of SubA,) all_rules: (B, (Select(C),), noop) of C => (SubjectIsProduct(C),) (B, (Select(C),), noop) of D => ((C, (Select(D),), noop) of D,) (C, (Select(D),), noop) of D => (SubjectIsProduct(D),) (Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop) of SubA => (SubjectIsProduct(SubA), (B, (Select(C),), noop) of C, (B, (Select(C),), noop) of D,) }""").strip(), subgraph)
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)
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)
def test_select_literal(self): literally_a = A() rules = [ (B, (SelectLiteral(literally_a, A),), noop) ] graphmaker = GraphMaker(NodeBuilder.create(rules, tuple()), root_subject_fns=_suba_root_subject_fns) subgraph = graphmaker.generate_subgraph(SubA(), requested_product=B) self.assert_equal_with_printing(dedent(""" { root_subject_types: (SubA,) root_rules: (B, (SelectLiteral(A(), A),), noop) of SubA (B, (SelectLiteral(A(), A),), noop) of SubA => (Literal(A(), A),) }""").strip(), subgraph)
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(RuleIndex.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, field_types=(D,)),), noop): no matches for Select(B) when resolving SelectDependencies(B, SubA, field_types=(D,)) with subject types: D""").strip(), subgraph.error_message())
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())
def test_one_level_of_recursion(self): rules = [(Exactly(A), (Select(B), ), noop), (B, (Select(SubA), ), noop)] graphmaker = GraphMaker(RuleIndex.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: Select(A) for SubA => ((Exactly(A), (Select(B),), noop) of SubA,) all_rules: (B, (Select(SubA),), noop) of SubA => (SubjectIsProduct(SubA),) (Exactly(A), (Select(B),), noop) of SubA => ((B, (Select(SubA),), noop) of SubA,) }""").strip(), subgraph)
def test_depends_on_multiple_one_noop(self): rules = [(B, (Select(A), ), noop), (A, (Select(C), ), noop), (A, (Select(SubA), ), noop)] graphmaker = GraphMaker(RuleIndex.create(rules, tuple()), root_subject_fns=_suba_root_subject_fns) subgraph = graphmaker.generate_subgraph(SubA(), requested_product=B) self.assert_equal_with_printing( dedent(""" { root_subject_types: (SubA,) root_rules: Select(B) for SubA => ((B, (Select(A),), noop) of SubA,) all_rules: (A, (Select(SubA),), noop) of SubA => (SubjectIsProduct(SubA),) (B, (Select(A),), noop) of SubA => ((A, (Select(SubA),), noop) of SubA,) }""").strip(), subgraph)
def test_select_dependencies_with_subject_as_first_subselector(self): rules = [ (Exactly(A), (SelectDependencies(B, SubA, field_types=(D,)),), noop), (B, (Select(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=(D,)),), noop) of SubA (B, (Select(D),), noop) of D => (SubjectIsProduct(D),) (Exactly(A), (SelectDependencies(B, SubA, u'dependencies', field_types=(D,)),), noop) of SubA => (SubjectIsProduct(SubA), (B, (Select(D),), noop) of D,) }""").strip(), subgraph)
def test_depends_on_multiple_one_noop(self): rules = [ (B, (Select(A),), noop), (A, (Select(C),), noop), (A, (Select(SubA),), noop) ] graphmaker = GraphMaker(NodeBuilder.create(rules, tuple()), root_subject_fns=_suba_root_subject_fns) subgraph = graphmaker.generate_subgraph(SubA(), requested_product=B) self.assert_equal_with_printing(dedent(""" { root_subject_types: (SubA,) root_rules: (B, (Select(A),), noop) of SubA (A, (Select(SubA),), noop) of SubA => (SubjectIsProduct(SubA),) (B, (Select(A),), noop) of SubA => ((A, (Select(SubA),), noop) of SubA,) }""").strip(), subgraph)
def test_successful_when_one_field_type_is_unfulfillable(self): # NB We may want this to be a warning, since it may not be intentional rules = [ (B, (Select(SubA),), noop), (D, (Select(Exactly(B)), SelectDependencies(B, SubA, field_types=(SubA, C))), noop) ] graphmaker = GraphMaker(NodeBuilder.create(rules, tuple()), root_subject_fns=_suba_root_subject_fns) subgraph = graphmaker.generate_subgraph(SubA(), requested_product=D) self.assert_equal_with_printing(dedent(""" { root_subject_types: (SubA,) root_rules: (D, (Select(Exactly(B)), SelectDependencies(B, SubA, u'dependencies', field_types=(SubA, C,))), noop) of SubA (B, (Select(SubA),), noop) of SubA => (SubjectIsProduct(SubA),) (D, (Select(Exactly(B)), SelectDependencies(B, SubA, u'dependencies', field_types=(SubA, C,))), noop) of SubA => ((B, (Select(SubA),), noop) of SubA, SubjectIsProduct(SubA), (B, (Select(SubA),), noop) of SubA,) }""").strip(), subgraph)
def test_fails_if_root_subject_types_empty(self): rules = [ (A, (Select(B), ), noop), ] with self.assertRaises(ValueError) as cm: GraphMaker(RuleIndex.create(rules), tuple()) self.assertEquals( dedent(""" root_subject_fns must not be empty """).strip(), str(cm.exception))
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)
def test_multiple_depend_on_same_rule(self): rules = [ (B, (Select(A),), noop), (C, (Select(A),), noop), (A, (Select(SubA),), noop) ] graphmaker = GraphMaker(NodeBuilder.create(rules, tuple()), root_subject_fns=_suba_root_subject_fns) subgraph = graphmaker.full_graph() self.assert_equal_with_printing(dedent(""" { root_subject_types: (SubA,) root_rules: (A, (Select(SubA),), noop) of SubA, (B, (Select(A),), noop) of SubA, (C, (Select(A),), noop) of SubA (A, (Select(SubA),), noop) of SubA => (SubjectIsProduct(SubA),) (B, (Select(A),), noop) of SubA => ((A, (Select(SubA),), noop) of SubA,) (C, (Select(A),), noop) of SubA => ((A, (Select(SubA),), noop) of SubA,) }""").strip(), subgraph)
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)
def test_one_level_of_recursion(self): rules = [ (Exactly(A), (Select(B),), noop), (B, (Select(SubA),), noop) ] graphmaker = GraphMaker(RuleIndex.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: Select(A) for SubA => ((Exactly(A), (Select(B),), noop) of SubA,) all_rules: (B, (Select(SubA),), noop) of SubA => (SubjectIsProduct(SubA),) (Exactly(A), (Select(B),), noop) of SubA => ((B, (Select(SubA),), noop) of SubA,) }""").strip(), subgraph)
def test_select_projection_simple(self): rules = [ (Exactly(A), (SelectProjection(B, D, ('some',), SubA),), noop), (B, (Select(D),), noop), ] graphmaker = GraphMaker(RuleIndex.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: Select(A) for SubA => ((Exactly(A), (SelectProjection(B, D, (u'some',), SubA),), noop) of SubA,) all_rules: (B, (Select(D),), noop) of D => (SubjectIsProduct(D),) (Exactly(A), (SelectProjection(B, D, (u'some',), SubA),), noop) of SubA => (SubjectIsProduct(SubA), (B, (Select(D),), noop) of D,) }""").strip(), subgraph)
def test_select_dependencies_with_matching_intrinsic(self): rules = [ (Exactly(A), (SelectDependencies(B, SubA, field_types=(C,)),), 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), (SelectDependencies(B, SubA, u'dependencies', field_types=(C,)),), noop) of SubA (Exactly(A), (SelectDependencies(B, SubA, u'dependencies', field_types=(C,)),), noop) of SubA => (SubjectIsProduct(SubA), IntrinsicRule(noop) of C,) IntrinsicRule(noop) of C => (,) }""").strip(), subgraph)
def test_select_projection_simple(self): rules = [ (Exactly(A), (SelectProjection(B, D, ('some', ), SubA), ), noop), (B, (Select(D), ), noop), ] graphmaker = GraphMaker(RuleIndex.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: Select(A) for SubA => ((Exactly(A), (SelectProjection(B, D, (u'some',), SubA),), noop) of SubA,) all_rules: (B, (Select(D),), noop) of D => (SubjectIsProduct(D),) (Exactly(A), (SelectProjection(B, D, (u'some',), SubA),), noop) of SubA => (SubjectIsProduct(SubA), (B, (Select(D),), noop) of D,) }""").strip(), subgraph)
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)
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)
def test_select_dependencies_multiple_field_types_all_resolvable_with_deps(self): rules = [ (Exactly(A), (SelectDependencies(B, SubA, field_types=(C, D,)),), noop), # for the C type, it'll just be a literal, but for D, it'll traverse one more edge (B, (Select(C),), noop), (C, (Select(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(C),), noop) of C => (SubjectIsProduct(C),) (B, (Select(C),), noop) of D => ((C, (Select(D),), noop) of D,) (C, (Select(D),), noop) of D => (SubjectIsProduct(D),) (Exactly(A), (SelectDependencies(B, SubA, u'dependencies', field_types=(C, D,)),), noop) of SubA => (SubjectIsProduct(SubA), (B, (Select(C),), noop) of C, (B, (Select(C),), noop) of D,) }""").strip(), subgraph)
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)
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)