def test_deploy_jar_excludes(self):
target = self.make_target(':foo',
JvmBinary,
main='com.example.Foo',
deploy_excludes=[Exclude(org='example.com', name='foo-lib')])
self.assertEquals([Exclude(org='example.com', name='foo-lib')],
target.deploy_excludes)
def test_excludes_field(self):
empty = ExcludesField()
empty_fp = empty.fingerprint()
self.assertEqual(empty_fp, empty.fingerprint())
normal = ExcludesField([Exclude('com', 'foozle'), Exclude('org')])
normal_fp = normal.fingerprint()
self.assertEqual(normal_fp, normal.fingerprint())
normal_dup = ExcludesField([Exclude('com', 'foozle'), Exclude('org')])
self.assertEqual(normal_fp, normal_dup.fingerprint())
self.assertNotEqual(empty_fp, normal_fp)
def test_create_canonical_classpath(self):
a = self.make_target('a/b', JvmTarget)
jar_path = 'ivy/jars/org.x/lib/x-1.0.jar'
jar_path_excluded = 'ivy/jars/org.y/lib/y-1.0.jar'
classpath_products = ClasspathProducts(self.pants_workdir)
resolved_jar = ResolvedJar(M2Coordinate(org='org', name='x',
rev='1.0'),
cache_path='somewhere',
pants_path=self._path(jar_path))
# org.y should be excluded from result canonical path
resolved_jar_to_exclude = ResolvedJar(
M2Coordinate(org='org', name='y', rev='1.0'),
cache_path='somewhere',
pants_path=self._path(jar_path_excluded))
classpath_products.add_for_target(
a, [('default', self._path('a.jar')),
('default', self._path('resources'))])
classpath_products.add_jars_for_targets([a], 'default', [resolved_jar])
with temporary_dir() as base_dir:
self._test_canonical_classpath_helper(
classpath_products, [a],
base_dir,
True, [
'a.b.b-0.jar',
'a.b.b-1',
'a.b.b-2.jar',
], {
'a.b.b-classpath.txt':
'{}/a.jar:{}/resources:{}/{}\n'.format(
self.pants_workdir, self.pants_workdir,
self.pants_workdir, jar_path)
},
excludes=set([Exclude(org='org', name='y')]))
# incrementally delete the resource dendendency
classpath_products = ClasspathProducts(self.pants_workdir)
classpath_products.add_for_target(a,
[('default', self._path('a.jar'))])
self._test_canonical_classpath_helper(
classpath_products, [a], base_dir, True, [
'a.b.b-0.jar',
],
{'a.b.b-classpath.txt': '{}/a.jar\n'.format(self.pants_workdir)})
# incrementally add another jar dependency
classpath_products = ClasspathProducts(self.pants_workdir)
classpath_products.add_for_target(a,
[('default', self._path('a.jar')),
('default', self._path('b.jar'))])
self._test_canonical_classpath_helper(
classpath_products, [a], base_dir, True,
['a.b.b-0.jar', 'a.b.b-1.jar'], {
'a.b.b-classpath.txt':
'{}/a.jar:{}/b.jar\n'.format(self.pants_workdir,
self.pants_workdir)
})
def test_create_invalidation_strategy(self):
task = self.create_task(self.context())
invalidation_strategy = task.create_invalidation_strategy()
target = self.make_target('java:target',
target_type=JavaLibrary,
services={'com.foo.bars.Baz': ['com.spam.bars.BaxImplA']})
fingerprint1 = invalidation_strategy.fingerprint_target(target)
self.assertIsNotNone(fingerprint1)
# Removal of services should be detected.
self.reset_build_graph()
target = self.make_target('java:target', target_type=JavaLibrary)
fingerprint2 = invalidation_strategy.fingerprint_target(target)
self.assertIsNotNone(fingerprint2)
self.assertNotEqual(fingerprint1, fingerprint2)
# Target payload should not affect fingerprinting.
self.reset_build_graph()
target = self.make_target('java:target',
excludes=[Exclude('com.foo', 'fiz')],
target_type=JavaLibrary)
fingerprint3 = invalidation_strategy.fingerprint_target(target)
self.assertEqual(fingerprint2, fingerprint3)
# A change in services should be detected.
self.reset_build_graph()
target = self.make_target('java:target',
target_type=JavaLibrary,
services={'com.foo.bars.Baz': ['com.spam.bars.BazImplA',
'com.spam.bars.BazImplB']})
fingerprint4 = invalidation_strategy.fingerprint_target(target)
self.assertIsNotNone(fingerprint4)
self.assertNotEqual(fingerprint1, fingerprint4)
self.assertNotEqual(fingerprint2, fingerprint4)
def test_copy(self):
b = self.make_target('b', JvmTarget, excludes=[Exclude('com.example', 'lib')])
a = self.make_target('a', JvmTarget, dependencies=[b])
classpath_product = ClasspathProducts(self.pants_workdir)
resolved_jar = self.add_jar_classpath_element_for_path(classpath_product,
a,
self._example_jar_path())
classpath_product.add_for_target(a, [('default', self.path('a/path'))])
copied = classpath_product.copy()
a_closure = a.closure(bfs=True)
self.assertEqual([('default', resolved_jar.pants_path), ('default', self.path('a/path'))],
classpath_product.get_for_targets(a_closure))
self.assertEqual([('default', resolved_jar.pants_path), ('default', self.path('a/path'))],
copied.get_for_targets(a_closure))
self.add_excludes_for_targets(copied, b, a)
self.assertEqual([('default', resolved_jar.pants_path), ('default', self.path('a/path'))],
classpath_product.get_for_targets(a_closure))
self.assertEqual([('default', self.path('a/path'))],
copied.get_for_targets(a_closure))
copied.add_for_target(b, [('default', self.path('b/path'))])
self.assertEqual([('default', resolved_jar.pants_path), ('default', self.path('a/path'))],
classpath_product.get_for_targets(a_closure))
self.assertEqual([('default', self.path('a/path')), ('default', self.path('b/path'))],
copied.get_for_targets(a_closure))
def test_get_classpath_entries_for_targets_intransitive(self):
b = self.make_target('b',
JvmTarget,
excludes=[Exclude('com.example', 'lib')])
a = self.make_target('a', JvmTarget, dependencies=[b])
classpath_product = ClasspathProducts(self.pants_workdir)
example_jar_path = self._example_jar_path()
resolved_jar = self.add_jar_classpath_element_for_path(
classpath_product, a, example_jar_path)
classpath_product.add_for_target(
b, [('default', self.path('b/loose/classes/dir'))])
classpath_product.add_for_target(
a, [('default', self.path('a/loose/classes/dir')),
('default', self.path('an/internally/generated.jar'))])
classpath = classpath_product.get_classpath_entries_for_targets([a])
self.assertEqual(
[('default',
ArtifactClasspathEntry(example_jar_path, resolved_jar.coordinate,
resolved_jar.cache_path)),
('default', ClasspathEntry(self.path('a/loose/classes/dir'))),
('default',
ClasspathEntry(self.path('an/internally/generated.jar')))],
classpath)
def test_classpath_by_targets(self):
b = self.make_target('b', JvmTarget)
a = self.make_target('a',
JvmTarget,
dependencies=[b],
excludes=[Exclude('com.example', 'lib')])
classpath_products = ClasspathProducts(self.pants_workdir)
path1 = self._path('jar/path1')
path2 = self._path('jar/path2')
path3 = os.path.join(self.pants_workdir, 'jar/path3')
resolved_jar = ResolvedJar(M2Coordinate(org='com.example',
name='lib',
rev='1.0'),
cache_path='somewhere',
pants_path=path3)
classpath_products.add_for_target(a, [('default', path1)])
classpath_products.add_for_target(a, [('non-default', path2)])
classpath_products.add_for_target(b, [('default', path2)])
classpath_products.add_jars_for_targets([b], 'default', [resolved_jar])
classpath_products.add_excludes_for_targets([a])
# (a, path2) filtered because of conf
# (b, path3) filtered because of excludes
self.assertEquals(
OrderedDict([(a, [ClasspathEntry(path1)]),
(b, [ClasspathEntry(path2)])]),
ClasspathUtil.classpath_by_targets(a.closure(bfs=True),
classpath_products))
def get_excludes(cls):
if cls._excludes == None:
excludes = []
for exclude in cls.global_instance().get_options().excludes:
excludes.append(
Exclude(org=exclude['org'], name=exclude['name']))
cls._excludes = excludes
return cls._excludes
def _test_copy(self, original): # A no-op clone results in an equal object. self.assertEqual(original, original.copy()) # Excludes included in equality. excludes_added = original.copy(excludes=[Exclude(org='com.blah', name='blah')]) self.assertNotEqual(original, excludes_added) # Clones are equal with equal content. self.assertEqual(original.copy(rev='1.2.3'), original.copy(rev='1.2.3'))
def collect_provide_excludes(target):
if not target.is_exported:
return
logger.debug(
'Automatically excluding jar {}.{}, which is provided by {}'.
format(target.provides.org, target.provides.name, target))
provide_excludes.add(
Exclude(org=target.provides.org, name=target.provides.name))
def test_jar_dependency_excludes_change_hash(self):
exclude = Exclude(org='example.com', name='foo-lib')
with_excludes = JarDependency(org='foo',
name='foo',
excludes=[exclude])
without_excludes = JarDependency(org='foo', name='foo')
self.assertNotEqual(with_excludes.cache_key(),
without_excludes.cache_key())
def test_transitive_dependencies_excluded_classpath_element(self):
b = self.make_target('b', JvmTarget, excludes=[Exclude('com.example', 'lib')])
a = self.make_target('a', JvmTarget, dependencies=[b])
classpath_product = ClasspathProducts(self.pants_workdir)
self.add_jar_classpath_element_for_path(classpath_product, a, self._example_jar_path())
self.add_excludes_for_targets(classpath_product, b, a)
classpath = classpath_product.get_for_target(a)
self.assertEqual([], classpath)
def test_deploy_jar_excludes(self):
self.add_to_build_file('BUILD', dedent('''
jvm_binary(name='foo',
main='com.example.Foo',
deploy_excludes=[exclude(org='example.com', name='foo-lib')],
)
'''))
target = self.target('//:foo')
self.assertEquals([Exclude(org='example.com', name='foo-lib')],
target.deploy_excludes)
def test_jvm_target_with_excludes_is_hashed(self):
confs = ()
strategy = IvyResolveFingerprintStrategy(confs)
target_with_excludes = self.make_target(':jvm-target',
target_type=JvmTarget,
excludes=[Exclude('org.some')])
self.assertIsNotNone(
strategy.compute_fingerprint(target_with_excludes))
def collect_automatic_excludes(target):
if not target.is_exported:
return
# if a source dep is exported, it should always override remote/binary versions
# of itself, ie "round trip" dependencies
logger.debug(
'Automatically excluding jar {}.{}, which is provided by {}'.
format(target.provides.org, target.provides.name, target))
excludes.add(
Exclude(org=target.provides.org, name=target.provides.name))
def test_excludes_similar_org_name(self):
b = self.make_target('b', JvmTarget)
a = self.make_target('a', JvmTarget, excludes=[Exclude('com.exam')], dependencies=[b])
classpath_product = ClasspathProducts(self.pants_workdir)
self.add_example_jar_classpath_element_for(classpath_product, b)
self.add_excludes_for_targets(classpath_product, a)
classpath = classpath_product.get_for_targets(a.closure(bfs=True))
self.assertEqual([('default', self._example_jar_path())], classpath)
def test_excludes_used_across_targets(self):
b = self.make_target('b', JvmTarget)
a = self.make_target('a', JvmTarget, excludes=[Exclude('com.example', 'lib')])
classpath_product = ClasspathProducts(self.pants_workdir)
self.add_example_jar_classpath_element_for(classpath_product, b)
self.add_excludes_for_targets(classpath_product, a)
classpath = classpath_product.get_for_target(a)
self.assertEqual([], classpath)
def test_intransitive_dependencies_excluded_classpath_element(self):
b = self.make_target('b', JvmTarget, excludes=[Exclude('com.example', 'lib')])
a = self.make_target('a', JvmTarget, dependencies=[b])
classpath_product = ClasspathProducts(self.pants_workdir)
example_jar_path = self._example_jar_path()
classpath_product.add_for_target(a, [('default', example_jar_path)])
classpath_product.add_excludes_for_targets([a, b])
intransitive_classpath = classpath_product.get_for_target(a)
self.assertEqual([('default', example_jar_path)], intransitive_classpath)
def test_get_classpath_entries_for_targets_respect_excludes(self):
a = self.make_target('a', JvmTarget, excludes=[Exclude('com.example', 'lib')])
classpath_product = ClasspathProducts()
example_jar_path = self._example_jar_path()
self.add_jar_classpath_element_for_path(classpath_product, a, example_jar_path)
self.add_excludes_for_targets(classpath_product, a)
classpath = classpath_product.get_classpath_entries_for_targets([a])
self.assertEqual([], classpath)
def test_excludes_org_name(self):
b = self.make_target('b', JvmTarget)
a = self.make_target('a', JvmTarget, excludes=[Exclude('com.example')], dependencies=[b])
classpath_product = ClasspathProducts(self.pants_workdir)
self.add_example_jar_classpath_element_for(classpath_product, b)
self.add_excludes_for_targets(classpath_product, a)
classpath = classpath_product.get_for_target(a)
self.assertEqual([], classpath)
def test_excluded_classpath_element(self):
a = self.make_target('a', JvmTarget, excludes=[Exclude('com.example', 'lib')])
classpath_product = ClasspathProducts(self.pants_workdir)
example_jar_path = self._example_jar_path()
self.add_jar_classpath_element_for_path(classpath_product, a, example_jar_path)
self.add_excludes_for_targets(classpath_product, a)
classpath = classpath_product.get_for_target(a)
self.assertEqual([], classpath)
def test_parent_excludes_ignored_for_resolving_child_target(self):
b = self.make_target('b', JvmTarget)
a = self.make_target('a', JvmTarget, dependencies=[b], excludes=[Exclude('com.example', 'lib')])
example_jar_path = self._example_jar_path()
classpath_product = ClasspathProducts(self.pants_workdir)
self.add_jar_classpath_element_for_path(classpath_product, b, example_jar_path)
self.add_excludes_for_targets(classpath_product, a)
classpath = classpath_product.get_for_target(b)
self.assertEqual([('default', example_jar_path)], classpath)
def test_parent_exclude_excludes_dependency_jar(self):
b = self.make_target('b', JvmTarget)
a = self.make_target('a', JvmTarget, dependencies=[b], excludes=[Exclude('com.example', 'lib')])
classpath_product = ClasspathProducts()
example_jar_path = self._example_jar_path()
self.add_jar_classpath_element_for_path(classpath_product, b, example_jar_path)
self.add_excludes_for_targets(classpath_product, b, a)
classpath = classpath_product.get_for_target(a)
self.assertEqual([], classpath)
def test_excludes_in_java_lib_excludes_all_from_jar_lib(self):
junit_jar_lib = self._make_junit_target()
excluding_target = self.make_target(
'//:b', JavaLibrary, excludes=[Exclude('junit', 'junit')])
compile_classpath = self.resolve([junit_jar_lib, excluding_target])
junit_jar_cp = compile_classpath.get_for_target(junit_jar_lib)
excluding_cp = compile_classpath.get_for_target(excluding_target)
self.assertEquals(0, len(junit_jar_cp))
self.assertEquals(0, len(excluding_cp))
def test_excludes_in_java_lib_excludes_all_from_jar_lib(self):
junit_dep = JarDependency('junit', 'junit', rev='4.12')
junit_jar_lib = self.make_target('//:a', JarLibrary, jars=[junit_dep])
excluding_target = self.make_target(
'//:b', JavaLibrary, excludes=[Exclude('junit', 'junit')])
compile_classpath = self.resolve([junit_jar_lib, excluding_target])
junit_jar_cp = compile_classpath.get_for_target(junit_jar_lib)
excluding_cp = compile_classpath.get_for_target(excluding_target)
self.assertEquals(0, len(junit_jar_cp))
self.assertEquals(0, len(excluding_cp))
def test_excluded_classpath_element(self):
a = self.make_target('a',
JvmTarget,
excludes=[Exclude('com.example', 'lib')])
classpath_product = ClasspathProducts()
example_jar_path = self._example_jar_path()
classpath_product.add_for_target(a, [('default', example_jar_path)])
classpath_product.add_excludes_for_targets([a])
classpath = classpath_product.get_for_target(a)
self.assertEqual([], classpath)
def test_jar_in_classpath_not_a_resolved_jar_ignored_by_excludes(self):
b = self.make_target('b', JvmTarget)
a = self.make_target('a', JvmTarget, excludes=[Exclude('com.example')], dependencies=[b])
example_jar_path = self._example_jar_path()
classpath_product = ClasspathProducts(self.pants_workdir)
classpath_product.add_for_target(b, [('default', example_jar_path)])
self.add_excludes_for_targets(classpath_product, a)
classpath = classpath_product.get_for_targets(a.closure(bfs=True))
self.assertEqual([('default', example_jar_path)], classpath)
def test_excludes_used_across_targets(self):
b = self.make_target('b', JvmTarget)
a = self.make_target('a',
JvmTarget,
excludes=[Exclude('com.example', 'lib')])
classpath_product = ClasspathProducts()
classpath_product.add_for_target(
b, [('default', self._example_jar_path())])
classpath_product.add_excludes_for_targets([a])
classpath = classpath_product.get_for_target(a)
self.assertEqual([], classpath)
def collect_jars(target):
targets_processed.add(target)
if isinstance(target, JarLibrary):
for jar in target.jar_dependencies:
if jar.rev:
add_jar(jar)
target_excludes = target.payload.get_field_value('excludes')
if target_excludes:
excludes.update(target_excludes)
if target.is_exported:
# if a source dep is exported, it should always override remote/binary versions
# of itself, ie "round trip" dependencies
excludes.add(Exclude(org=target.provides.org, name=target.provides.name))
def test_jvm_binaries_deploy_excludes(self):
foo_jar_lib = self.make_target(
spec='3rdparty/jvm/org/example:foo',
target_type=JarLibrary,
jars=[JarDependency(org='org.example', name='foo', rev='1.0.0')])
binary_target = self.make_target(
spec='//bar:bar-binary',
target_type=JvmBinary,
source='Bar.java',
dependencies=[foo_jar_lib],
deploy_excludes=[Exclude(org='org.pantsbuild')])
context = self.context(target_roots=[binary_target])
classpath_products = self.ensure_classpath_products(context)
foo_artifact = self.create_artifact(org='org.example',
name='foo',
rev='1.0.0')
with open_zip(foo_artifact.pants_path, 'w') as jar:
jar.writestr('foo/Foo.class', '')
baz_artifact = self.create_artifact(org='org.pantsbuild',
name='baz',
rev='2.0.0')
with open_zip(baz_artifact.pants_path, 'w') as jar:
# This file should not be included in the binary jar since org.pantsbuild is deploy excluded.
jar.writestr('baz/Baz.class', '')
classpath_products.add_jars_for_targets(
targets=[foo_jar_lib],
conf='default',
resolved_jars=[foo_artifact, baz_artifact])
self.add_to_runtime_classpath(context, binary_target, {
'Bar.class': '',
'bar.txt': ''
})
self.execute(context)
jvm_binary_products = context.products.get('jvm_binaries')
self.assertIsNotNone(jvm_binary_products)
product_data = jvm_binary_products.get(binary_target)
dist_root = os.path.join(self.build_root, 'dist')
self.assertEquals({dist_root: ['bar-binary.jar']}, product_data)
with open_zip(os.path.join(dist_root, 'bar-binary.jar')) as jar:
self.assertEqual(
sorted([
'META-INF/', 'META-INF/MANIFEST.MF', 'foo/',
'foo/Foo.class', 'Bar.class', 'bar.txt'
]), sorted(jar.namelist()))
