def test_get_reusable_component_different_arches(self, set_database_arch, set_current_arch): second_module_build = models.ModuleBuild.get_by_id(db_session, 3) if set_current_arch: # set architecture for current build mmd = second_module_build.mmd() component = mmd.get_rpm_component("tangerine") component.reset_arches() component.add_restricted_arch("i686") second_module_build.modulemd = mmd_to_str(mmd) db_session.commit() if set_database_arch: # set architecture for build in database second_module_changed_component = models.ComponentBuild.from_component_name( db_session, "tangerine", 2) mmd = second_module_changed_component.module_build.mmd() component = mmd.get_rpm_component("tangerine") component.reset_arches() component.add_restricted_arch("i686") second_module_changed_component.module_build.modulemd = mmd_to_str( mmd) db_session.commit() tangerine = get_reusable_component(second_module_build, "tangerine") assert bool(tangerine is None) != bool( set_current_arch == set_database_arch)
def _add_test_rpm( self, nevra, srpm_nevra, multilib=None, koji_srpm_nevra=None, excludearch=None, exclusivearch=None, license=None, ): """ Helper method to add test RPM to ModuleBuild used by KojiContentGenerator and also to Koji tag used to generate the Content Generator build. :param str nevra: NEVRA of the RPM to add. :param str srpm_nevra: NEVRA of SRPM the added RPM is built from. :param list multilib: List of architecture for which the multilib should be turned on. :param str koji_srpm_nevra: If set, overrides the `srpm_nevra` in Koji tag. This is needed to test the case when the built "src" package has different name than the package in Koji. This is for example case of software collections where the name in `srpm_nevra` is "httpd" but `koji_srpm_nevra` name would be "httpd24-httpd". :param list excludearch: List of architectures this package is excluded from. :param list exclusivearch: List of architectures this package is exclusive for. :param str license: License of this RPM. """ srpm_name = kobo.rpmlib.parse_nvra(srpm_nevra)["name"] parsed_nevra = kobo.rpmlib.parse_nvra(nevra) parsed_nevra["payloadhash"] = "hash" if koji_srpm_nevra: parsed_nevra["srpm_nevra"] = koji_srpm_nevra parsed_nevra["srpm_name"] = kobo.rpmlib.parse_nvra( koji_srpm_nevra)["name"] else: parsed_nevra["srpm_nevra"] = srpm_nevra parsed_nevra["srpm_name"] = srpm_name parsed_nevra["excludearch"] = excludearch or [] parsed_nevra["exclusivearch"] = exclusivearch or [] parsed_nevra["license"] = license or "" self.cg.rpms.append(parsed_nevra) self.cg.rpms_dict[nevra] = parsed_nevra mmd = self.cg.module.mmd() if srpm_name not in mmd.get_rpm_component_names(): component = Modulemd.ComponentRpm.new(srpm_name) component.set_rationale("foo") if multilib: for arch in multilib: component.add_multilib_arch(arch) mmd.add_component(component) self.cg.module.modulemd = mmd_to_str(mmd) self.cg.modulemd = mmd_to_str(mmd)
def test_import_builds_from_local_dnf_repos(self, patched_open): with mock.patch("dnf.Base") as dnf_base: repo = mock.MagicMock() repo.repofile = "/etc/yum.repos.d/foo.repo" mmd = load_mmd(read_staged_data("formatted_testmodule")) repo.get_metadata_content.return_value = mmd_to_str(mmd) base = dnf_base.return_value base.repos = {"reponame": repo} patched_open.return_value.readlines.return_value = ( "FOO=bar", "PLATFORM_ID=platform:x") import_builds_from_local_dnf_repos() base.read_all_repos.assert_called_once() repo.load.assert_called_once() repo.get_metadata_content.assert_called_once_with("modules") module_build = models.ModuleBuild.get_build_from_nsvc( db_session, "testmodule", "master", 20180205135154, "9c690d0e") assert module_build assert module_build.koji_tag == "repofile:///etc/yum.repos.d/foo.repo" module_build = models.ModuleBuild.get_build_from_nsvc( db_session, "platform", "x", 1, "000000") assert module_build
def test_get_rpm_release_metadata_br_stream_override(mock_admmn): """ Test that when a module buildrequires a module in conf.allowed_privileged_module_names, and that module has the xmd.mbs.disttag_marking field set, it should influence the disttag. """ scheduler_init_data(1) metadata_mmd = load_mmd(read_staged_data("build_metadata_module")) import_mmd(db_session, metadata_mmd) build_one = models.ModuleBuild.get_by_id(db_session, 2) mmd = build_one.mmd() deps = mmd.get_dependencies()[0] deps.add_buildtime_stream("build", "product1.2") xmd = mmd.get_xmd() xmd["mbs"]["buildrequires"]["build"] = { "filtered_rpms": [], "ref": "virtual", "stream": "product1.2", "version": "1", "context": "00000000", } mmd.set_xmd(xmd) build_one.modulemd = mmd_to_str(mmd) db_session.add(build_one) db_session.commit() release = utils.get_rpm_release(db_session, build_one) assert release == "module+product12+2+814cfa39"
def test_add_default_modules_request_failed(mock_get_dm): """ Test that an exception is raised when the call to _get_default_modules failed. """ clean_database() make_module_in_db("python:3:12345:1") make_module_in_db("nodejs:11:2345:2") mmd = load_mmd(read_staged_data("formatted_testmodule.yaml")) xmd_brs = mmd.get_xmd()["mbs"]["buildrequires"] assert set(xmd_brs.keys()) == {"platform"} platform = ModuleBuild.get_build_from_nsvc( db_session, "platform", xmd_brs["platform"]["stream"], xmd_brs["platform"]["version"], xmd_brs["platform"]["context"], ) assert platform platform_mmd = platform.mmd() platform_xmd = mmd.get_xmd() platform_xmd["mbs"]["use_default_modules"] = True platform_mmd.set_xmd(platform_xmd) platform.modulemd = mmd_to_str(platform_mmd) db_session.commit() expected_error = "some error" mock_get_dm.side_effect = ValueError(expected_error) with pytest.raises(ValueError, match=expected_error): default_modules.add_default_modules(mmd)
def _finalize_mmd(self, arch): """ Finalizes the modulemd: - Fills in the list of built RPMs respecting filters, whitelist and multilib. :param str arch: Name of arch to generate the final modulemd for. :rtype: str :return: Finalized modulemd string. """ mmd = self._sanitize_mmd(self.module.mmd()) if self.devel: # Set the new name mmd = mmd.copy(mmd.get_module_name() + "-devel") # Depend on the actual module for dep in mmd.get_dependencies(): dep.add_runtime_stream(mmd.get_module_name(), mmd.get_stream_name()) # Delete API and profiles for rpm in mmd.get_rpm_api(): mmd.remove_rpm_api(rpm) mmd.clear_profiles() # Set the "Arch" field in mmd. mmd.set_arch(pungi.arch.tree_arch_to_yum_arch(arch)) # Fill in the list of built RPMs. mmd = self._fill_in_rpms_list(mmd, arch) return mmd_to_str(mmd)
def test_get_reusable_component_different_buildrequires_stream( self, rebuild_strategy): first_module_build = models.ModuleBuild.get_by_id(db_session, 2) first_module_build.rebuild_strategy = rebuild_strategy db_session.commit() second_module_build = models.ModuleBuild.get_by_id(db_session, 3) mmd = second_module_build.mmd() xmd = mmd.get_xmd() xmd["mbs"]["buildrequires"]["platform"]["stream"] = "different" deps = Modulemd.Dependencies() deps.add_buildtime_stream("platform", "different") deps.add_runtime_stream("platform", "different") mmd.clear_dependencies() mmd.add_dependencies(deps) mmd.set_xmd(xmd) second_module_build.modulemd = mmd_to_str(mmd) second_module_build.build_context = \ models.ModuleBuild.contexts_from_mmd(second_module_build.modulemd).build_context second_module_build.rebuild_strategy = rebuild_strategy db_session.commit() plc_rv = get_reusable_component(second_module_build, "perl-List-Compare") pt_rv = get_reusable_component(second_module_build, "perl-Tangerine") tangerine_rv = get_reusable_component(second_module_build, "tangerine") assert plc_rv is None assert pt_rv is None assert tangerine_rv is None
def test_submit_module_build_from_yaml_with_skiptests(self, mock_submit): """ Tests local module build from a yaml file with the skiptests option Args: mock_submit (MagickMock): mocked function submit_module_build, which we then inspect if it was called with correct arguments """ module_dir = tempfile.mkdtemp() module = models.ModuleBuild.get_by_id(db_session, 3) mmd = module.mmd() modulemd_yaml = mmd_to_str(mmd) modulemd_file_path = path.join(module_dir, "testmodule.yaml") username = "******" stream = "dev" with io.open(modulemd_file_path, "w", encoding="utf-8") as fd: fd.write(modulemd_yaml) with open(modulemd_file_path, "rb") as fd: handle = FileStorage(fd) submit_module_build_from_yaml( db_session, username, handle, {}, stream=stream, skiptests=True) mock_submit_args = mock_submit.call_args[0] username_arg = mock_submit_args[1] mmd_arg = mock_submit_args[2] assert mmd_arg.get_stream_name() == stream assert "\n\n%__spec_check_pre exit 0\n" in mmd_arg.get_buildopts().get_rpm_macros() assert username_arg == username rmtree(module_dir)
def test_get_module_build_dependencies_recursive( self, reuse_component_init_data): """ Tests that the buildrequires are returned when it is two layers deep """ # Add testmodule2 that requires testmodule module = models.ModuleBuild.get_by_id(db_session, 3) mmd = module.mmd() # Rename the module mmd = mmd.copy("testmodule2") mmd.set_version(20180123171545) deps = Modulemd.Dependencies() deps.add_runtime_stream("testmodule", "master") mmd.add_dependencies(deps) xmd = mmd.get_xmd() xmd["mbs"]["requires"]["testmodule"] = { "filtered_rpms": [], "ref": "620ec77321b2ea7b0d67d82992dda3e1d67055b4", "stream": "master", "version": "20180205135154", } mmd.set_xmd(xmd) module.modulemd = mmd_to_str(mmd) module.name = "testmodule2" module.version = str(mmd.get_version()) module.koji_tag = "module-ae2adf69caf0e1b6" db_session.commit() resolver = mbs_resolver.GenericResolver.create(db_session, conf, backend="db") result = resolver.get_module_build_dependencies( "testmodule2", "master", "20180123171545", "c40c156c").keys() assert set(result) == {"module-f28-build"}
def test_resolve_requires_siblings(self, require_platform_and_default_arch): resolver = mbs_resolver.GenericResolver.create(db_session, conf, backend="db") mmd = load_mmd(tests.read_staged_data("formatted_testmodule")) for i in range(3): build = tests.module_build_from_modulemd(mmd_to_str(mmd)) build.context = "f6e2ae" + str(i) build.build_context = "f6e2aeec7576196241b9afa0b6b22acf2b6873d" + str( i) build.runtime_context = "bbc84c7b817ab3dd54916c0bcd6c6bdf512f7f9c" + str( i) build.state = models.BUILD_STATES["ready"] db_session.add(build) db_session.commit() build_one = ModuleBuild.get_by_id(db_session, 2) nsvc = ":".join([ build_one.name, build_one.stream, build_one.version, build_one.context ]) result = resolver.resolve_requires([nsvc]) assert result == { "testmodule": { "stream": build_one.stream, "version": build_one.version, "context": build_one.context, "ref": "65a7721ee4eff44d2a63fb8f3a8da6e944ab7f4d", "koji_tag": None } } db_session.commit()
def test_get_reusable_component_different_arch_in_batch( self, changed_component, reuse_component): """ Test that we get the correct reuse behavior for the changed-and-after strategy. Changes to the architectures in earlier batches should prevent reuse, but such changes to later batches should not. For context, see https://pagure.io/fm-orchestrator/issue/1298 """ if changed_component == reuse_component: # we're only testing the cases where these are different # this case is already covered by test_get_reusable_component_different_arches return second_module_build = models.ModuleBuild.get_by_id(db_session, 3) # update arch for changed component mmd = second_module_build.mmd() component = mmd.get_rpm_component(changed_component) component.reset_arches() component.add_restricted_arch("i686") second_module_build.modulemd = mmd_to_str(mmd) db_session.commit() changed_component = models.ComponentBuild.from_component_name( db_session, changed_component, second_module_build.id) reuse_component = models.ComponentBuild.from_component_name( db_session, reuse_component, second_module_build.id) reuse_result = get_reusable_component(second_module_build, reuse_component.package) # Changing the arch of a component should prevent reuse only when the changed component # is in a batch earlier than the component being considered for reuse. assert bool(reuse_result is None) == bool( reuse_component.batch > changed_component.batch)
def test_init_called_twice(self): build = self.init_basic(db_session) old_component_builds = len(build.component_builds) old_mmd = load_mmd(build.modulemd) build.state = 4 db_session.commit() build = self.init_basic(db_session) db_session.refresh(build) assert build.state == 1 assert old_component_builds == len(build.component_builds) new_mmd = load_mmd(build.modulemd) # Compare only lengths, because `mmd_to_str` can shuffle the fields randomly. assert len(mmd_to_str(old_mmd)) == len(mmd_to_str(new_mmd))
def test_get_buildrequired_modulemds(self): mmd = load_mmd(tests.read_staged_data("platform")) mmd = mmd.copy(mmd.get_module_name(), "f30.1.3") import_mmd(db_session, mmd) platform_f300103 = db_session.query(ModuleBuild).filter_by(stream="f30.1.3").one() mmd = tests.make_module("testmodule:master:20170109091357:123") build = ModuleBuild( name="testmodule", stream="master", version=20170109091357, state=5, build_context="dd4de1c346dcf09ce77d38cd4e75094ec1c08ec3", runtime_context="ec4de1c346dcf09ce77d38cd4e75094ec1c08ef7", context="7c29193d", koji_tag="module-testmodule-master-20170109091357-7c29193d", scmurl="https://src.stg.fedoraproject.org/modules/testmodule.git?#ff1ea79", batch=3, owner="Dr. Pepper", time_submitted=datetime(2018, 11, 15, 16, 8, 18), time_modified=datetime(2018, 11, 15, 16, 19, 35), rebuild_strategy="changed-and-after", modulemd=mmd_to_str(mmd), ) build.buildrequires.append(platform_f300103) db_session.add(build) db_session.commit() resolver = mbs_resolver.GenericResolver.create(db_session, conf, backend="db") result = resolver.get_buildrequired_modulemds( "testmodule", "master", platform_f300103.mmd()) nsvcs = {m.get_nsvc() for m in result} assert nsvcs == {"testmodule:master:20170109091357:123"}
def test_get_reusable_component_different_buildrequires(self): second_module_build = models.ModuleBuild.get_by_id(db_session, 3) mmd = second_module_build.mmd() mmd.get_dependencies()[0].add_buildtime_stream("some_module", "master") xmd = mmd.get_xmd() xmd["mbs"]["buildrequires"] = { "some_module": { "ref": "da39a3ee5e6b4b0d3255bfef95601890afd80709", "stream": "master", "version": "20170123140147", } } mmd.set_xmd(xmd) second_module_build.modulemd = mmd_to_str(mmd) second_module_build.build_context = models.ModuleBuild.calculate_build_context( xmd["mbs"]["buildrequires"]) db_session.commit() plc_rv = get_reusable_component(second_module_build, "perl-List-Compare") assert plc_rv is None pt_rv = get_reusable_component(second_module_build, "perl-Tangerine") assert pt_rv is None tangerine_rv = get_reusable_component(second_module_build, "tangerine") assert tangerine_rv is None
def test_tagging_already_tagged_artifacts(self, blocklist, mock_get_session): """ Tests that buildroot_add_artifacts and tag_artifacts do not try to tag already tagged artifacts """ module_build = module_build_service.common.models.ModuleBuild.get_by_id( db_session, 2) if blocklist: mmd = module_build.mmd() xmd = mmd.get_xmd() xmd["mbs_options"] = {"blocked_packages": ["foo", "bar", "new"]} mmd.set_xmd(xmd) module_build.modulemd = mmd_to_str(mmd) db_session.commit() builder = FakeKojiModuleBuilder( db_session=db_session, owner=module_build.owner, module=module_build, config=conf, tag_name="module-nginx-1.2", components=[], ) builder.module_tag = {"name": "module-foo", "id": 1} builder.module_build_tag = {"name": "module-foo-build", "id": 2} # Set listTagged to return test data tagged = [{ "nvr": "foo-1.0-1.module_e0095747" }, { "nvr": "bar-1.0-1.module_e0095747" }] builder.koji_session.listTagged.return_value = tagged # Try to tag one artifact which is already tagged and one new ... to_tag = ["foo-1.0-1.module_e0095747", "new-1.0-1.module_e0095747"] builder.buildroot_add_artifacts(to_tag) if blocklist: # "foo" and "new" packages should be unblocked before tagging. expected_calls = [ mock.call("module-foo-build", "foo"), mock.call("module-foo-build", "new"), ] else: expected_calls = [] assert builder.koji_session.packageListUnblock.mock_calls == expected_calls # ... only new one should be added. builder.koji_session.tagBuild.assert_called_once_with( builder.module_build_tag["id"], "new-1.0-1.module_e0095747") # Try the same for tag_artifacts(...). builder.koji_session.tagBuild.reset_mock() builder.tag_artifacts(to_tag) builder.koji_session.tagBuild.assert_called_once_with( builder.module_tag["id"], "new-1.0-1.module_e0095747")
def test_get_arch_mmd_output_components(self, patched_open): mmd = self.cg.module.mmd() mmd.add_rpm_artifact("dhcp-libs-12:4.3.5-5.module_2118aef6.x86_64") mmd_data = mmd_to_str(mmd).encode("utf-8") patched_open.return_value = mock_open(read_data=mmd_data).return_value self.cg.rpms = [{ "name": "dhcp", "version": "4.3.5", "release": "5.module_2118aef6", "arch": "x86_64", "epoch": "12", "payloadhash": "hash", }] self.cg.rpms_dict = { "dhcp-libs-12:4.3.5-5.module_2118aef6.x86_64": { "name": "dhcp", "version": "4.3.5", "release": "5.module_2118aef6", "arch": "x86_64", "epoch": "12", "payloadhash": "hash", } } ret = self.cg._get_arch_mmd_output("./fake-dir", "x86_64") assert ret == { "arch": "x86_64", "buildroot_id": 1, "checksum": "5fbad2ef9b6c5496bdce4368ca3182d6", "checksum_type": "md5", "components": [{ u"arch": "x86_64", u"epoch": "12", u"name": "dhcp", u"release": "5.module_2118aef6", u"sigmd5": "hash", u"type": u"rpm", u"version": "4.3.5", }], "extra": { "typeinfo": { "module": {} } }, "filename": "modulemd.x86_64.txt", "filesize": 316, "type": "file", }
def test_get_buildrequired_modulemds_kojiresolver(self, mock_session): """ Test that MBSResolver uses KojiResolver as input when KojiResolver is enabled for the base module. """ mock_session.get.return_value = Mock(ok=True) mock_session.get.return_value.json.return_value = { "items": [ { "name": "nodejs", "stream": "10", "version": 2, "context": "c1", "modulemd": mmd_to_str(tests.make_module("nodejs:10:2:c1"), ), }, ], "meta": { "next": None }, } resolver = mbs_resolver.GenericResolver.create(db_session, conf, backend="mbs") platform = db_session.query( module_build_service.common.models.ModuleBuild).filter_by( id=1).one() platform_mmd = platform.mmd() platform_xmd = platform_mmd.get_xmd() platform_xmd["mbs"]["koji_tag_with_modules"] = "module-f29-build" platform_mmd.set_xmd(platform_xmd) with patch.object(resolver, "get_buildrequired_koji_builds" ) as get_buildrequired_koji_builds: get_buildrequired_koji_builds.return_value = [{ "build_id": 124, "name": "nodejs", "version": "10", "release": "2.c1", "tag_name": "foo-test" }] result = resolver.get_buildrequired_modulemds( "nodejs", "10", platform_mmd) get_buildrequired_koji_builds.assert_called_once() assert 1 == len(result) mmd = result[0] assert "nodejs" == mmd.get_module_name() assert "10" == mmd.get_stream_name() assert 2 == mmd.get_version() assert "c1" == mmd.get_context()
def _get_fixed_mmd(self): if self.devel: mmd = self.module.mmd() mmd = mmd.copy(mmd.get_module_name() + "-devel") ret = mmd_to_str(mmd) else: ret = self.mmd return ret
def test_add_default_modules(mock_get_dm, mock_hc, require_platform_and_default_arch): """ Test that default modules present in the database are added, and the others are ignored. """ mmd = load_mmd(read_staged_data("formatted_testmodule.yaml")) xmd_brs = mmd.get_xmd()["mbs"]["buildrequires"] assert set(xmd_brs.keys()) == {"platform"} platform = ModuleBuild.get_build_from_nsvc( db_session, "platform", xmd_brs["platform"]["stream"], xmd_brs["platform"]["version"], xmd_brs["platform"]["context"], ) assert platform platform_mmd = platform.mmd() platform_xmd = mmd.get_xmd() platform_xmd["mbs"]["use_default_modules"] = True platform_mmd.set_xmd(platform_xmd) platform.modulemd = mmd_to_str(platform_mmd) dependencies = [{ "requires": { "platform": ["f28"] }, "buildrequires": { "platform": ["f28"] } }] make_module_in_db("python:3:12345:1", base_module=platform, dependencies=dependencies) make_module_in_db("nodejs:11:2345:2", base_module=platform, dependencies=dependencies) db_session.commit() mock_get_dm.return_value = { "nodejs": "11", "python": "3", "ruby": "2.6", } defaults_added = default_modules.add_default_modules(mmd) # Make sure that the default modules were added. ruby:2.6 will be ignored since it's not in # the database assert set(mmd.get_xmd()["mbs"]["buildrequires"].keys()) == { "nodejs", "platform", "python" } mock_get_dm.assert_called_once_with( "f28", "https://pagure.io/releng/fedora-module-defaults.git", ) assert "ursine_rpms" not in mmd.get_xmd()["mbs"] assert defaults_added is True
def setup_method(self, test_method): self.fn = module_build_service.scheduler.handlers.modules.init testmodule_yml_path = read_staged_data("testmodule_init") mmd = load_mmd(testmodule_yml_path) # Set the name and stream mmd = mmd.copy("testmodule", "1") scmurl = "git://pkgs.domain.local/modules/testmodule?#620ec77" clean_database() ModuleBuild.create(db_session, conf, "testmodule", "1", 3, mmd_to_str(mmd), scmurl, "mprahl")
def _create_test_modules(self, koji_tag_with_modules="foo-test"): mmd = load_mmd(tests.read_staged_data("platform")) mmd = mmd.copy(mmd.get_module_name(), "f30.1.3") import_mmd(db_session, mmd) platform = db_session.query(ModuleBuild).filter_by( stream="f30.1.3").one() if koji_tag_with_modules: platform = db_session.query(ModuleBuild).filter_by( stream="f30.1.3").one() platform_mmd = platform.mmd() platform_xmd = platform_mmd.get_xmd() platform_xmd["mbs"][ "koji_tag_with_modules"] = koji_tag_with_modules platform_mmd.set_xmd(platform_xmd) platform.modulemd = mmd_to_str(platform_mmd) for context in ["7c29193d", "7c29193e"]: mmd = tests.make_module("testmodule:master:20170109091357:" + context) build = ModuleBuild( name="testmodule", stream="master", version=20170109091357, state=5, build_context="dd4de1c346dcf09ce77d38cd4e75094ec1c08ec3", runtime_context="ec4de1c346dcf09ce77d38cd4e75094ec1c08ef7", context=context, koji_tag="module-testmodule-master-20170109091357-" + context, scmurl= "https://src.stg.fedoraproject.org/modules/testmodule.git?#ff1ea79", batch=3, owner="Dr. Pepper", time_submitted=datetime(2018, 11, 15, 16, 8, 18), time_modified=datetime(2018, 11, 15, 16, 19, 35), rebuild_strategy="changed-and-after", modulemd=mmd_to_str(mmd), ) build.buildrequires.append(platform) db_session.add(build) db_session.commit()
def test_get_buildrequired_modulemds(self, mock_session): resolver = mbs_resolver.GenericResolver.create(db_session, conf, backend="mbs") mock_session.get.return_value = Mock(ok=True) mock_session.get.return_value.json.return_value = { "items": [ { "name": "nodejs", "stream": "10", "version": 1, "context": "c1", "modulemd": mmd_to_str(tests.make_module("nodejs:10:1:c1"), ), }, { "name": "nodejs", "stream": "10", "version": 2, "context": "c1", "modulemd": mmd_to_str(tests.make_module("nodejs:10:2:c1"), ), }, ], "meta": { "next": None }, } platform = db_session.query( module_build_service.common.models.ModuleBuild).filter_by( id=1).one() result = resolver.get_buildrequired_modulemds("nodejs", "10", platform.mmd()) assert 1 == len(result) mmd = result[0] assert "nodejs" == mmd.get_module_name() assert "10" == mmd.get_stream_name() assert 1 == mmd.get_version() assert "c1" == mmd.get_context()
def test_get_module_build_dependencies_empty_buildrequires( self, mock_session, testmodule_mmd_9c690d0e): mmd = load_mmd(testmodule_mmd_9c690d0e) # Wipe out the dependencies for deps in mmd.get_dependencies(): mmd.remove_dependencies(deps) xmd = mmd.get_xmd() xmd["mbs"]["buildrequires"] = {} mmd.set_xmd(xmd) mock_res = Mock() mock_res.ok.return_value = True mock_res.json.side_effect = [{ "items": [{ "name": "testmodule", "stream": "master", "version": "20180205135154", "context": "9c690d0e", "modulemd": mmd_to_str(mmd), "build_deps": [], }], "meta": { "next": None }, }] mock_session.get.return_value = mock_res expected = set() resolver = mbs_resolver.GenericResolver.create(db_session, conf, backend="mbs") result = resolver.get_module_build_dependencies( "testmodule", "master", "20180205135154", "9c690d0e").keys() mbs_url = conf.mbs_url expected_query = { "name": "testmodule", "stream": "master", "version": "20180205135154", "context": "9c690d0e", "verbose": True, "order_desc_by": "version", "page": 1, "per_page": 10, "state": ["ready"], } mock_session.get.assert_called_once_with(mbs_url, params=expected_query) assert set(result) == expected
def test_get_reusable_component_different_rpm_macros(self): second_module_build = models.ModuleBuild.get_by_id(db_session, 3) mmd = second_module_build.mmd() buildopts = Modulemd.Buildopts() buildopts.set_rpm_macros("%my_macro 1") mmd.set_buildopts(buildopts) second_module_build.modulemd = mmd_to_str(mmd) db_session.commit() plc_rv = get_reusable_component(second_module_build, "perl-List-Compare") assert plc_rv is None pt_rv = get_reusable_component(second_module_build, "perl-Tangerine") assert pt_rv is None
def test_record_component_builds_component_exists_already( self, mocked_scm): mocked_scm.return_value.commit = "620ec77321b2ea7b0d67d82992dda3e1d67055b4" mocked_scm.return_value.get_latest.side_effect = [ "4ceea43add2366d8b8c5a622a2fb563b625b9abf", "fbed359411a1baa08d4a88e0d12d426fbf8f602c", "dbed259411a1baa08d4a88e0d12d426fbf8f6037", "4ceea43add2366d8b8c5a622a2fb563b625b9abf", # To simulate that when a module is resubmitted, some ref of # its components is changed, which will cause MBS stops # recording component to database and raise an error. "abcdefg", "dbed259411a1baa08d4a88e0d12d426fbf8f6037", ] original_mmd = load_mmd(read_staged_data("testmodule")) # Set the module name and stream mmd = original_mmd.copy("testmodule", "master") module_build = module_build_service.common.models.ModuleBuild() module_build.name = "testmodule" module_build.stream = "master" module_build.version = 20170109091357 module_build.state = models.BUILD_STATES["init"] module_build.scmurl = \ "https://src.stg.fedoraproject.org/modules/testmodule.git?#ff1ea79" module_build.batch = 1 module_build.owner = "Tom Brady" module_build.time_submitted = datetime(2017, 2, 15, 16, 8, 18) module_build.time_modified = datetime(2017, 2, 15, 16, 19, 35) module_build.rebuild_strategy = "changed-and-after" module_build.modulemd = mmd_to_str(mmd) db_session.add(module_build) db_session.commit() format_mmd(mmd, module_build.scmurl) record_component_builds(mmd, module_build) db_session.commit() mmd = original_mmd.copy("testmodule", "master") from module_build_service.common.errors import ValidationError with pytest.raises( ValidationError, match= r"Component build .+ of module build .+ already exists in database" ): format_mmd(mmd, module_build.scmurl) record_component_builds(mmd, module_build)
def test_get_rpm_release_platform_stream_override(): scheduler_init_data(1) # Set the disttag_marking override on the platform platform = (db_session.query(models.ModuleBuild).filter_by( name="platform", stream="f28").first()) platform_mmd = platform.mmd() platform_xmd = platform_mmd.get_xmd() platform_xmd["mbs"]["disttag_marking"] = "fedora28" platform_mmd.set_xmd(platform_xmd) platform.modulemd = mmd_to_str(platform_mmd) db_session.add(platform) db_session.commit() build_one = models.ModuleBuild.get_by_id(db_session, 2) release = utils.get_rpm_release(db_session, build_one) assert release == "module+fedora28+2+814cfa39"
def test_init_includedmodule(self, get_build_arches, mocked_scm, mocked_mod_allow_repo): FakeSCM(mocked_scm, "includedmodules", ["testmodule_init.yaml"]) includedmodules_yml_path = read_staged_data("includedmodules") mmd = load_mmd(includedmodules_yml_path) # Set the name and stream mmd = mmd.copy("includedmodules", "1") scmurl = "git://pkgs.domain.local/modules/includedmodule?#da95886" ModuleBuild.create(db_session, conf, "includemodule", "1", 3, mmd_to_str(mmd), scmurl, "mprahl") self.fn(msg_id="msg-id-1", module_build_id=3, module_build_state="init") build = ModuleBuild.get_by_id(db_session, 3) assert build.state == 1 assert build.name == "includemodule" batches = {} for comp_build in build.component_builds: batches[comp_build.package] = comp_build.batch assert batches["perl-List-Compare"] == 2 assert batches["perl-Tangerine"] == 2 assert batches["foo"] == 2 assert batches["tangerine"] == 3 assert batches["file"] == 4 # Test that the RPMs are properly merged in xmd xmd_rpms = { "perl-List-Compare": { "ref": "4f26aeafdb" }, "perl-Tangerine": { "ref": "4f26aeafdb" }, "tangerine": { "ref": "4f26aeafdb" }, "foo": { "ref": "93dea37599" }, "file": { "ref": "a2740663f8" }, } assert build.mmd().get_xmd()["mbs"]["rpms"] == xmd_rpms
def test_prepare_file_directory_modulemd_src(self, mocked_scm): FakeSCM( mocked_scm, "testmodule", "testmodule_init.yaml", "620ec77321b2ea7b0d67d82992dda3e1d67055b4", ) mmd = self.cg.module.mmd() mmd.set_xmd({ "mbs": { "commit": "foo", "scmurl": "git://localhost/modules/foo.git#master" } }) self.cg.module.modulemd = mmd_to_str(mmd) file_dir = self.cg._prepare_file_directory() with io.open(path.join(file_dir, "modulemd.src.txt"), encoding="utf-8") as mmd: assert len(mmd.read()) == 1339
def init_basic(self, db_session, get_build_arches, hcwbmr, rscm, mocked_scm, built_rpms): FakeSCM( mocked_scm, "testmodule", "testmodule_init.yaml", "620ec77321b2ea7b0d67d82992dda3e1d67055b4", ) built_rpms.return_value = [ "foo-0:2.4.48-3.el8+1308+551bfa71", "foo-debuginfo-0:2.4.48-3.el8+1308+551bfa71", "bar-0:2.5.48-3.el8+1308+551bfa71", "bar-debuginfo-0:2.5.48-3.el8+1308+551bfa71", "x-0:2.5.48-3.el8+1308+551bfa71", "x-debuginfo-0:2.5.48-3.el8+1308+551bfa71", ] platform_build = ModuleBuild.get_by_id(db_session, 1) mmd = platform_build.mmd() for rpm in mmd.get_rpm_filters(): mmd.remove_rpm_filter(rpm) mmd.add_rpm_filter("foo") mmd.add_rpm_filter("bar") platform_build.modulemd = mmd_to_str(mmd) db_session.commit() self.fn(msg_id="msg-id-1", module_build_id=2, module_build_state="init") build = ModuleBuild.get_by_id(db_session, 2) # Make sure the module entered the wait state assert build.state == 1, build.state # Make sure format_mmd was run properly xmd_mbs = build.mmd().get_xmd()["mbs"] assert xmd_mbs["buildrequires"]["platform"]["filtered_rpms"] == [ "foo-0:2.4.48-3.el8+1308+551bfa71", "bar-0:2.5.48-3.el8+1308+551bfa71", ] hcwbmr.assert_called_once() return build
def test_record_component_builds_duplicate_components(self, mocked_scm): # Mock for format_mmd to get components' latest ref mocked_scm.return_value.commit = "620ec77321b2ea7b0d67d82992dda3e1d67055b4" mocked_scm.return_value.get_latest.side_effect = [ "4ceea43add2366d8b8c5a622a2fb563b625b9abf", "fbed359411a1baa08d4a88e0d12d426fbf8f602c", ] mmd = load_mmd(read_staged_data("testmodule")) mmd = mmd.copy("testmodule-variant", "master") module_build = module_build_service.common.models.ModuleBuild() module_build.name = "testmodule-variant" module_build.stream = "master" module_build.version = 20170109091357 module_build.state = models.BUILD_STATES["init"] module_build.scmurl = \ "https://src.stg.fedoraproject.org/modules/testmodule.git?#ff1ea79" module_build.batch = 1 module_build.owner = "Tom Brady" module_build.time_submitted = datetime(2017, 2, 15, 16, 8, 18) module_build.time_modified = datetime(2017, 2, 15, 16, 19, 35) module_build.rebuild_strategy = "changed-and-after" module_build.modulemd = mmd_to_str(mmd) db_session.add(module_build) db_session.commit() # Rename the the modulemd to include mmd = mmd.copy("testmodule") # Remove perl-Tangerine and tangerine from the modulemd to include so only one # component conflicts mmd.remove_rpm_component("perl-Tangerine") mmd.remove_rpm_component("tangerine") error_msg = ( 'The included module "testmodule" in "testmodule-variant" have ' "the following conflicting components: perl-List-Compare") format_mmd(mmd, module_build.scmurl) with pytest.raises(UnprocessableEntity) as e: record_component_builds(mmd, module_build, main_mmd=module_build.mmd()) assert str(e.value) == error_msg