def test_walk_addressables(self): self.assertEqual({self.addr('//:root'): Struct(name='root', type_alias='struct'), self.addr('a/b:b'): self.a_b_target, self.addr('a/d:d'): Target(name='d', type_alias='target'), self.addr('a/d/e:e'): Target(name='e', type_alias='target'), self.addr('a/d/e:e-prime'): Struct(name='e-prime', type_alias='struct')}, self.resolve_multi(DescendantAddresses('')))
def do_test_codegen_simple(self, scheduler): def address(name): return Address(spec_path='graph_test', target_name=name) resolved_java1 = self.resolve(scheduler, address('java1')) nonstrict = ApacheThriftConfiguration(address=address('nonstrict'), version='0.9.2', strict=False, lang='java') public = Struct(address=address('public'), url='https://oss.sonatype.org/#stagingRepositories') thrift1 = Target(address=address('thrift1')) thrift2 = Target(address=address('thrift2'), dependencies=[thrift1]) expected_java1 = Target(address=address('java1'), configurations=[ ApacheThriftConfiguration(version='0.9.2', strict=True, lang='java'), nonstrict, PublishConfiguration( default_repo=public, repos={ 'jake': Struct(url='https://dl.bintray.com/pantsbuild/maven'), 'jane': public } ) ], dependencies=[thrift2]) self.assertEqual(expected_java1, resolved_java1)
def test_extend_and_merge(self) -> None: extends_and_merges = Struct( age=32, label="green", items=[5], extends=Struct(age=42, other=True, knobs={"a": True}, items=[1, 2]), merges=[ Struct(age=52, other=False, items=[1, 3, 4], knobs={ "a": False, "b": True }), Struct(items=[2]), ], ) self.assertEqual( Struct( age=32, label="green", other=True, items=[5, 1, 3, 4, 2], knobs={ "a": False, "b": True }, ), extends_and_merges.create(), )
def test_merge(self) -> None: merges = Struct(age=32, items=[3], knobs={'b': False}, merges=[ Struct(age=42, other=True, items=[1, 2], knobs={ 'a': True, 'b': True }) ]) # Merging is lazy, so we don't pick up the other field yet. self.assertNotEqual( Struct(age=32, items=[3, 1, 2], knobs={ 'a': True, 'b': True }, other=True), merges) # But we do pick it up now. self.assertEqual( Struct(age=32, items=[3, 1, 2], knobs={ 'a': True, 'b': True }, other=True), merges.create())
def test_extend_and_merge(self) -> None: extends_and_merges = Struct(age=32, label='green', items=[5], extends=Struct(age=42, other=True, knobs={'a': True}, items=[1, 2]), merges=[ Struct(age=52, other=False, items=[1, 3, 4], knobs={ 'a': False, 'b': True }), Struct(items=[2]) ]) self.assertEqual( Struct(age=32, label='green', other=True, items=[5, 1, 3, 4, 2], knobs={ 'a': False, 'b': True }), extends_and_merges.create())
def test_extend(self): extends = Struct(age=32, label='green', items=[], extends=Struct(age=42, other=True, items=[1, 2])) # Extension is lazy, so we don't pick up the other field yet. self.assertNotEqual(Struct(age=32, label='green', items=[], other=True), extends) # But we do pick it up now. self.assertEqual(Struct(age=32, label='green', items=[], other=True), extends.create())
def test_type_alias(self): self.assertEqual('Struct', Struct().type_alias) self.assertEqual('aliased', Struct(type_alias='aliased').type_alias) class Subclass(Struct): pass self.assertEqual('Subclass', Subclass().type_alias) self.assertEqual('aliased_subclass', Subclass(type_alias='aliased_subclass').type_alias)
def test_type_alias(self) -> None: self.assertEqual("Struct", Struct().type_alias) self.assertEqual("aliased", Struct(type_alias="aliased").type_alias) class Subclass(Struct): pass self.assertEqual("Subclass", Subclass().type_alias) self.assertEqual("aliased_subclass", Subclass(type_alias="aliased_subclass").type_alias)
def do_test_codegen_simple(self, scheduler): def address(name: str) -> Address: return Address(spec_path="graph_test", target_name=name) resolved_java1 = self.resolve(scheduler, address("java1")) nonstrict = ApacheThriftConfiguration( type_alias="ApacheThriftConfig", address=address("nonstrict"), version="0.10.0", strict=False, lang="java", ) public = Struct( type_alias="Struct", address=address("public"), url="https://oss.sonatype.org/#stagingRepositories", ) thrift1 = Target(address=address("thrift1")) thrift2 = Target(address=address("thrift2"), dependencies=[thrift1]) expected_java1 = Target( address=address("java1"), configurations=[ PublishConfiguration( type_alias="PublishConfig", default_repo=public, repos={ "jake": Struct(type_alias="Struct", url="https://dl.bintray.com/pantsbuild/maven"), "jane": public, }, ), nonstrict, ApacheThriftConfiguration( type_alias="ApacheThriftConfig", version="0.10.0", strict=True, dependencies=[address("thrift2")], lang="java", ), ], dependencies=[thrift2], type_alias="Target", ) self.assertEqual(expected_java1.configurations, resolved_java1.configurations)
def setUp(self): # Set up a scheduler that supports address mapping. symbol_table = TargetTable() address_mapper = AddressMapper(parser=JsonParser(symbol_table), build_patterns=('*.BUILD.json',)) rules = create_fs_rules() + create_graph_rules(address_mapper, symbol_table) # TODO handle updating the rule graph when passed unexpected root selectors. # Adding the following task allows us to get around the fact that SelectDependencies # requests are not currently supported. rules.append(TaskRule(UnhydratedStructs, [SelectDependencies(UnhydratedStruct, BuildFileAddresses, field_types=(Address,), field='addresses')], UnhydratedStructs)) project_tree = self.mk_fs_tree(os.path.join(os.path.dirname(__file__), 'examples/mapper_test')) self.build_root = project_tree.build_root self.scheduler = self.mk_scheduler(rules=rules, project_tree=project_tree) self.a_b = Address.parse('a/b') self.a_b_target = Target(name='b', dependencies=['//d:e'], configurations=['//a', Struct(embedded='yes')], type_alias='target')
def test_walk_descendants_rel_path(self): self.assertEqual( { self.addr('a/d:d'): Target(name='d', type_alias='target'), self.addr('a/d/e:e'): Target(name='e', type_alias='target'), self.addr('a/d/e:e-prime'): Struct(name='e-prime', type_alias='struct') }, self.resolve_multi(DescendantAddresses('a/d')))
def setUp(self): # Set up a scheduler that supports address mapping. symbol_table_cls = TargetTable address_mapper = AddressMapper(symbol_table_cls=symbol_table_cls, parser_cls=JsonParser, build_patterns=('*.BUILD.json',)) tasks = create_graph_tasks(address_mapper, symbol_table_cls) project_tree = self.mk_fs_tree(os.path.join(os.path.dirname(__file__), 'examples/mapper_test')) self.build_root = project_tree.build_root self.scheduler = self.mk_scheduler(tasks=tasks, project_tree=project_tree) self.a_b = Address.parse('a/b') self.a_b_target = Target(name='b', dependencies=['//d:e'], configurations=['//a', Struct(embedded='yes')], type_alias='target')
def test_no_address_no_family(self): spec = SingleAddress('a/c', 'c') # Does not exist. self.assertEqual(0, len(self.resolve(spec))) # Exists on disk, but not yet in memory. directory = 'a/c' build_file = os.path.join(self.build_root, directory, 'c.BUILD.json') with safe_open(build_file, 'w') as fp: fp.write('{"type_alias": "struct", "name": "c"}') self.assertEqual(0, len(self.resolve(spec))) # Success. self.scheduler.invalidate_files([directory]) resolved = self.resolve(spec) self.assertEqual(1, len(resolved)) self.assertEqual(Struct(name='c', type_alias='struct'), resolved[0].struct)
def test_no_address_no_family(self): spec = SingleAddress('a/c', None) # Should fail: does not exist. with self.assertRaises(ResolveError): self.resolve(spec) # Exists on disk, but not yet in memory. build_file = os.path.join(self.build_root, 'a/c/c.BUILD.json') with safe_open(build_file, 'w') as fp: fp.write('{"type_alias": "struct", "name": "c"}') with self.assertRaises(ResolveError): self.resolve(spec) # Success. self.scheduler.product_graph.invalidate() resolved = self.resolve(spec) self.assertEqual(1, len(resolved)) self.assertEqual(Struct(name='c', type_alias='struct'), resolved[0].struct)
def setUp(self) -> None: # Set up a scheduler that supports address mapping. address_mapper = AddressMapper(parser=JsonParser(TARGET_TABLE), build_patterns=('*.BUILD.json',)) # We add the `unhydrated_structs` rule because it is otherwise not used in the core engine. rules = [ unhydrated_structs ] + create_fs_rules() + create_graph_rules(address_mapper) project_tree = self.mk_fs_tree(os.path.join(os.path.dirname(__file__), 'examples/mapper_test')) self.build_root = project_tree.build_root self.scheduler = self.mk_scheduler(rules=rules, project_tree=project_tree) self.a_b = Address.parse('a/b') self.a_b_target = Target(address=self.a_b, dependencies=['//a/d/e'], configurations=['//a/d/e', Struct(embedded='yes')], type_alias='target')
def test_no_address_no_family(self): spec = SingleAddress('a/c', 'c') # Does not exist. with self.assertRaises(Exception): self.resolve(spec) build_file = os.path.join(self.build_root, 'a/c', 'c.BUILD.json') with safe_open(build_file, 'w') as fp: fp.write('{"type_alias": "struct", "name": "c"}') # Exists on disk, but not yet in memory. with self.assertRaises(Exception): self.resolve(spec) self.scheduler.invalidate_files(['a/c']) # Success. resolved = self.resolve(spec) self.assertEqual(1, len(resolved)) self.assertEqual([Struct(name='c', type_alias='struct')], [r.struct for r in resolved])
def test_no_address_no_family(self) -> None: spec = SingleAddress("a/c", "c") # Does not exist. with self.assertRaises(Exception): self.resolve(spec) build_file = os.path.join(self.build_root, "a/c", "c.BUILD.json") with safe_open(build_file, "w") as fp: fp.write('{"type_alias": "struct", "name": "c"}') # Exists on disk, but not yet in memory. with self.assertRaises(Exception): self.resolve(spec) self.scheduler.invalidate_files(["a/c"]) # Success. resolved = self.resolve(spec) self.assertEqual(1, len(resolved)) self.assertEqual([Struct(address=Address.parse("a/c"), type_alias="struct")], resolved)
def test_address_no_name(self) -> None: config = Struct(address=Address.parse("a:b")) self.assertEqual("b", config.name)
def test_address_name_conflict(self) -> None: with self.assertRaises(ValidationError): Struct(name="a", address=Address.parse("a:b"))
def test_walk_addressables_path_excludes(self): self.assertEqual({self.addr('//:root'): Struct(name='root'), self.addr('a/d:d'): Target(name='d')}, self.resolve_multi(DescendantAddresses('')))
def test_address_no_name(self): config = Struct(address=Address.parse('a:b')) self.assertEqual('b', config.name)
def do_test_codegen_simple(self, scheduler): def address(name): return Address(spec_path='graph_test', target_name=name) java1_address = address('java1') resolved_java1 = self.resolve(scheduler, java1_address) nonstrict_address = address('nonstrict') expected_nonstrict = ApacheThriftConfiguration(address=nonstrict_address, version='0.9.2', strict=False, lang='java') public_address = address('public') expected_public = Struct(address=public_address, url='https://oss.sonatype.org/#stagingRepositories') thrift2_address = address('thrift2') expected_java1 = Target(address=java1_address, sources={}, configurations=[ PublishConfiguration( default_repo=expected_public, repos={ 'jake': Struct(url='https://dl.bintray.com/pantsbuild/maven'), 'jane': expected_public } ), expected_nonstrict, ApacheThriftConfiguration( version='0.9.2', strict=True, lang='java', dependencies=[address(thrift2_address)] ), ]) self.assertEqual(expected_java1, resolved_java1) resolved_nonstrict = self.resolve(scheduler, nonstrict_address) self.assertEqual(expected_nonstrict, resolved_nonstrict) self.assertEqual(expected_nonstrict, expected_java1.configurations[1]) self.assertEquals(resolved_java1.configurations[1], resolved_nonstrict) resolved_public = self.resolve(scheduler, public_address) self.assertEqual(expected_public, resolved_public) self.assertEqual(expected_public, expected_java1.configurations[0].default_repo) self.assertEqual(expected_public, expected_java1.configurations[0].repos['jane']) self.assertEquals(resolved_java1.configurations[0].default_repo, resolved_public) self.assertEquals(resolved_java1.configurations[0].repos['jane'], resolved_public) # NB: `dependencies` lists must be explicitly requested by tasks, so we expect an Address. thrift1_address = address('thrift1') expected_thrift2 = Target(address=thrift2_address, dependencies=[thrift1_address]) resolved_thrift2 = self.resolve(scheduler, thrift2_address) self.assertEqual(expected_thrift2, resolved_thrift2) expected_thrift1 = Target(address=thrift1_address) resolved_thrift1 = self.resolve(scheduler, thrift1_address) self.assertEqual(expected_thrift1, resolved_thrift1)
def test_address_name_conflict(self): with self.assertRaises(ValidationError): Struct(name='a', address=Address.parse('a:b'))