def test_resolve_ignores_jars_with_rev_left_off(self):
"""If a resolve jar leaves off the rev, we're supposed to get the latest version,
but coursier doesn't currently support that.
https://github.com/coursier/coursier/issues/209
"""
with self.assertRaises(TaskError) as cm:
jar = JarDependency('com.google.guava', 'guava')
lib = self.make_target('//:b', JarLibrary, jars=[jar])
self.resolve([lib])
self.assertEqual(
'Undefined revs for jars unsupported by Coursier. "jar(org=u\'com.google.guava\', name=u\'guava\', rev=None, classifier=None, ext=u\'jar\')"',
str(cm.exception))
def test_resolve_conflicted(self):
with self._temp_task_cache_dir():
losing_dep = JarDependency('com.google.guava', 'guava', '16.0')
winning_dep = JarDependency('com.google.guava', 'guava', '16.0.1')
losing_lib = self.make_target('//:a',
JarLibrary,
jars=[losing_dep])
winning_lib = self.make_target('//:b',
JarLibrary,
jars=[winning_dep])
compile_classpath = self.resolve([losing_lib, winning_lib])
losing_cp = compile_classpath.get_for_target(losing_lib)
winning_cp = compile_classpath.get_for_target(winning_lib)
self.assertEqual(losing_cp, winning_cp)
self.assertEqual(1, len(winning_cp))
conf, path = winning_cp[0]
self.assertEqual('default', conf)
self.assertEqual('guava-16.0.1.jar', os.path.basename(path))
def _make_jar_library(self, coordinate, jar_filename):
build_path = os.path.join(self.build_root, "unpack", "jars", "BUILD")
if os.path.exists(build_path):
os.remove(build_path)
return self.make_target(
spec="unpack/jars:foo-jars",
target_type=JarLibrary,
jars=[
JarDependency(
coordinate.org, coordinate.name, coordinate.rev, url=f"file:{jar_filename}"
)
],
)
def test_supplied(self):
self.make_target('test:checkstyle',
JarLibrary,
jars=[
JarDependency('com.puppycrawl.tools',
'checkstyle', '6.10.1')
])
task = self.prepare_execute(context=self.context())
classpath = task.execute()
with self.execute_tool(classpath,
'com.puppycrawl.tools.checkstyle.Main',
args=['-v']) as out:
self.assertIn('6.10.1', out)
def _make_jar_library(self, coordinate, jar_filename):
build_path = os.path.join(self.build_root, 'unpack', 'jars', 'BUILD')
if os.path.exists(build_path):
os.remove(build_path)
return self.make_target(spec='unpack/jars:foo-jars',
target_type=JarLibrary,
jars=[
JarDependency(
coordinate.org,
coordinate.name,
coordinate.rev,
url='file:{}'.format(jar_filename))
])
def test_default_target(self):
default_target = self.make_target(spec='//foo:management',
target_type=ManagedJarDependencies,
artifacts=[
JarDependency(org='foobar',
name='foobar',
rev='2'),
])
jar_library = self.make_target(spec='//foo:library',
target_type=JarLibrary,
jars=[
JarDependency(org='foobar',
name='foobar'),
])
context = self.context(target_roots=[default_target, jar_library])
manager = self._init_manager(default_target='//foo:management')
task = self.create_task(context)
task.execute()
artifact_set = manager.for_target(jar_library)
self.assertFalse(artifact_set is None)
self.assertEquals('2', artifact_set[M2Coordinate('foobar',
'foobar')].rev)
def test_bad_default(self):
jar_library = self.make_target(spec='//foo:library',
target_type=JarLibrary,
jars=[
JarDependency(org='foobar',
name='foobar'),
])
context = self.context(target_roots=[jar_library])
self._init_manager(default_target='//foo:nonexistant')
task = self.create_task(context)
with self.assertRaises(
JarDependencyManagementSetup.InvalidDefaultTarget):
task.execute()
def register_options(cls, register):
super().register_options(register)
register('--main',
default='scala.tools.nsc.MainGenericRunner',
help='The entry point for running the repl.')
cls.register_jvm_tool(register,
'pants-runner',
classpath=[
JarDependency(org='org.pantsbuild',
name='pants-runner',
rev='0.0.1'),
],
main=ScalaRepl._RUNNER_MAIN)
def register_options(cls, register):
super().register_options(register)
register(
"--main",
default="scala.tools.nsc.MainGenericRunner",
help="The entry point for running the repl.",
)
cls.register_jvm_tool(
register,
"pants-runner",
classpath=[JarDependency(org="org.pantsbuild", name="pants-runner", rev="0.0.1")],
main=ScalaRepl._RUNNER_MAIN,
)
def test_bad_libraries_ref(self):
self.make_target(':right-type',
JarLibrary,
jars=[JarDependency('foo', 'bar', '123')])
# Making a target which is not a jar library, which causes an error.
self.make_target(':wrong-type',
UnpackedJars,
libraries=[':right-type'])
target = self.make_target(':foo',
UnpackedJars,
libraries=[':wrong-type'])
with self.assertRaises(ImportJarsMixin.WrongTargetTypeError):
target.imported_targets
def register_scala_repl_tool(version, with_jline=False):
classpath = [cls._create_compiler_jardep(version)
] # Note: the REPL is in the compiler jar.
if with_jline:
jline_dep = JarDependency(
org='org.scala-lang',
name='jline',
rev=scala_build_info[version].full_version)
classpath.append(jline_dep)
cls.register_jvm_tool(register,
cls.versioned_tool_name(
'scala-repl', version),
classpath=classpath)
def init_dependencies_for_scala_libraries(self):
init_subsystem(
ScalaPlatform,
{
ScalaPlatform.options_scope: {
"version": "custom",
"suffix_version": "2.12",
}
},
)
init_subsystem(JUnit, )
init_subsystem(ScoveragePlatform)
self.make_target(
"//:scala-library",
target_type=JarLibrary,
jars=[JarDependency(org="com.example", name="scala", rev="0.0.0")],
)
self.make_target(
"//:junit-library",
target_type=JarLibrary,
jars=[JarDependency(org="com.example", name="scala", rev="0.0.0")],
)
def register_options(cls, register):
super(Checkstyle, cls).register_options(register)
register('--skip',
type=bool,
fingerprint=True,
help='Skip checkstyle.')
register('--configuration',
advanced=True,
type=file_option,
fingerprint=True,
help='Path to the checkstyle configuration file.')
register(
'--properties',
advanced=True,
type=dict_with_files_option,
default={},
fingerprint=True,
help=
'Dictionary of property mappings to use for checkstyle.properties.'
)
register(
'--confs',
advanced=True,
type=list,
default=['default'],
help='One or more ivy configurations to resolve for this target.')
register('--include-user-classpath',
type=bool,
fingerprint=True,
help='Add the user classpath to the checkstyle classpath')
cls.register_jvm_tool(
register,
'checkstyle',
# Note that checkstyle 7.0 does not run on Java 7 runtimes or below.
classpath=[
JarDependency(org='com.puppycrawl.tools',
name='checkstyle',
rev='6.19'),
],
main=cls._CHECKSTYLE_MAIN,
custom_rules=[
# Checkstyle uses reflection to load checks and has an affordance that
# allows leaving off a check classes' package name. This affordance
# breaks for built-in checkstyle checks under shading so we ensure all
# checkstyle packages are excluded from shading such that just its
# third party transitive deps (guava and the like), are shaded.
# See the module configuration rules here which describe this:
# http://checkstyle.sourceforge.net/config.html#Modules
Shader.exclude_package('com.puppycrawl.tools.checkstyle',
recursive=True),
])
def setUp(self):
"""
:API: public
"""
super(TestCobertura, self).setUp()
self.pants_workdir = 'workdir'
self.conf = 'default'
self.factory = Cobertura.Factory("test_scope", [])
self.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'),
JarDependency(org='org.pantsbuild',
name='bar',
rev='2.0.0',
ext='zip')
])
self.binary_target = self.make_target(spec='//foo:foo-binary',
target_type=JvmBinary,
source='Foo.java',
dependencies=[self.jar_lib])
self.app_target = self.make_target(spec='//foo:foo-app',
target_type=JvmApp,
basename='FooApp',
dependencies=[self.binary_target])
self.java_target = self.make_target(spec='//foo:foo-java',
target_type=JavaLibrary,
sources=[])
self.annotation_target = self.make_target(
spec='//foo:foo-anno', target_type=AnnotationProcessor)
def setUp(self):
"""Prepare targets, context, runtime classpath. """
super(TestBundleCreate, self).setUp()
self.task = self.prepare_execute(self.context())
self.jar_artifact = self.create_artifact(org='org.example', name='foo', rev='1.0.0')
self.zip_artifact = self.create_artifact(org='org.pantsbuild', name='bar', rev='2.0.0',
ext='zip')
self.bundle_artifact = self.create_artifact(org='org.apache', name='baz', rev='3.0.0',
classifier='tests')
self.tar_gz_artifact = self.create_artifact(org='org.gnu', name='gary', rev='4.0.0',
ext='tar.gz')
self.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'),
JarDependency(org='org.pantsbuild',
name='bar',
rev='2.0.0',
ext='zip'),
JarDependency(org='org.apache', name='baz', rev='3.0.0',
classifier='tests'),
JarDependency(org='org.gnu', name='gary', rev='4.0.0',
ext='tar.gz')])
safe_file_dump(os.path.join(self.build_root, 'resources/foo/file'), '// dummy content')
self.resources_target = self.make_target('//resources:foo-resources', Resources,
sources=['foo/file'])
# This is so that payload fingerprint can be computed.
safe_file_dump(os.path.join(self.build_root, 'foo/Foo.java'), '// dummy content')
self.java_lib_target = self.make_target('//foo:foo-library', JavaLibrary, sources=['Foo.java'])
self.binary_target = self.make_target(spec='//foo:foo-binary',
target_type=JvmBinary,
dependencies=[self.java_lib_target, self.jar_lib, self.resources_target])
self.dist_root = os.path.join(self.build_root, 'dist')
def test_artifacts_indirection(self):
jar_library_unversioned = self.make_target(
target_type=JarLibrary,
spec='//foo:library-unversioned',
jars=[
JarDependency(org='foobar', name='foobar'),
],
)
jar_library_versioned = self.make_target(
target_type=JarLibrary,
spec='//foo:library-versioned',
jars=[
JarDependency(org='foobar', name='foobar', rev='2'),
],
)
indirect_target = self.make_target(target_type=Target,
spec='//foo:indirect-deps',
dependencies=[
jar_library_versioned,
])
management_target = self.make_target(
target_type=ManagedJarDependencies,
spec='//foo:management',
artifacts=[
'//foo:indirect-deps',
])
context = self.context(target_roots=[
management_target, indirect_target, jar_library_versioned,
jar_library_unversioned
])
manager = self._init_manager(default_target='//foo:management')
task = self.create_task(context)
task.execute()
artifact_set = self._single_artifact_set(manager,
[jar_library_unversioned])
self.assertFalse(artifact_set is None)
self.assertEqual('2', artifact_set[M2Coordinate('foobar',
'foobar')].rev)
def setUp(self):
super().setUp()
self.conf = "default"
self.factory = Cobertura.Factory("test_scope", [])
self.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"),
JarDependency(org="org.pantsbuild",
name="bar",
rev="2.0.0",
ext="zip"),
],
)
self.binary_target = self.make_target(
spec="//foo:foo-binary",
target_type=JvmBinary,
source="Foo.java",
dependencies=[self.jar_lib],
)
self.app_target = self.make_target(
spec="//foo:foo-app",
target_type=JvmApp,
basename="FooApp",
dependencies=[self.binary_target],
)
self.java_target = self.make_target(spec="//foo:foo-java",
target_type=JavaLibrary,
sources=[])
self.annotation_target = self.make_target(
spec="//foo:foo-anno", target_type=AnnotationProcessor)
def test_heterogenous_for_targets(self):
default_target = self.make_target(
spec="//foo:management",
target_type=ManagedJarDependencies,
artifacts=[
JarDependency(org="foobar", name="foobar", rev="2"),
],
)
jar_library1 = self.make_target(
spec="//foo:library",
target_type=JarLibrary,
jars=[
JarDependency(org="foobar", name="foobar"),
],
)
jar_library2 = self.make_target(
spec="//foo:library2",
target_type=JarLibrary,
jars=[
JarDependency(org="vegetables", name="potato", rev="3"),
],
)
unpacked_target = self.make_target(spec="//foo:unpacked",
target_type=UnpackedJars,
libraries=[
":library2",
])
context = self.context(target_roots=[
default_target, jar_library1, jar_library2, unpacked_target
])
manager = self._init_manager(default_target="//foo:management")
task = self.create_task(context)
task.execute()
artifact_set = self._single_artifact_set(
manager, [jar_library1, jar_library2, unpacked_target])
self.assertFalse(artifact_set is None)
self.assertEqual("2", artifact_set[M2Coordinate("foobar",
"foobar")].rev)
def test_identical_jar_libraries_with_same_jar_dep_management_artifacts_match(
self):
confs = ()
strategy = IvyResolveFingerprintStrategy(confs)
managed_jar_deps = self.make_target(
':managed',
target_type=ManagedJarDependencies,
artifacts=[JarDependency('org.some', 'name')])
self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())
jar_lib_1 = self.make_target(':jar-lib-1',
target_type=JarLibrary,
jars=[JarDependency('org.some', 'name')],
managed_dependencies=':managed')
jar_lib_2 = self.make_target(':jar-lib-2',
target_type=JarLibrary,
jars=[JarDependency('org.some', 'name')],
managed_dependencies=':managed')
self.assertEqual(strategy.compute_fingerprint(jar_lib_1),
strategy.compute_fingerprint(jar_lib_2))
def test_missing_hardlinked_jar_in_candidates(self):
empty_hardlink_map = {}
result = IvyResolveResult(
['non-existent-file-location'], empty_hardlink_map, 'hash-name', {
'default':
self.ivy_report_path(
'ivy_utils_resources/report_with_diamond.xml')
})
with self.assertRaises(IvyResolveMappingError):
list(
result.resolved_jars_for_each_target('default', [
self.make_target(
't', JarLibrary, jars=[JarDependency('org1', 'name1')])
]))
def init_dependencies_for_scala_libraries(self):
init_subsystem(
ScalaPlatform,
{
ScalaPlatform.options_scope: {
'version': 'custom',
'suffix_version': '2.12',
}
}
)
init_subsystem(
JUnit,
)
self.make_target(
'//:scala-library',
target_type=JarLibrary,
jars=[JarDependency(org='com.example', name='scala', rev='0.0.0')]
)
self.make_target(
'//:junit-library',
target_type=JarLibrary,
jars=[JarDependency(org='com.example', name='scala', rev='0.0.0')]
)
def register_options(cls, register):
super(RoutesGen, cls).register_options(register)
cls.register_jvm_tool(
register,
'play-pants-tool',
classpath=[
JarDependency(
org='com.thesamet',
name='play-pants-tool',
rev='0.0.7-SNAPSHOT',
url=
'file:///Users/lawrencefinn/Documents/marc/libs/play-pants-tool-0.0.7-SNAPSHOT.jar',
mutable=True),
])
def test_default_target(self):
default_target = self.make_target(
spec="//foo:management",
target_type=ManagedJarDependencies,
artifacts=[
JarDependency(org="foobar", name="foobar", rev="2"),
],
)
jar_library = self.make_target(
spec="//foo:library",
target_type=JarLibrary,
jars=[
JarDependency(org="foobar", name="foobar"),
],
)
context = self.context(target_roots=[default_target, jar_library])
manager = self._init_manager(default_target="//foo:management")
task = self.create_task(context)
task.execute()
artifact_set = manager.for_target(jar_library)
self.assertFalse(artifact_set is None)
self.assertEqual("2", artifact_set[M2Coordinate("foobar",
"foobar")].rev)
def test_supplied(self):
self.make_target(
"test:checkstyle",
JarLibrary,
jars=[
JarDependency("com.puppycrawl.tools", "checkstyle", "6.10.1")
],
)
task = self.prepare_execute(context=self.context())
classpath = task.execute()
with self.execute_tool(classpath,
"com.puppycrawl.tools.checkstyle.Main",
args=["-v"]) as out:
self.assertIn("6.10.1", out)
def test_heterogenous_for_targets(self):
default_target = self.make_target(spec='//foo:management',
target_type=ManagedJarDependencies,
artifacts=[
JarDependency(org='foobar',
name='foobar',
rev='2'),
])
jar_library1 = self.make_target(spec='//foo:library',
target_type=JarLibrary,
jars=[
JarDependency(org='foobar',
name='foobar'),
])
jar_library2 = self.make_target(spec='//foo:library2',
target_type=JarLibrary,
jars=[
JarDependency(org='vegetables',
name='potato',
rev='3'),
])
unpacked_target = self.make_target(spec='//foo:unpacked',
target_type=UnpackedJars,
libraries=[
':library2',
])
context = self.context(target_roots=[
default_target, jar_library1, jar_library2, unpacked_target
])
manager = self._init_manager(default_target='//foo:management')
task = self.create_task(context)
task.execute()
artifact_set = self._single_artifact_set(
manager, [jar_library1, jar_library2, unpacked_target])
self.assertFalse(artifact_set is None)
self.assertEqual('2', artifact_set[M2Coordinate('foobar',
'foobar')].rev)
def register_options(cls, register):
super().register_options(register)
register(
"--override",
type=list,
fingerprint=True,
help="Specifies a jar dependency override in the form: "
"[org]#[name]=(revision|url) "
"Multiple overrides can be specified using repeated invocations of this flag. "
"For example, to specify 2 overrides: "
"--override=com.foo#bar=0.1.2 "
"--override=com.baz#spam=file:///tmp/spam.jar ",
)
register("--report",
type=bool,
help="Generate an ivy resolve html report")
register(
"--open",
type=bool,
help="Attempt to open the generated ivy resolve report "
"in a browser (implies --report)",
)
register("--outdir",
help="Emit ivy report outputs in to this directory.")
register("--args",
type=list,
fingerprint=True,
help="Pass these extra args to ivy.")
register(
"--confs",
type=list,
default=["default"],
fingerprint=True,
help="Pass a configuration to ivy in addition to the default ones.",
)
register(
"--mutable-pattern",
fingerprint=True,
help=
"If specified, all artifact revisions matching this pattern will be treated as "
"mutable unless a matching artifact explicitly marks mutable as False.",
)
cls.register_jvm_tool(register,
"xalan",
classpath=[
JarDependency(org="xalan",
name="xalan",
rev="2.7.1"),
])
def register_options_for(jvm_tool_mixin_cls, register, **kwargs):
"""Register options for the zinc tool in the context of the given JvmToolMixin.
TODO: Move into the classmethod after zinc registration has been removed
from `zinc_compile` in `1.6.0.dev0`.
"""
cls = jvm_tool_mixin_cls
def sbt_jar(name, **kwargs):
return JarDependency(org='org.scala-sbt', name=name, rev='1.0.0-X5', **kwargs)
shader_rules = [
# The compiler-interface and compiler-bridge tool jars carry xsbt and
# xsbti interfaces that are used across the shaded tool jar boundary so
# we preserve these root packages wholesale along with the core scala
# APIs.
Shader.exclude_package('scala', recursive=True),
Shader.exclude_package('xsbt', recursive=True),
Shader.exclude_package('xsbti', recursive=True),
]
cls.register_jvm_tool(register,
'zinc',
classpath=[
JarDependency('org.pantsbuild', 'zinc_2.10', '0.0.5'),
],
main=Zinc.ZINC_COMPILE_MAIN,
custom_rules=shader_rules,
**kwargs)
cls.register_jvm_tool(register,
'compiler-bridge',
classpath=[
sbt_jar(name='compiler-bridge_2.10',
classifier='sources',
intransitive=True)
],
**kwargs)
cls.register_jvm_tool(register,
'compiler-interface',
classpath=[
sbt_jar(name='compiler-interface')
],
# NB: We force a noop-jarjar'ing of the interface, since it is now broken
# up into multiple jars, but zinc does not yet support a sequence of jars
# for the interface.
main='no.such.main.Main',
custom_rules=shader_rules,
**kwargs)
def test_identical_jar_libraries_with_differing_managed_deps_differ(self):
confs = ()
strategy = IvyResolveFingerprintStrategy(confs)
managed_jar_deps = self.make_target(
':managed',
target_type=ManagedJarDependencies,
artifacts=[JarDependency('org.some', 'name')])
self.set_artifact_set_for(managed_jar_deps, PinnedJarArtifactSet())
jar_lib_with_managed_deps = self.make_target(
':jar-lib-1',
target_type=JarLibrary,
jars=[JarDependency('org.some', 'name')],
managed_dependencies=':managed')
jar_lib_without_managed_deps = self.make_target(
':jar-lib-no-managed-dep',
target_type=JarLibrary,
jars=[JarDependency('org.some', 'name')])
self.assertNotEqual(
strategy.compute_fingerprint(jar_lib_with_managed_deps),
strategy.compute_fingerprint(jar_lib_without_managed_deps))
def test_invalid_managed_jar_libraries(self):
target_aliases = {
'managed_jar_dependencies': ManagedJarDependencies,
'jar_library': JarLibrary,
}
class FakeContext(object):
def create_object(fake, target_type, name, **kwargs):
return self.make_target(
target_type=target_aliases[target_type],
spec='//foo:{}'.format(name),
**kwargs)
with self.assertRaises(ManagedJarLibraries.JarLibraryNameCollision):
ManagedJarLibraries(FakeContext())(
name='management',
artifacts=[
JarDependency(org='fruit.apple', name='orange', rev='2'),
JarDependency(org='fruit',
name='apple',
rev='2',
classifier='orange'),
],
)
def test_invalid_managed_jar_libraries(self):
target_aliases = {
"managed_jar_dependencies": ManagedJarDependencies,
"jar_library": JarLibrary,
}
class FakeContext:
def create_object(fake, target_type, name, **kwargs):
return self.make_target(
target_type=target_aliases[target_type],
spec=f"//foo:{name}",
**kwargs)
with self.assertRaises(ManagedJarLibraries.JarLibraryNameCollision):
ManagedJarLibraries(FakeContext())(
name="management",
artifacts=[
JarDependency(org="fruit.apple", name="orange", rev="2"),
JarDependency(org="fruit",
name="apple",
rev="2",
classifier="orange"),
],
)
def test_jar_relative_url(self):
abs_url = 'file://{}/a/b/c'.format(get_buildroot())
rel_url = 'file:a/b/c'
# Three equivalent ways of using absolute/relative url.
jar1 = JarDependency('org', 'name', url=abs_url)
jar2 = JarDependency('org', 'name', url=rel_url, base_path='.')
jar3 = JarDependency('org', 'name', url=abs_url, base_path='a/b')
self.assertEquals(jar1.get_url(relative=False), jar2.get_url(relative=False))
self.assertEquals(jar1.get_url(relative=False), jar3.get_url(relative=False))
self.assertEquals(jar1.get_url(relative=True), jar2.get_url(relative=True))
def verify_url_attributes(spec, jar, expected_attributes):
target = self.make_target(spec, JarLibrary, jars=[jar])
frozen_resolution = FrozenResolution()
frozen_resolution.add_resolved_jars(target, [])
self.assertEquals(frozen_resolution.coordinate_to_attributes.values(), expected_attributes)
verify_url_attributes('t1', jar1, [{'url': 'file:a/b/c', 'base_path': '.'}])
verify_url_attributes('t2', jar2, [{'url': 'file:a/b/c', 'base_path': '.'}])
verify_url_attributes('t3', jar3, [{'url': 'file:c', 'base_path': 'a/b'}])
