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)