def test_normalize_deps__skip_pomgen_mode_allows_refs_to_same_package(
self):
ws = workspace.Workspace("so/path", [],
exclusions.src_exclusions(),
maveninstallinfo.NOOP,
pom_content=pomcontent.NOOP)
package = "a/b/c"
art1 = buildpom.MavenArtifactDef("g1",
"a1",
"1",
bazel_package=package,
pom_generation_mode=pomgenmode.SKIP)
dep1 = dependency.MonorepoDependency(art1, bazel_target=None)
art2 = buildpom.MavenArtifactDef("g2",
"a2",
"1",
bazel_package=package)
dep2 = dependency.MonorepoDependency(art2, bazel_target=None)
art3 = buildpom.MavenArtifactDef("g1",
"a1",
"1",
bazel_package="d/e/f")
dep3 = dependency.MonorepoDependency(art3, bazel_target=None)
dep4 = dependency.ThirdPartyDependency("name", "g101", "a101", "1")
# the result of this method is based on bazel_package comparison
deps = ws.normalize_deps(art1, [dep1, dep2, dep3, dep4])
self.assertEqual([dep1, dep2, dep3, dep4], deps)
def test_template_genmode__goldfile(self):
"""
Verifies version omissions when genmode is GOLDFILE.
"""
ws = workspace.Workspace("some/path", [], exclusions.src_exclusions(),
self._mocked_mvn_install_info("maven"),
pomcontent.NOOP)
artifact_def = buildpom.maven_artifact("groupId", "artifactId",
"1.2.3")
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
srpc_artifact_def = buildpom.maven_artifact("com.grail.srpc",
"srpc-api", "5.6.7")
srpc_artifact_def = buildpom._augment_art_def_values(
srpc_artifact_def, None, "pack1", None, None, pomgenmode.DYNAMIC)
srpc_dep = dependency.MonorepoDependency(srpc_artifact_def,
bazel_target=None)
artifact_def.custom_pom_template_content = """
this artifact version #{version}
logback coord #{ch.qos.logback:logback-classic:version}
logback qualified #{@maven//:ch_qos_logback_logback_classic.version}
logback unqualified #{ch_qos_logback_logback_classic.version}
srpc #{com.grail.srpc:srpc-api:version}
"""
pomgen = pom.TemplatePomGen(ws, artifact_def, dep)
pomgen.register_dependencies_transitive_closure__library(
set([srpc_dep]))
generated_pom = pomgen.gen(pomcontenttype=pom.PomContentType.GOLDFILE)
self.assertIn("this artifact version ***", generated_pom)
self.assertIn("logback coord 1.2.3", generated_pom)
self.assertIn("logback qualified 1.2.3", generated_pom)
self.assertIn("logback unqualified 1.2.3", generated_pom)
self.assertIn("srpc ***", generated_pom)
def test_src_dep_without_build_pom(self):
"""
Verifies we correctly produce an error when a monorepo src ref is
missing a BUILD.pom file.
"""
artifact_version = "1.2.3"
package_name = "package"
group_id = "group1"
artifact_id = "art1"
repo_root = tempfile.mkdtemp("monorepo")
self._touch_file_at_path(repo_root, "", "MVN-INF", "LIBRARY.root")
self._write_build_pom(repo_root, package_name, artifact_id, group_id, artifact_version)
bad_package_name = "bad_package"
os.mkdir(os.path.join(repo_root, bad_package_name)) # no BUILD.pom
ws = workspace.Workspace(repo_root, [], exclusions.src_exclusions(),
maveninstallinfo.NOOP,
pom_content=pomcontent.NOOP)
with self.assertRaises(Exception) as ctx:
deps = ws.parse_dep_labels(["//%s" % package_name,
"//%s" % bad_package_name])
self.assertIn("no BUILD.pom", str(ctx.exception))
self.assertIn(bad_package_name, str(ctx.exception))
def main(args):
args = _parse_arguments(args)
repo_root = common.get_repo_root(args.repo_root)
cfg = config.load(repo_root, args.verbose)
pom_content = pomcontentm.PomContent()
if args.pom_description is not None:
pom_content.description = args.pom_description
if args.verbose:
logger.debug("Global pom content: %s" % pom_content)
mvn_install_info = maveninstallinfo.MavenInstallInfo(
cfg.maven_install_paths)
ws = workspace.Workspace(repo_root, cfg.excluded_dependency_paths,
cfg.all_src_exclusions, mvn_install_info,
pom_content)
packages = argsupport.get_all_packages(repo_root, args.package)
packages = ws.filter_artifact_producing_packages(packages)
if len(packages) == 0:
raise Exception(
"Did not find any artifact producing BUILD.pom packages at [%s]" %
args.package)
spider = crawler.Crawler(ws, cfg.pom_template, args.verbose)
result = spider.crawl(packages,
follow_monorepo_references=args.recursive,
force_release=args.force)
if len(result.pomgens) == 0:
logger.info(
"No releases are required. pomgen will not generate any pom files. To force pom generation, use pomgen's --force option."
)
else:
output_dir = _get_output_dir(args)
for pomgen in result.pomgens:
pom_dest_dir = os.path.join(output_dir, pomgen.bazel_package)
if not os.path.exists(pom_dest_dir):
os.makedirs(pom_dest_dir)
# the goldfile pom is actually a pomgen metadata file, so we
# write it using the mdfiles module, which ensures it goes
# into the proper location within the specified bazel package
if args.pom_goldfile:
pom_content = pomgen.gen(pom.PomContentType.GOLDFILE)
pom_goldfile_path = mdfiles.write_file(
pom_content, output_dir, pomgen.bazel_package,
mdfiles.POM_XML_RELEASED_FILE_NAME)
logger.info("Wrote pom goldfile to [%s]" % pom_goldfile_path)
else:
pom_content = pomgen.gen(pom.PomContentType.RELEASE)
pom_path = os.path.join(pom_dest_dir, "pom.xml")
_write_file(pom_path, pom_content)
logger.info("Wrote pom file to [%s]" % pom_path)
for i, companion_pomgen in enumerate(
pomgen.get_companion_generators()):
pom_content = companion_pomgen.gen(
pom.PomContentType.RELEASE)
pom_path = os.path.join(pom_dest_dir,
"pom_companion%s.xml" % i)
_write_file(pom_path, pom_content)
logger.info("Wrote companion pom file to [%s]" % pom_path)
def test_parse_src_dep_with_changes_since_last_release(self):
"""
Verifies that a source dependency label is correctly parsed into a
Dependency instance.
The source dependency has a BUILD.pom.released file that indicates
that changes have been made since the last release; therefore
the dependency instance should point to the monorepo source artifact.
"""
version = "1.2.3"
released_version = "1.2.0"
package_name = "package1"
group_id = "group1"
artifact_id = "art1"
repo_root = tempfile.mkdtemp("monorepo")
self._touch_file_at_path(repo_root, "", "MVN-INF", "LIBRARY.root")
self._write_build_pom(repo_root, package_name, artifact_id, group_id, version)
self._setup_repo(repo_root)
package_hash = git.get_dir_hash(repo_root, [package_name], exclusions.src_exclusions())
self._write_build_pom_released(repo_root, package_name, released_version, package_hash)
self._touch_file_at_path(repo_root, package_name, "", "myfile")
self._commit(repo_root)
ws = workspace.Workspace(repo_root, [], exclusions.src_exclusions(),
maveninstallinfo.NOOP,
pom_content=pomcontent.NOOP)
deps = ws.parse_dep_labels(["//%s" % package_name])
self.assertEqual(1, len(deps))
self.assertEqual(group_id, deps[0].group_id)
self.assertEqual(artifact_id, deps[0].artifact_id)
self.assertFalse(deps[0].external)
self.assertEqual(version, deps[0].version)
self.assertEqual(package_name, deps[0].bazel_package)
def test_template_var_sub__ext_deps_with_same_versions(self):
"""
Ensures that external dependencies (jars) that have the same gav, but
are defined multiple times in different maven_install rules, can
be referenced.
"""
ws = workspace.Workspace("some/path", [], exclusions.src_exclusions(),
self._mocked_mvn_install_info("maven"),
pomcontent.NOOP)
artifact_def = buildpom.maven_artifact("groupId", "artifactId",
"1.4.4")
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
artifact_def.custom_pom_template_content = """
1 v1 #{@maven//:org_apache_maven_same_version.version}
2 v2 #{@maven2//:org_apache_maven_same_version.version}
3 v #{org_apache_maven_same_version.version}
4 v #{org.apache.maven:same-version:version}
"""
pomgen = pom.TemplatePomGen(ws, artifact_def, dep)
generated_pom = pomgen.gen(pom.PomContentType.RELEASE)
self.assertIn("1 v1 1.0.0", generated_pom)
self.assertIn("2 v2 1.0.0", generated_pom)
self.assertIn("3 v 1.0.0", generated_pom)
self.assertIn("4 v 1.0.0", generated_pom)
def test_template__deps_config_setion_is_removed(self):
"""
Verifies that the special dependency config section is removed
from the pom template when it is processed.
"""
pom_template = """
<project>
<dependencyManagement>
<dependencies>
__pomgen.start_dependency_customization__
__pomgen.end_dependency_customization__
</dependencies>
</dependencyManagement>
</project>
"""
expected_pom = """
<project>
<dependencyManagement>
<dependencies>
</dependencies>
</dependencyManagement>
</project>
"""
ws = workspace.Workspace("some/path", [], exclusions.src_exclusions(),
maveninstallinfo.NOOP, pomcontent.NOOP)
artifact_def = buildpom.maven_artifact("groupId", "artifactId",
"1.2.3")
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
artifact_def.custom_pom_template_content = pom_template
pomgen = pom.TemplatePomGen(ws, artifact_def, dep)
generated_pom = pomgen.gen(pom.PomContentType.RELEASE)
self.assertEqual(expected_pom, generated_pom)
def test_template_genmode__goldfile(self):
"""
Verifies version omissions when genmode is GOLDFILE.
"""
ws = workspace.Workspace(
"some/path", """
native.maven_jar(
name = "ch_qos_logback_logback_classic",
artifact = "ch.qos.logback:logback-classic:1.4.4",
)""", [], exclusions.src_exclusions())
artifact_def = buildpom.maven_artifact("groupId", "artifactId",
"1.2.3")
srpc_artifact_def = buildpom.maven_artifact("com.grail.srpc",
"srpc-api", "5.6.7")
srpc_artifact_def = buildpom._augment_art_def_values(
srpc_artifact_def, None, "pack1", None, None, pomgenmode.DYNAMIC)
dep = dependency.new_dep_from_maven_artifact_def(srpc_artifact_def)
pomgen = pom.TemplatePomGen(ws,
artifact_def,
dep,
template_content="""
this artifact version #{version}
logback #{ch.qos.logback:logback-classic:version}
srpc #{com.grail.srpc:srpc-api:version}""")
pomgen.register_dependencies_globally(
set([
dependency.MonorepoDependency(srpc_artifact_def,
bazel_target=None)
]), set())
generated_pom = pomgen.gen(pomcontenttype=pom.PomContentType.GOLDFILE)
self.assertIn("this artifact version ***", generated_pom)
self.assertIn("logback 1.4.4", generated_pom)
self.assertIn("srpc ***", generated_pom)
def test_template_var_sub__conflicting_gav__ext_and_BUILDpom(self):
"""
Verifies error handling when gavs are conflicting between external deps
and what is set in BUILD.pom files.
"""
ws = workspace.Workspace("some/path", [], exclusions.src_exclusions(),
self._mocked_mvn_install_info("maven"),
pomcontent.NOOP)
artifact_def = buildpom.maven_artifact("groupId", "artifactId",
"1.2.3")
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
artifact_def.custom_pom_template_content = "srpc #{g:a:version}"
pomgen = pom.TemplatePomGen(ws, artifact_def, dep)
art = buildpom.MavenArtifactDef("com.google.guava",
"guava",
"26.0",
bazel_package="a/b/c")
d = dependency.MonorepoDependency(art, bazel_target=None)
pomgen.register_dependencies_transitive_closure__library(set([d]))
with self.assertRaises(Exception) as ctx:
pomgen.gen(pom.PomContentType.RELEASE)
self.assertIn(
"Found multiple artifacts with the same groupId:artifactId",
str(ctx.exception))
self.assertIn("com.google.guava:guava", str(ctx.exception))
def test_template_var_sub__multiple_ext_deps_with_same_gav(self):
"""
Verifies that pomgen is ok with multiple external deps with the same
gav. This is an edge case, where the WORKSPACE file defines 2 (or more)
differnently named maven_jars, that all point back to the same artifact.
"""
ws = workspace.Workspace(
"some/path", """
native.maven_jar(
name = "name1",
artifact = "g:a:20",
)
native.maven_jar(
name = "name2",
artifact = "g:a:20",
)
""", [], exclusions.src_exclusions())
artifact_def = buildpom.maven_artifact("groupId", "artifactId",
"1.2.3")
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
pomgen = pom.TemplatePomGen(ws,
artifact_def,
dep,
template_content="""
srpc #{g:a:version}""")
pomgen.gen()
def test_template_var_sub__multiple_ext_deps_with_same_ga_diff_vers(self):
"""
Verifies that pomgen is NOT OK with multiple external deps with the same
groupId/artifactId but with a different version (as this would break
the #{<groupId>:<artifactId>:version} syntax).
"""
ws = workspace.Workspace(
"some/path", """
native.maven_jar(
name = "name1",
artifact = "g:a:20",
)
native.maven_jar(
name = "name2",
artifact = "g:a:21",
)
""", [], exclusions.src_exclusions())
artifact_def = buildpom.maven_artifact("groupId", "artifactId",
"1.2.3")
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
pomgen = pom.TemplatePomGen(ws,
artifact_def,
dep,
template_content="""
srpc #{g:a:version}""")
with self.assertRaises(Exception) as ctx:
pomgen.gen()
self.assertIn(
"Found multiple artifacts with the same groupId:artifactId",
str(ctx.exception))
self.assertIn("g:a", str(ctx.exception))
def test_template_var_sub__conflicting_gav__ext_and_BUILDpom(self):
"""
Verifies error handling when gavs are conflicting between external deps
and what is set in BUILD.pom files.
"""
ws = workspace.Workspace(
"some/path", """
native.maven_jar(
name = "name",
artifact = "g:a:20",
)""", [], exclusions.src_exclusions())
artifact_def = buildpom.maven_artifact("groupId", "artifactId",
"1.2.3")
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
pomgen = pom.TemplatePomGen(ws,
artifact_def,
dep,
template_content="""
srpc #{g:a:version}""")
art = buildpom.MavenArtifactDef("g", "a", "1", bazel_package="a/b/c")
d = dependency.MonorepoDependency(art, bazel_target=None)
pomgen.register_dependencies_globally(set([d]), set())
with self.assertRaises(Exception) as ctx:
pomgen.gen()
self.assertIn(
"Found multiple artifacts with the same groupId:artifactId",
str(ctx.exception))
self.assertIn("g:a", str(ctx.exception))
def test_template_var_sub__monorepo_deps(self):
"""
Verifies references to monorepo versions in a pom template.
"""
ws = workspace.Workspace("some/path", "", [],
exclusions.src_exclusions())
artifact_def = buildpom.MavenArtifactDef("groupId", "artifactId",
"1.2.3")
srpc_artifact_def = buildpom.MavenArtifactDef("com.grail.srpc",
"srpc-api", "5.6.7")
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
pomgen = pom.TemplatePomGen(ws,
artifact_def,
dep,
template_content="""
srpc #{com.grail.srpc:srpc-api:version}""")
pomgen.register_dependencies_globally(
set([
dependency.MonorepoDependency(srpc_artifact_def,
bazel_target=None)
]), set())
generated_pom = pomgen.gen()
self.assertIn("srpc 5.6.7", generated_pom)
def test_template_var_sub(self):
"""
Verifies variable substitution in a pom template.
"""
ws = workspace.Workspace(
"some/path", """
native.maven_jar(
name = "ch_qos_logback_logback_classic",
artifact = "ch.qos.logback:logback-classic:1.4.4",
)""", [], exclusions.src_exclusions())
artifact_def = buildpom.maven_artifact("groupId", "artifactId",
"1.2.3")
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
pomgen = pom.TemplatePomGen(ws,
artifact_def,
dep,
template_content="""
logback_old_syntax #{ch_qos_logback_logback_classic.version}
logback_new_syntax #{ch.qos.logback:logback-classic:version}
monorepo artifact version #{version}""")
generated_pom = pomgen.gen()
self.assertIn("logback_old_syntax 1.4.4", generated_pom)
self.assertIn("logback_new_syntax 1.4.4", generated_pom)
self.assertIn("monorepo artifact version 1.2.3", generated_pom)
def test_parse_src_dep_with_target(self):
"""
Verifies that a source dependency label is correctly parsed into a
Dependency instance, when the source dependency includes a target
"""
artifact_version = "1.2.3"
package_name = "package1"
group_id = "group1"
artifact_id = "art1"
repo_root = tempfile.mkdtemp("monorepo")
self._touch_file_at_path(repo_root, "", "MVN-INF", "LIBRARY.root")
self._write_build_pom(repo_root, package_name, artifact_id, group_id, artifact_version)
ws = workspace.Workspace(repo_root, [], exclusions.src_exclusions(),
maveninstallinfo.NOOP,
pom_content=pomcontent.NOOP)
deps = ws.parse_dep_labels(["//%s:my_cool_target" % package_name])
self.assertEqual(1, len(deps))
self.assertEqual(group_id, deps[0].group_id)
self.assertEqual(artifact_id, deps[0].artifact_id)
self.assertEqual(artifact_version, deps[0].version)
self.assertFalse(deps[0].external)
self.assertEqual(package_name, deps[0].bazel_package)
self.assertEqual("my_cool_target", deps[0].bazel_target)
def test_depman_pom__sanity(self):
"""
Ensures that dependency management pom generation isn't totally broken.
"""
ws = workspace.Workspace("some/path", [], exclusions.src_exclusions(),
maveninstallinfo.NOOP, pomcontent.NOOP)
artifact_def = buildpom.MavenArtifactDef(
"g1", "a2", "1.2.3", gen_dependency_management_pom=True)
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
pomgen = pom.DependencyManagementPomGen(ws, artifact_def, dep,
TEST_POM_TEMPLATE)
guava = dependency.new_dep_from_maven_art_str("google:guava:1", "guav")
force = dependency.new_dep_from_maven_art_str("force:commons:1",
"forc")
pomgen.register_dependencies_transitive_closure__artifact((
guava,
force,
))
generated_pom = pomgen.gen(pom.PomContentType.RELEASE)
self.assertIn("<packaging>pom</packaging>", generated_pom)
self.assertIn("<dependencyManagement>", generated_pom)
self.assertIn("<artifactId>guava</artifactId>", generated_pom)
self.assertIn("<artifactId>commons</artifactId>", generated_pom)
def _get_workspace(self):
return workspace.Workspace(
repo_root_path="a/b/c",
excluded_dependency_paths=[],
source_exclusions=[],
maven_install_info=maveninstallinfo.NOOP,
pom_content="",
)
def test_template__unencountered_deps(self):
"""
Verifies that declared deps that are not crawled can be referenced
using the pomgen.unencountered_deps property.
"""
pom_template = """
<project>
<dependencyManagement>
<dependencies>
__pomgen.start_dependency_customization__
<dependency>
<artifactId>art1</artifactId>
<groupId>group1</groupId>
<version>1.0.0</version>
<exclusions>
<exclusion>
<artifactId>ea1</artifactId>
<groupId>eg1</groupId>
</exclusion>
</exclusions>
</dependency>
__pomgen.end_dependency_customization__
#{pomgen.unencountered_dependencies}
</dependencies>
</dependencyManagement>
</project>
"""
expected_pom = """
<project>
<dependencyManagement>
<dependencies>
<dependency>
<artifactId>art1</artifactId>
<groupId>group1</groupId>
<version>1.0.0</version>
<exclusions>
<exclusion>
<artifactId>ea1</artifactId>
<groupId>eg1</groupId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
</dependencyManagement>
</project>
"""
ws = workspace.Workspace("some/path", [], exclusions.src_exclusions(),
maveninstallinfo.NOOP, pomcontent.NOOP)
artifact_def = buildpom.maven_artifact("groupId", "artifactId",
"1.2.3")
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
artifact_def.custom_pom_template_content = pom_template
pomgen = pom.TemplatePomGen(ws, artifact_def, dep)
generated_pom = pomgen.gen(pom.PomContentType.RELEASE)
self.assertEqual(expected_pom, generated_pom)
def test_template__library_transitives(self):
"""
Verifies that transitive dependencies can be referenced using the
property pomgen.transitive_closure_of_library_dependencies.
"""
pom_template = """
<project>
<dependencyManagement>
<dependencies>
#{pomgen.transitive_closure_of_library_dependencies}
</dependencies>
</dependencyManagement>
</project>
"""
expected_pom = """
<project>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>com.grail.srpc</groupId>
<artifactId>srpc-api</artifactId>
<version>5.6.7</version>
</dependency>
<dependency>
<groupId>cg</groupId>
<artifactId>ca</artifactId>
<version>0.0.1</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>
"""
ws = workspace.Workspace("some/path", [], exclusions.src_exclusions(),
maveninstallinfo.NOOP, pomcontent.NOOP)
artifact_def = buildpom.maven_artifact("groupId", "artifactId",
"1.2.3")
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
artifact_def.custom_pom_template_content = pom_template
pomgen = pom.TemplatePomGen(ws, artifact_def, dep)
srpc_artifact_def = buildpom.MavenArtifactDef("com.grail.srpc",
"srpc-api",
"5.6.7",
bazel_package="a/b/c")
internal_dep = dependency.MonorepoDependency(srpc_artifact_def,
bazel_target=None)
external_dep = dependency.ThirdPartyDependency("name", "cg", "ca",
"0.0.1")
pomgen.register_dependencies_transitive_closure__library(
set([external_dep, internal_dep]))
generated_pom = pomgen.gen(pom.PomContentType.RELEASE)
self.assertEqual(expected_pom, generated_pom)
def main(args):
args = _parse_arguments(args)
repo_root = common.get_repo_root(args.repo_root)
cfg = config.load(repo_root)
mvn_install_info = maveninstallinfo.MavenInstallInfo(cfg.maven_install_paths)
ws = workspace.Workspace(repo_root,
cfg.excluded_dependency_paths,
cfg.all_src_exclusions,
mvn_install_info,
pomcontent.NOOP)
group_id = "all_ext_deps_group" if args.group_id is None else args.group_id
artifact_id = "all_ext_deps_art" if args.artifact_id is None else args.artifact_id
version = "0.0.1-SNAPSHOT" if args.version is None else args.version
artifact_def = buildpom.MavenArtifactDef(group_id=group_id,
artifact_id=artifact_id,
version=version)
if args.stdin:
dep_labels = set() # we want to de-dupe labels
dependencies = []
for line in sys.stdin:
line = line.strip()
if len(line) == 0:
continue
if not line.startswith("@"):
continue
if _starts_with_ignored_prefix(line):
continue
dep_labels.add(line)
dependencies = ws.parse_dep_labels(dep_labels)
else:
dependencies = list(ws.name_to_external_dependencies.values())
# note that it is possible to end up with duplicate dependencies
# because different labels may point to the same dependency (gav)
# (for ex: @maven//:org_antlr_ST4 and @antlr//:org_antlr_ST4)
# however those indentical gavs may have distinct exclusions
dependencies.sort()
if args.exclude_all_transitives:
# ignore what was specified in the pinned dependencies files
# and add an "exclude all" dependency for all dependencies that
# will end up in the generated pom
ws.dependency_metadata.clear()
for dep in dependencies:
ws.dependency_metadata.register_exclusions(
dep, [dependency.EXCLUDE_ALL_PLACEHOLDER_DEP])
pomgen = ThirdPartyDepsPomGen(ws, artifact_def, dependencies,
cfg.pom_template)
pomgen.process_dependencies()
return pomgen.gen(pom.PomContentType.RELEASE)
def test_dynamic_pom_genmode__goldfile(self):
"""
Test goldfile mode with dynamic pom gen.
"""
ws = workspace.Workspace(
"some/path", """
native.maven_jar(
name = "aopalliance_aopalliance",
artifact = "aopalliance:aopalliance:1.0",
)
native.maven_jar(
name = "com_google_guava_guava",
artifact = "com.google.guava:guava:20.0",
)""", [], exclusions.src_exclusions())
artifact_def = buildpom.maven_artifact("g1", "a2", "1.2.3")
artifact_def = buildpom._augment_art_def_values(
artifact_def, None, "pack1", None, None, pomgenmode.DYNAMIC)
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
pomgen = pom.DynamicPomGen(ws, artifact_def, dep, TEST_POM_TEMPLATE)
org_function = bazel.query_java_library_deps_attributes
try:
bazel.query_java_library_deps_attributes = lambda r, p: (
"@com_google_guava_guava//jar",
"@aopalliance_aopalliance//jar",
)
_, _, deps = pomgen.process_dependencies()
pomgen.register_dependencies(deps)
generated_pom = pomgen.gen(pom.PomContentType.GOLDFILE)
self.assertIn(
"""<groupId>g1</groupId>
<artifactId>a2</artifactId>
<version>***</version>
<packaging>jar</packaging>""", generated_pom)
self.assertIn(
"""<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>20.0</version>
<exclusions>
<exclusion>
<groupId>*</groupId>
<artifactId>*</artifactId>
</exclusion>
</exclusions>""", generated_pom)
aop_index = generated_pom.index("aopalliance")
guava_index = generated_pom.index("guava")
self.assertTrue(guava_index > aop_index) # deps are sorted
finally:
bazel.query_java_library_deps_attributes = org_function
def test_template__crawled_external_deps__configured_attributes(self):
"""
Verifies that "classifier" and "scope" are correcly set in the generated
pom.
"""
pom_template = """
<project>
<dependencyManagement>
<dependencies>
__pomgen.start_dependency_customization__
<dependency>
<artifactId>ca</artifactId>
<groupId>cg</groupId>
<version>0.0.1</version>
<scope>test</scope>
<classifier>sources</classifier>
</dependency>
__pomgen.end_dependency_customization__
#{pomgen.transitive_closure_of_library_dependencies}
</dependencies>
</dependencyManagement>
</project>
"""
expected_pom = """
<project>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>cg</groupId>
<artifactId>ca</artifactId>
<version>0.0.1</version>
<classifier>sources</classifier>
<scope>test</scope>
</dependency>
</dependencies>
</dependencyManagement>
</project>
"""
ws = workspace.Workspace("some/path", [], exclusions.src_exclusions(),
maveninstallinfo.NOOP, pomcontent.NOOP)
artifact_def = buildpom.maven_artifact("groupId", "artifactId",
"1.2.3")
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
artifact_def.custom_pom_template_content = pom_template
pomgen = pom.TemplatePomGen(ws, artifact_def, dep)
crawled_dep = dependency.ThirdPartyDependency("name", "cg", "ca",
"0.0.1")
pomgen.register_dependencies_transitive_closure__library(
set([crawled_dep]))
generated_pom = pomgen.gen(pom.PomContentType.RELEASE)
self.assertEqual(expected_pom, generated_pom)
def test_parse_invalid_dep(self):
"""
Verifies that parsing of an invalid label behaves as expected.
"""
ws = workspace.Workspace("some/path", "", [],
exclusions.src_exclusions())
with self.assertRaises(Exception) as ctx:
deps = ws.parse_dep_labels(["this is a label"])
self.assertIn("bad label", str(ctx.exception))
self.assertIn("this is a label", str(ctx.exception))
def test_parse_ext_dep__unknown_dep(self):
"""
Verifies the error that is thrown when an unknown dep is encountered.
"""
ws = workspace.Workspace("some/path", [], exclusions.src_exclusions(),
maven_install_info=self._mocked_mvn_install_info("maven"),
pom_content=pomcontent.NOOP)
with self.assertRaises(Exception) as ctx:
deps = ws.parse_dep_labels(["@maven//:bad_qos_logback_logback_classic"])
self.assertIn("json files have been registered", str(ctx.exception))
self.assertIn("maven_install_paths in the pomgen config file", str(ctx.exception))
def test_parse_ext_dep_with_reserved_words(self):
"""
Verifies that an external dependency label is correctly parsed into a
Dependency instance when the strings being parsed contain reserved words
such as "artifact".
"""
ws = workspace.Workspace("some/path", [], exclusions.src_exclusions(),
maven_install_info=self._mocked_mvn_install_info("maven"),
pom_content=pomcontent.NOOP)
deps = ws.parse_dep_labels(["@maven//:org_apache_maven_maven_artifact"])
self.assertEqual(1, len(deps))
self.assertEqual("org.apache.maven", deps[0].group_id)
self.assertEqual("maven-artifact", deps[0].artifact_id)
self.assertEqual("3.3.9", deps[0].version)
def test_parse_ext_dep(self):
"""
Verifies that an external dependency label is correctly parsed into a
Dependency instance.
"""
ws = workspace.Workspace("some/path", [], exclusions.src_exclusions(),
maven_install_info=self._mocked_mvn_install_info("maven"),
pom_content=pomcontent.NOOP)
deps = ws.parse_dep_labels(["@maven//:ch_qos_logback_logback_classic"])
self.assertEqual(1, len(deps))
self.assertEqual("ch.qos.logback", deps[0].group_id)
self.assertEqual("logback-classic", deps[0].artifact_id)
self.assertEqual("1.2.3", deps[0].version)
self.assertTrue(deps[0].external)
self.assertIsNone(deps[0].bazel_package)
def test_template_unknown_variable(self):
"""
Verifies that an unknown variable in a pom template is handled and
results in an error during template processing.
"""
ws = workspace.Workspace("some/path", [], exclusions.src_exclusions(),
maveninstallinfo.NOOP, pomcontent.NOOP)
artifact_def = buildpom.maven_artifact("groupId", "artifactId",
"1.2.3")
dep = dependency.new_dep_from_maven_artifact_def(artifact_def)
artifact_def.custom_pom_template_content = "my pom template with a bad ref #{bad1} and also #{bad2}"
pomgen = pom.TemplatePomGen(ws, artifact_def, dep)
with self.assertRaises(Exception) as ctx:
generated_pom = pomgen.gen(pom.PomContentType.RELEASE)
self.assertIn("bad1", str(ctx.exception))
self.assertIn("bad2", str(ctx.exception))
def test_excluded_dependency_paths(self):
"""
Verifies that excluded dependency paths are not added to the list of
dependencies.
"""
ws = workspace.Workspace("some/path",
excluded_dependency_paths=["projects/protos/",],
source_exclusions=exclusions.src_exclusions(),
maven_install_info=self._mocked_mvn_install_info("maven"),
pom_content=pomcontent.NOOP)
deps = ws.parse_dep_labels(["@maven//:ch_qos_logback_logback_classic", "//projects/protos/grail:java_protos"])
self.assertEqual(1, len(deps))
self.assertEqual("ch.qos.logback", deps[0].group_id)
self.assertEqual("logback-classic", deps[0].artifact_id)
self.assertEqual("1.2.3", deps[0].version)
self.assertIsNone(deps[0].bazel_package)
def test_non_default_package_ref__allowed_for_skip_pom_gen_mode(self):
"""
lib/a2 is allowed to ref lib/a1:foo because lib/a1 has
pom_gen_mode = "skip"
https://github.com/salesforce/pomgen/tree/master/examples/skip-artifact-generation
"""
repo_root_path = tempfile.mkdtemp("monorepo")
self._write_library_root(repo_root_path, "lib")
self._add_artifact(repo_root_path, "lib/a1", "skip", deps=[])
self._add_artifact(repo_root_path,
"lib/a2",
"template",
deps=["//lib/a1:foo"])
ws = workspace.Workspace(repo_root_path, "", [],
exclusions.src_exclusions())
crawler = crawlerm.Crawler(ws, pom_template="")
crawler.crawl(["lib/a2"])
def test_parse_ext_dep_with_reserved_words(self):
"""
Verifies that an external dependency label is correctly parsed into a
Dependency instance when the strings being parsed contain reserved words
such as "artifact".
"""
ws = workspace.Workspace(
"some/path", """
native.maven_jar(
name = "org_apache_maven_maven_artifact",
artifact = "org.apache.maven:maven-artifact:3.3.9",
)""", [], exclusions.src_exclusions())
deps = ws.parse_dep_labels(["@org_apache_maven_maven_artifact//jar"])
self.assertEqual(1, len(deps))
self.assertEqual("org.apache.maven", deps[0].group_id)
self.assertEqual("maven-artifact", deps[0].artifact_id)
self.assertEqual("3.3.9", deps[0].version)
