diff --git a/README.md b/README.md index 396a603..8069086 100644 --- a/README.md +++ b/README.md @@ -75,9 +75,10 @@ load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository") git_repository( name = "pomgen", remote = "https://github.com/salesforce/pomgen.git", - commit = "" + commit = "" ) ``` +The `master` branch is always releasable - use the current `HEAD` commit. You can then run pomgen commands [as documented](examples/hello-world/README.md#before-running-pomgen), for example: @@ -193,4 +194,4 @@ pomgen uses [ruff](https://github.com/astral-sh/ruff). Follow the installation i ruff check src tests ``` -Currently, we just use the default ruff linting configuration. \ No newline at end of file +Currently, we just use the default ruff linting configuration. diff --git a/examples/dependency-management/README.md b/examples/dependency-management/README.md index b49f984..eef5399 100644 --- a/examples/dependency-management/README.md +++ b/examples/dependency-management/README.md @@ -1,6 +1,6 @@ # Dependency Management POM Example -This examples shows how pomgen can optionally generate a dependencyManagement "companion" pom. This pom file is generate in addition to the regular pom.xml, when the attribute `generate_dependency_management_pom` is to to `True` in the [BUILD.pom file](juicer/MVN-INF/BUILD.pom). +This examples shows how pomgen can optionally generate a dependencyManagement "companion" pom. This pom file is generated in addition to the regular pom.xml, when the attribute `generate_dependency_management_pom` is to to `True` in the [BUILD.pom file](juicer/MVN-INF/BUILD.pom). The dependency management pom contains a `` section with the transitive closure of all dependencies of the artifact it was generated for. It uses the `artifact_id` specified in the BUILD.pom file, suffixed with `.depmanagement`. diff --git a/misc/extdeps_pomgen.py b/misc/extdeps_pomgen.py index 05dd6ec..71394a0 100755 --- a/misc/extdeps_pomgen.py +++ b/misc/extdeps_pomgen.py @@ -50,15 +50,13 @@ def _parse_arguments(args): class ThirdPartyDepsPomGen(pom.DynamicPomGen): + def __init__(self, workspace, artifact_def, dependencies, pom_template): super(ThirdPartyDepsPomGen, self).__init__(workspace, artifact_def, dependency=None, pom_template=pom_template) self.dependencies = dependencies - def _load_additional_dependencies_hook(self): - return self.dependencies - def _starts_with_ignored_prefix(line): for prefix in IGNORED_DEPENDENCY_PREFIXES: @@ -71,11 +69,12 @@ def main(args): repo_root = common.get_repo_root(args.repo_root) cfg = config.load(repo_root) - # For the primary function of pomgen (generating pom.xml files for publishing) - # there are sometimes maven_install namespaces that are ignored in .pomgenrc. - # These are identified as maven_install paths that begin with - . - # For extdeps, we need to have full access to all maven_install namespaces, so - # we tell maveninstallinfo to not honor the excludes. + # For the primary function of pomgen, generating pom.xml files for + # publishing to Nexus or similar, there are sometimes maven_install + # namespaces that are ignored in .pomgenrc + # These are identified as maven_install paths that begin with - + # For extdeps, we need to have full access to all maven_install namespaces, + # so we tell maveninstallinfo to not honor those excludes allow_excludes = False mvn_install_info = maveninstallinfo.MavenInstallInfo(cfg.maven_install_paths, allow_excludes) @@ -141,7 +140,7 @@ def main(args): pomgen = ThirdPartyDepsPomGen(ws, artifact_def, dependencies, cfg.pom_template) - pomgen.process_dependencies() + return pomgen.gen(pom.PomContentType.RELEASE) diff --git a/src/crawl/artifactprocessor.py b/src/crawl/artifactprocessor.py index d1028f2..0b84266 100644 --- a/src/crawl/artifactprocessor.py +++ b/src/crawl/artifactprocessor.py @@ -22,8 +22,14 @@ def augment_artifact_def(repo_root_path, art_def, source_exclusions, change_detection_enabled): + + # library path art_def.library_path = _get_library_path(repo_root_path, art_def) + # build file exists? + art_def._has_build_file = _has_build_file(repo_root_path, art_def) + + # release state if art_def.released_version is None or art_def.released_artifact_hash is None: # never released? art_def.requires_release = True @@ -49,6 +55,15 @@ def augment_artifact_def(repo_root_path, return art_def +def _has_build_file(repo_root_path, art_def): + path = os.path.join(repo_root_path, art_def.bazel_package) + if os.path.exists(os.path.join(path, "BUILD")): + return True + if os.path.exists(os.path.join(path, "BUILD.bazel")): + return True + return False + + def _get_library_path(repo_root_path, art_def): """ Starts at the path the specified artifact lives at and "walks up" to find diff --git a/src/crawl/buildpom.py b/src/crawl/buildpom.py index 6422bf3..62233ae 100644 --- a/src/crawl/buildpom.py +++ b/src/crawl/buildpom.py @@ -17,7 +17,7 @@ class MavenArtifactDef(object): """ - Represents an instance of a maven_artifact rule defined in BUILD.pom file. + Represents an instance of a maven_artifact rule defined in a BUILD.pom file. Information from the BUILD.pom.released file is added, if that file exists. @@ -67,34 +67,39 @@ class MavenArtifactDef(object): ==== Read out of the optional BUILD.pom.released file ==== - released_version: the previously released version to Nexus + released_version: the previously released version to Nexus. released_artifact_hash: the hash of the artifact at the time it was - previously released to Nexus + previously released to Nexus. - - ===== Internal attributes (never specified by the user) ==== + ===== Internal attributes (never specified by the user in config/md files) deps: additional targets this package depends on; list of Bazel labels. - For example: deps = ["//projects/libs/servicelibs/srpc/srpc-thrift-svc-runtime"] + For example: deps = ["//projects/libs/srpc/srpc-thrift-svc-runtime"] + The deps attribute is typically only used by tests, that's why it is + listed here under "internal attributes", although it is specified in the + BUILD.pom file. - The deps attribute is only used by tests. + bazel_package: the bazel package (relative path to the directory) where the + MVN-INF directory and the build file live. The build file is not + guaranteed to exist (see attr below) because pomgen supports "pom only" + artifacts, which are foreign to bazel. - bazel_package: the bazel package the BUILD (and MVN-INF/) files live in + has_build_file: whether the bazel package actually has a build file. - bazel_target: the bazel target that builds this artifact + bazel_target: the bazel target that builds this artifact. library_path: the path to the root directory of the library this artifact - is part of + is part of. requires_release: whether this artifact should be released (to Nexus - or local Maven repository) + or local Maven repository). - release_reason: the reason for releasing this artifact + release_reason: the reason for releasing this artifact. released_pom_content: if the file pom.xml.released exists next to the - BUILD.pom file, the content of the pom.xml.released file + BUILD.pom file, the content of the pom.xml.released file. ===== @@ -144,6 +149,7 @@ def __init__(self, self._requires_release = requires_release self._release_reason = None self._released_pom_content = released_pom_content + self._has_build_file = False # data cleanup/verification/sanitization # these are separate methods for better readability @@ -213,6 +219,10 @@ def released_artifact_hash(self, value): def bazel_package(self): return self._bazel_package + @property + def has_build_file(self): + return self._has_build_file + @property def bazel_target(self): return self._bazel_target diff --git a/src/crawl/crawler.py b/src/crawl/crawler.py index aa2ccc4..76631b6 100644 --- a/src/crawl/crawler.py +++ b/src/crawl/crawler.py @@ -534,9 +534,15 @@ def _crawl(self, package, dep, parent_node, follow_references): self.package_to_artifact[package] = artifact_def self.library_to_artifact[artifact_def.library_path].append(artifact_def) - pomgen = self._get_pom_generator(artifact_def, dep) + if dep is None: + # make a real dependency instance here + # this is a bootstrapping problem: the root + # artifacts (that we start with) have nothing pointing at them + dep = dependency.new_dep_from_maven_artifact_def(artifact_def) + pomgen = pom.get_pom_generator(self.workspace, self.pom_template, + artifact_def, dep) self.pomgens.append(pomgen) - source_deps, ext_deps, all_deps = pomgen.process_dependencies() + source_deps, ext_deps, all_deps = self._discover_dependencies(artifact_def, dep) self.target_to_dependencies[target_key] = all_deps if self.verbose: logger.debug("Determined deps for artifact: [%s] with target key [%s]" % (artifact_def, target_key)) @@ -556,14 +562,58 @@ def _crawl(self, package, dep, parent_node, follow_references): self._store_if_leafnode(node) return node - def _get_pom_generator(self, artifact_def, dep): - if dep is None: - # make a real dependency instance here so we can pass it along - # into the pom generator - dep = dependency.new_dep_from_maven_artifact_def(artifact_def) - return pom.get_pom_generator(self.workspace, - self.pom_template, artifact_def, - dep) + def _discover_dependencies(self, artifact_def, dep): + """ + Discovers the dependencies of the given artifact (bazel target). + + This method returns a tuple of 3 (!) lists of Dependency instances: + (l1, l2, l3) + l1: all source dependencies (== references to other bazel packages) + l2: all external dependencies (maven jars) + l3: l1 and l2 together, in "discovery order" + """ + assert artifact_def is not None + assert dep is not None, "dep is None for artifact %s" % artifact_def + all_deps = () + if artifact_def.deps is not None: + all_deps = self.workspace.parse_dep_labels(artifact_def.deps) + if artifact_def.has_build_file: + all_deps += self._query_dependencies(artifact_def, dep) + + source_dependencies = [] + ext_dependencies = [] + for dep in all_deps: + if dep.bazel_package is None: + ext_dependencies.append(dep) + else: + source_dependencies.append(dep) + + return (tuple(source_dependencies), + tuple(ext_dependencies), + tuple(all_deps)) + + # this method delegates to bazel query to get the value of a bazel target's + # "deps" and "runtime_deps" attributes + def _query_dependencies(self, artifact_def, dependency): + if not artifact_def.include_deps: + return () + else: + assert artifact_def.bazel_package is not None + assert dependency.bazel_target is not None + assert len(dependency.bazel_target) > 0 + label = "%s:%s" % (artifact_def.bazel_package, dependency.bazel_target) + try: + # the rule attributes to query for dependencies, typically + # "deps" and "runtime_deps" + attrs = artifact_def.pom_generation_mode.dependency_attributes + dep_labels = bazel.query_java_library_deps_attributes( + self.workspace.repo_root_path, label, attrs, + self.workspace.verbose) + deps = self.workspace.parse_dep_labels(dep_labels) + return self.workspace.normalize_deps(artifact_def, deps) + except Exception as e: + msg = e.message if hasattr(e, "message") else type(e) + raise Exception("Error while processing dependencies: %s %s caused by %s\nOne possible cause for this error is that the java_libary rule that builds the jar artifact is not the default bazel package target (same name as dir it lives in)" % (msg, artifact_def, repr(e))) @classmethod def _get_target_key(clazz, package, dep, artifact_def=None): diff --git a/src/crawl/pom.py b/src/crawl/pom.py index af56cb5..716a42b 100644 --- a/src/crawl/pom.py +++ b/src/crawl/pom.py @@ -9,7 +9,6 @@ from common import pomgenmode import copy -from crawl import bazel from crawl import pomparser import os import re @@ -90,38 +89,6 @@ def bazel_package(self): def dependency(self): return self._dependency - def process_dependencies(self): - """ - Discovers the dependencies of this artifact (bazel target). - - This method *must* be called before requesting this instance to generate - a pom. - - This method returns a tuple of 3 (!) lists of Dependency instances: - (l1, l2, l3) - l1: all source dependencies (== references to other bazel packages) - l2: all external dependencies (maven jars) - l3: l1 and l2 together, in "discovery order" - - This method is not meant to be overwritten by subclasses. - """ - all_deps = () - if self._artifact_def.deps is not None: - all_deps = self._workspace.parse_dep_labels(self._artifact_def.deps) - all_deps += self._load_additional_dependencies_hook() - - source_dependencies = [] - ext_dependencies = [] - for dep in all_deps: - if dep.bazel_package is None: - ext_dependencies.append(dep) - else: - source_dependencies.append(dep) - - return (tuple(source_dependencies), - tuple(ext_dependencies), - tuple(all_deps)) - def register_dependencies(self, dependencies): """ Registers the dependencies the backing artifact references explicitly. @@ -162,15 +129,6 @@ def get_companion_generators(self): """ return () - def _load_additional_dependencies_hook(self): - """ - Returns a list of dependency instances referenced by the current - package. - - Only meant to be overridden by subclasses. - """ - return () - def _artifact_def_version(self, pomcontenttype): """ Returns the associated artifact's version, based on the specified @@ -279,10 +237,6 @@ class NoopPomGen(AbstractPomGen): def __init__(self, workspace, artifact_def, dependency): super(NoopPomGen, self).__init__(workspace, artifact_def, dependency) - def _load_additional_dependencies_hook(self): - return _query_dependencies(self._workspace, self._artifact_def, - self._dependency) - class TemplatePomGen(AbstractPomGen): @@ -543,10 +497,6 @@ def gen(self, pomcontenttype): "#{dependencies}", self._gen_dependencies(pomcontenttype)) return content - def _load_additional_dependencies_hook(self): - return _query_dependencies(self._workspace, self._artifact_def, - self._dependency) - def _gen_dependencies(self, pomcontenttype): content = "" content, indent = self._xml(content, "dependencies", indent=_INDENT) @@ -687,9 +637,6 @@ def gen(self, pomcontenttype): def get_companion_generators(self): return (self.depmanpomgen,) - def _load_additional_dependencies_hook(self): - return self.pomgen._load_additional_dependencies_hook() - _INDENT = pomparser.INDENT @@ -702,34 +649,3 @@ def _sort(s): the_list = list(s) the_list.sort() return the_list - - -# this method delegates to bazel query to get the value of a bazel target's -# "deps" and "runtime_deps" attributes. it really doesn't belong in this module, -# because it has nothing to do with generating a pom.xml file. -# it could move into common.pomgenmode or live closer to the crawler -def _query_dependencies(workspace, artifact_def, dependency): - if not artifact_def.include_deps: - return () - else: - try: - label = _build_bazel_label(artifact_def.bazel_package, - dependency.bazel_target) - - # the rule attributes to query for dependencies - dep_attrs=artifact_def.pom_generation_mode.dependency_attributes - dep_labels = bazel.query_java_library_deps_attributes( - workspace.repo_root_path, label, dep_attrs, - workspace.verbose) - deps = workspace.parse_dep_labels(dep_labels) - return workspace.normalize_deps(artifact_def, deps) - except Exception as e: - msg = e.message if hasattr(e, "message") else type(e) - raise Exception("Error while processing dependencies: %s %s caused by %s\nOne possible cause for this error is that the java_libary rule that builds the jar artifact is not the default bazel package target (same name as dir it lives in)" % (msg, artifact_def, repr(e))) - - -def _build_bazel_label(package, target): - assert package is not None, "package should not be None" - assert target is not None, "target should not be None" - assert len(target) > 0, "target should not be an empty string for package [%s]" % package - return "%s:%s" % (package, target) diff --git a/tests/crawlertest_misc.py b/tests/crawlertest_misc.py index 1d268ba..a27f1b9 100644 --- a/tests/crawlertest_misc.py +++ b/tests/crawlertest_misc.py @@ -10,7 +10,6 @@ from config import config from crawl import crawler as crawlerm from crawl import dependencymd as dependencym -from crawl import pom from crawl import pomcontent from crawl import workspace @@ -27,13 +26,6 @@ class CrawlerTest(unittest.TestCase): Various one-off crawler related test cases that require file-system setup. """ - def setUp(self): - self.org_query_method = pom._query_dependencies - pom._query_dependencies = lambda ws, art_def, dep: () - - def tearDown(self): - pom._query_dependencies = self.org_query_method - def test_default_package_ref(self): """ lib/a2 can reference lib/a1. diff --git a/tests/pomtest.py b/tests/pomtest.py index a0a54e5..a6168ea 100644 --- a/tests/pomtest.py +++ b/tests/pomtest.py @@ -34,14 +34,17 @@ class PomTest(unittest.TestCase): def setUp(self): f = dependency.new_dep_from_maven_art_str - t1_dep = f("gt1:t1:1.0.0", "maven") - t2_dep = f("gt2:t2:1.0.0", "maven") + self.t1_dep = f("gt1:t1:1.0.0", "maven") + self.t2_dep = f("gt2:t2:1.0.0", "maven") + self.guava_dep = f("com.google.guava:guava:23.0", "maven") + self.logback_dep = f("ch.qos.logback:logback-classic:1.2.3", "maven") + self.aop_dep = f("aopalliance:aopalliance:jar:1.0.0", "maven") self.orig_bazel_parse_maven_install = bazel.parse_maven_install query_result = [ - (f("com.google.guava:guava:23.0", "maven"), [t1_dep, t2_dep]), - (f("ch.qos.logback:logback-classic:1.2.3", "maven"), []), - (f("aopalliance:aopalliance:jar:1.0.0", "maven"), []), - (t2_dep, []), + (self.guava_dep, [self.t1_dep, self.t2_dep]), + (self.logback_dep, []), + (self.aop_dep, []), + (self.t2_dep, []), # same version, different maven_install rules (f("org.apache.maven:same-version:1.0.0", "maven"), []), (f("org.apache.maven:same-version:1.0.0", "maven2"), []), @@ -70,27 +73,27 @@ def test_dynamic_pom__sanity(self): 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, a, v: ("@maven//:com_google_guava_guava", "@maven//:aopalliance_aopalliance", "@maven//:ch_qos_logback_logback_classic", "@maven//:gt2_t2" ) - _, _, deps = pomgen.process_dependencies() - deps = list(deps) - # appending a dependency that is built from soure - # (should not have an exclusions block) - artifact_def = buildpom.MavenArtifactDef( - "repo", "my-dep", "1.2.3", bazel_target="t1") - dep = dependency.new_dep_from_maven_artifact_def(artifact_def) - deps.append(dep) - deps = tuple(deps) - pomgen.register_dependencies(deps) - generated_pom = pomgen.gen(pom.PomContentType.RELEASE) - - self.assertIn("""g1 + deps = [self.guava_dep, + self.logback_dep, + self.aop_dep, + self.t2_dep, + ] + # appending a dependency that is built from soure + # (should not have an exclusions block) + artifact_def = buildpom.MavenArtifactDef( + "repo", "my-dep", "1.2.3", bazel_target="t1") + dep = dependency.new_dep_from_maven_artifact_def(artifact_def) + deps.append(dep) + deps = tuple(deps) + pomgen.register_dependencies(deps) + generated_pom = pomgen.gen(pom.PomContentType.RELEASE) + + self.assertIn("""g1 a2 1.2.3 jar""", generated_pom) - self.assertIn("""com.google.guava + self.assertIn("""com.google.guava guava 23.0 @@ -100,7 +103,7 @@ def test_dynamic_pom__sanity(self): """, generated_pom) - self.assertIn("""aopalliance + self.assertIn("""aopalliance aopalliance 1.0.0 @@ -110,7 +113,7 @@ def test_dynamic_pom__sanity(self): """, generated_pom) - self.assertIn(""" + self.assertIn(""" ch.qos.logback logback-classic 1.2.3 @@ -122,8 +125,8 @@ def test_dynamic_pom__sanity(self): """, generated_pom) - # transitive of guava, but also top-level - self.assertIn(""" + # transitive of guava, but also top-level + self.assertIn(""" gt2 t2 1.0.0 @@ -135,16 +138,16 @@ def test_dynamic_pom__sanity(self): """, generated_pom) - # this dependency shouldn't have the exclusions block due to it - # having "bazel_buildable=True" - self.assertIn(""" + # this dependency shouldn't have the exclusions block due to it + # having "bazel_buildable=True" + self.assertIn(""" repo my-dep 1.2.3 """, generated_pom) - # transitive of guava - self.assertIn(""" + # transitive of guava + self.assertIn(""" gt1 t1 1.0.0 @@ -156,25 +159,24 @@ def test_dynamic_pom__sanity(self): """, generated_pom) - # deps are BUILD file order - aop_index = generated_pom.index("aopalliance") - guava_index = generated_pom.index("guava") - self.assertTrue(guava_index < aop_index) - - transitives_start_index = generated_pom.index("") - # gt1:t1 is a transitive of guava and not top level, it should be - # in the transitives section - t1_index = generated_pom.index("t1") - self.assertTrue(t1_index > transitives_start_index) - self.assertEqual(1, generated_pom.count("t1")) - - # gt2:t2 is a transitive of guava but because it is also top-level - # it does not appear in the transitives section - t2_index = generated_pom.index("t2") - self.assertTrue(t2_index < transitives_start_index) - self.assertEqual(1, generated_pom.count("t2")) - finally: - bazel.query_java_library_deps_attributes = org_function + # deps are BUILD file order + aop_index = generated_pom.index("aopalliance") + guava_index = generated_pom.index("guava") + self.assertTrue(guava_index < aop_index) + + transitives_start_index = generated_pom.index("") + # gt1:t1 is a transitive of guava and not top level, it should be + # in the transitives section + t1_index = generated_pom.index("t1") + self.assertTrue(t1_index > transitives_start_index) + self.assertEqual(1, generated_pom.count("t1")) + + # gt2:t2 is a transitive of guava but because it is also top-level + # it does not appear in the transitives section + t2_index = generated_pom.index("t2") + self.assertNotEqual(-1, t2_index) + self.assertTrue(t2_index < transitives_start_index) + self.assertEqual(1, generated_pom.count("t2")) def test_dynamic_pom__gen_description(self): """ @@ -241,9 +243,8 @@ def test_dyamic_pom__no_explicit_transitives(self): """ # we need to overwrite what the default setUp method did to remove all # transitives - f = dependency.new_dep_from_maven_art_str query_result = [ - (f("com.google.guava:guava:23.0", "maven"), []), + (self.guava_dep, []), ] bazel.parse_maven_install = lambda names, overrides, verbose: query_result artifact_def = buildpom.MavenArtifactDef("g1", "a2", "1.2.3", bazel_target="t2") @@ -257,23 +258,16 @@ def test_dyamic_pom__no_explicit_transitives(self): depmd, label_to_overridden_fq_label={}) 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, a, v: ("@maven//:com_google_guava_guava", ) - _, _, deps = pomgen.process_dependencies() - pomgen.register_dependencies(deps) + pomgen.register_dependencies([self.guava_dep]) - generated_pom = pomgen.gen(pom.PomContentType.RELEASE) + generated_pom = pomgen.gen(pom.PomContentType.RELEASE) - self.assertIn(""" + self.assertIn(""" com.google.guava guava 23.0""", generated_pom) # check that the special "explicit transitives" comment isn't there - self.assertNotIn("", generated_pom) - - finally: - bazel.query_java_library_deps_attributes = org_function + self.assertNotIn("", generated_pom) def test_dynamic_pom__classifier(self): """ @@ -321,15 +315,9 @@ def test_dynamic_pom__do_not_include_deps(self): dep = dependency.new_dep_from_maven_artifact_def(artifact_def) pomgen = pom.DynamicPomGen(ws, artifact_def, dep, "") - org_function = bazel.query_java_library_deps_attributes - try: - bazel.query_java_library_deps_attributes = lambda r, p, a, v: 1/0 # fails - pomgen.process_dependencies() - generated_pom = pomgen.gen(pom.PomContentType.RELEASE) + generated_pom = pomgen.gen(pom.PomContentType.RELEASE) - self.assertNotIn("dependencies", generated_pom) - finally: - bazel.query_java_library_deps_attributes = org_function + self.assertNotIn("dependencies", generated_pom) def test_dynamic_pom_genmode__goldfile(self): """ @@ -345,23 +333,18 @@ def test_dynamic_pom_genmode__goldfile(self): artifact_def = buildpom.MavenArtifactDef("g1", "a2", "1.2.3", bazel_target="t1") 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) + deps = [self.guava_dep, self.aop_dep] + pomgen.register_dependencies(deps) - org_function = bazel.query_java_library_deps_attributes - try: - bazel.query_java_library_deps_attributes = lambda r, p, a, v: ("@maven//:com_google_guava_guava", "@maven//:aopalliance_aopalliance", ) - _, _, deps = pomgen.process_dependencies() - pomgen.register_dependencies(deps) - - generated_pom = pomgen.gen(pom.PomContentType.GOLDFILE) + generated_pom = pomgen.gen(pom.PomContentType.GOLDFILE) - self.assertIn("""g1 + self.assertIn("""g1 a2 *** jar""", generated_pom) - self.assertIn("""com.google.guava + self.assertIn("""com.google.guava guava 23.0 @@ -371,15 +354,13 @@ def test_dynamic_pom_genmode__goldfile(self): """, 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 + aop_index = generated_pom.index("aopalliance") + guava_index = generated_pom.index("guava") + self.assertTrue(guava_index > aop_index) # deps are sorted def test_template_var_sub(self): """ - Verifies variable substitution in a pom template. + Verifies references of 3rd party dependency versions in a pom template. """ depmd = dependencym.DependencyMetadata(None) ws = workspace.Workspace("some/path", @@ -406,7 +387,7 @@ def test_template_var_sub(self): def test_template_var_sub__monorepo_deps(self): """ - Verifies references to monorepo versions in a pom template. + Verifies references of source dependency versions in a pom template. """ depmd = dependencym.DependencyMetadata(None) ws = workspace.Workspace("some/path",