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'))
