def test_iter(self):
set1 = PinnedJarArtifactSet(pinned_coordinates=[
M2Coordinate("org", "foo", "1.2"),
M2Coordinate("org", "bar", "7.8"),
])
self.assertEqual(2, len(set1))
set2 = PinnedJarArtifactSet(set1)
self.assertEqual(2, len(set2))
self.assertEqual(set1, set2)
def test_iter(self):
set1 = PinnedJarArtifactSet(pinned_coordinates=[
M2Coordinate('org', 'foo', '1.2'),
M2Coordinate('org', 'bar', '7.8'),
])
self.assertEquals(2, len(set1))
set2 = PinnedJarArtifactSet(set1)
self.assertEquals(2, len(set2))
self.assertEquals(set1, set2)
def test_equality(self):
set1 = PinnedJarArtifactSet(pinned_coordinates=[
M2Coordinate('org', 'foo', '1.2'),
M2Coordinate('org', 'bar', '7.8'),
])
set2 = PinnedJarArtifactSet(pinned_coordinates=[
M2Coordinate('org', 'foo', '1.2'),
M2Coordinate('org', 'bar', '7.8'),
])
self.assertEquals(set1, set2)
self.assertEquals(hash(set1), hash(set2))
def test_equality(self):
set1 = PinnedJarArtifactSet(pinned_coordinates=[
M2Coordinate("org", "foo", "1.2"),
M2Coordinate("org", "bar", "7.8"),
])
set2 = PinnedJarArtifactSet(pinned_coordinates=[
M2Coordinate("org", "foo", "1.2"),
M2Coordinate("org", "bar", "7.8"),
])
self.assertEqual(set1, set2)
self.assertEqual(hash(set1), hash(set2))
def test_identical_jar_libraries_with_differing_managed_deps_differ(self):
confs = ()
strategy = CoursierResolveFingerprintStrategy(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 _compute_jars_to_resolve_and_pin(raw_jars, artifact_set, manager):
"""
This method provides settled lists of jar dependencies and coordinates
based on conflict management.
:param raw_jars: a collection of `JarDependencies`
:param artifact_set: PinnedJarArtifactSet
:param manager: JarDependencyManagement
:return: (list of settled `JarDependency`, set of pinned `M2Coordinate`)
"""
if artifact_set is None:
artifact_set = PinnedJarArtifactSet()
untouched_pinned_artifact = set(
M2Coordinate.create(x) for x in artifact_set)
jar_list = list(raw_jars)
for i, dep in enumerate(jar_list):
direct_coord = M2Coordinate.create(dep)
# Portion to manage pinned jars in case of conflict
if direct_coord in artifact_set:
managed_coord = artifact_set[direct_coord]
untouched_pinned_artifact.remove(managed_coord)
if direct_coord.rev != managed_coord.rev:
# It may be necessary to actually change the version number of the jar we want to resolve
# here, because overrides do not apply directly (they are exclusively transitive). This is
# actually a good thing, because it gives us more control over what happens.
coord = manager.resolve_version_conflict(managed_coord,
direct_coord,
force=dep.force)
# Once a version is settled, we force it anyway
jar_list[i] = dep.copy(rev=coord.rev, force=True)
return jar_list, untouched_pinned_artifact
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_identical_jar_libraries_with_differing_managed_deps_differ(self):
confs = ()
strategy = IvyResolveFingerprintStrategy(
self.create_task(self.context()), 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_replace(self):
set1 = PinnedJarArtifactSet(pinned_coordinates=[
M2Coordinate('org', 'foo', '1.2'),
M2Coordinate('org', 'bar', '7.8'),
])
set1.put(M2Coordinate('org', 'hello', '9'))
self.assertEqual(3, len(set1))
set1.put(M2Coordinate('org', 'foo', '1.3'))
self.assertEqual(3, len(set1))
self.assertEqual(M2Coordinate('org', 'foo', '1.3'), set1[M2Coordinate('org', 'foo')])
def _generate_resolve_ivy(cls, jars, excludes, ivyxml, confs, resolve_hash_name, pinned_artifacts=None,
jar_dep_manager=None):
org = IvyUtils.INTERNAL_ORG_NAME
name = resolve_hash_name
extra_configurations = [conf for conf in confs if conf and conf != 'default']
jars_by_key = OrderedDict()
for jar in jars:
jars = jars_by_key.setdefault((jar.org, jar.name), [])
jars.append(jar)
manager = jar_dep_manager or JarDependencyManagement.global_instance()
artifact_set = PinnedJarArtifactSet(pinned_artifacts) # Copy, because we're modifying it.
for jars in jars_by_key.values():
for i, dep in enumerate(jars):
direct_coord = M2Coordinate.create(dep)
managed_coord = artifact_set[direct_coord]
if direct_coord.rev != managed_coord.rev:
# It may be necessary to actually change the version number of the jar we want to resolve
# here, because overrides do not apply directly (they are exclusively transitive). This is
# actually a good thing, because it gives us more control over what happens.
coord = manager.resolve_version_conflict(managed_coord, direct_coord, force=dep.force)
jars[i] = dep.copy(rev=coord.rev)
elif dep.force:
# If this dependency is marked as 'force' and there is no version conflict, use the normal
# pants behavior for 'force'.
artifact_set.put(direct_coord)
dependencies = [cls._generate_jar_template(jars) for jars in jars_by_key.values()]
# As it turns out force is not transitive - it only works for dependencies pants knows about
# directly (declared in BUILD files - present in generated ivy.xml). The user-level ivy docs
# don't make this clear [1], but the source code docs do (see isForce docs) [2]. I was able to
# edit the generated ivy.xml and use the override feature [3] though and that does work
# transitively as you'd hope.
#
# [1] http://ant.apache.org/ivy/history/2.3.0/settings/conflict-managers.html
# [2] https://svn.apache.org/repos/asf/ant/ivy/core/branches/2.3.0/
# src/java/org/apache/ivy/core/module/descriptor/DependencyDescriptor.java
# [3] http://ant.apache.org/ivy/history/2.3.0/ivyfile/override.html
overrides = [cls._generate_override_template(_coord) for _coord in artifact_set]
excludes = [cls._generate_exclude_template(exclude) for exclude in excludes]
template_data = TemplateData(
org=org,
module=name,
extra_configurations=extra_configurations,
dependencies=dependencies,
excludes=excludes,
overrides=overrides)
template_relpath = os.path.join('templates', 'ivy_utils', 'ivy.mustache')
cls._write_ivy_xml_file(ivyxml, template_data, template_relpath)
def test_replace(self):
set1 = PinnedJarArtifactSet(pinned_coordinates=[
M2Coordinate("org", "foo", "1.2"),
M2Coordinate("org", "bar", "7.8"),
])
set1.put(M2Coordinate("org", "hello", "9"))
self.assertEqual(3, len(set1))
set1.put(M2Coordinate("org", "foo", "1.3"))
self.assertEqual(3, len(set1))
self.assertEqual(M2Coordinate("org", "foo", "1.3"),
set1[M2Coordinate("org", "foo")])
def test_id(self):
set1 = PinnedJarArtifactSet(pinned_coordinates=[
M2Coordinate('org', 'foo', '1.2'),
M2Coordinate('org', 'bar', '7.8'),
M2Coordinate('org', 'foo', '1.8', ext='tar')
])
self.assertFalse(set1.id is None)
self.assertFalse(set1._id is None)
set1.put(M2Coordinate('hello', 'there', '9'))
self.assertTrue(set1._id is None)
self.assertFalse(set1.id is None)
set1.put(M2Coordinate('org', 'foo', '1.2'))
self.assertFalse(set1._id is None) # Should be no change, because version was already there.
def test_lookup(self):
set1 = PinnedJarArtifactSet(pinned_coordinates=[
M2Coordinate('org', 'foo', '1.2'),
M2Coordinate('org', 'bar', '7.8'),
M2Coordinate('org', 'foo', '1.8', ext='tar')
])
self.assertEqual('1.2', set1[M2Coordinate('org', 'foo')].rev)
self.assertEqual('7.8', set1[M2Coordinate('org', 'bar')].rev)
self.assertEqual('1.8', set1[M2Coordinate('org', 'foo', ext='tar')].rev)
self.assertEqual({coord.rev for coord in set1}, {'1.2', '7.8', '1.8'})
self.assertIn(M2Coordinate('org', 'foo'), set1)
self.assertIn(M2Coordinate('org', 'foo', '27'), set1)
self.assertNotIn(M2Coordinate('hello', 'there'), set1)
def test_lookup(self):
set1 = PinnedJarArtifactSet(pinned_coordinates=[
M2Coordinate("org", "foo", "1.2"),
M2Coordinate("org", "bar", "7.8"),
M2Coordinate("org", "foo", "1.8", ext="tar"),
])
self.assertEqual("1.2", set1[M2Coordinate("org", "foo")].rev)
self.assertEqual("7.8", set1[M2Coordinate("org", "bar")].rev)
self.assertEqual("1.8", set1[M2Coordinate("org", "foo",
ext="tar")].rev)
self.assertEqual({coord.rev for coord in set1}, {"1.2", "7.8", "1.8"})
self.assertIn(M2Coordinate("org", "foo"), set1)
self.assertIn(M2Coordinate("org", "foo", "27"), set1)
self.assertNotIn(M2Coordinate("hello", "there"), set1)
def test_id(self):
set1 = PinnedJarArtifactSet(pinned_coordinates=[
M2Coordinate("org", "foo", "1.2"),
M2Coordinate("org", "bar", "7.8"),
M2Coordinate("org", "foo", "1.8", ext="tar"),
])
self.assertFalse(set1.id is None)
self.assertFalse(set1._id is None)
set1.put(M2Coordinate("hello", "there", "9"))
self.assertTrue(set1._id is None)
self.assertFalse(set1.id is None)
set1.put(M2Coordinate("org", "foo", "1.2"))
self.assertFalse(
set1._id is
None) # Should be no change, because version was already there.
def test_identical_jar_libraries_with_same_jar_dep_management_artifacts_match(self):
confs = ()
strategy = CoursierResolveFingerprintStrategy(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_lookup_noop(self):
self.assertEquals(
M2Coordinate('org', 'foo', '1.2'),
PinnedJarArtifactSet()[M2Coordinate('org', 'foo', '1.2')])
def test_put_failure(self):
set1 = PinnedJarArtifactSet()
with self.assertRaises(PinnedJarArtifactSet.MissingVersion):
set1.put(M2Coordinate('hello', 'there'))
def test_lookup_noop(self):
self.assertEqual(
M2Coordinate("org", "foo", "1.2"),
PinnedJarArtifactSet()[M2Coordinate("org", "foo", "1.2")],
)
