def test_set_spec_ver_empty_changelog(tmpdir): t = Path(str(tmpdir)) u_remote_path = t / "upstream_remote" u_remote_path.mkdir(parents=True, exist_ok=True) subprocess.check_call(["git", "init", "--bare", "."], cwd=u_remote_path) u = t / "upstream_git" shutil.copytree(EMPTY_CHANGELOG, u) initiate_git_repo(u, tag="0.1.0") with cwd(tmpdir): c = get_test_config() pc = get_local_package_config(str(u)) pc.upstream_project_url = str(u) lp = LocalProject(working_dir=str(u)) ups = Upstream(c, pc, lp) new_ver = "1.2.3" ups.specfile.set_spec_version(version=new_ver, changelog_entry="- asdqwe") assert ups.get_specfile_version() == new_ver assert "%changelog" not in u.joinpath("beer.spec").read_text()
def test_basic_local_update_direct_push(upstream_distgit_remote, mock_remote_functionality_upstream): """ basic propose-update test: mock remote API, use local upstream and dist-git """ upstream, distgit, remote_dir = upstream_distgit_remote with cwd(upstream): c = get_test_config() pc = get_local_package_config(str(upstream)) pc.upstream_project_url = str(upstream) pc.dist_git_clone_path = str(distgit) up_lp = LocalProject(working_dir=str(upstream)) api = PackitAPI(c, pc, up_lp) api.sync_release("master", "0.1.0", create_pr=False) remote_dir_clone = Path(f"{remote_dir}-clone") subprocess.check_call( ["git", "clone", remote_dir, str(remote_dir_clone)], cwd=str(remote_dir_clone.parent), ) spec = get_specfile(str(remote_dir_clone / "beer.spec")) assert spec.get_version() == "0.1.0" assert (remote_dir_clone / "README.packit").is_file()
def test_srpm(mock_remote_functionality_sourcegit, api_instance_source_git): # TODO: we need a better test case here which will mimic the systemd use case sg_path = Path(api_instance_source_git.upstream_local_project.working_dir) mock_spec_download_remote_s(sg_path / "fedora") with cwd(sg_path): api_instance_source_git.create_srpm(upstream_ref="0.1.0") assert list(sg_path.glob("beer-0.1.0-1.*.src.rpm"))[0].is_file()
def cwd_upstream_or_distgit( request, upstream_and_remote, distgit_and_remote, ogr_distgit_and_remote, upstream_and_remote_with_multiple_sources, ): """ Run the code from upstream, downstream and ogr-distgit. When using be careful to - specify this fixture in the right place (the order of the parameters means order of the execution) - to not overwrite the cwd in the other fixture or in the test itself """ cwd_path = { "upstream": upstream_and_remote[0], "distgit": distgit_and_remote[0], "ogr-distgit": ogr_distgit_and_remote[0], "upstream-with-multiple-sources": upstream_and_remote_with_multiple_sources[0], }[request.param] with cwd(cwd_path): yield cwd_path
def test_srpm_merge_storm(mock_remote_functionality_sourcegit, api_instance_source_git): sg_path = Path(api_instance_source_git.upstream_local_project.working_dir) mock_spec_download_remote_s(sg_path / "fedora") create_merge_commit_in_source_git(sg_path, go_nuts=True) with cwd(sg_path): api_instance_source_git.create_srpm(upstream_ref="0.1.0") srpm_path = list(sg_path.glob("beer-0.1.0-2.*.src.rpm"))[0] assert srpm_path.is_file() build_srpm(srpm_path) branches = subprocess.check_output( ["git", "for-each-ref", "--format=%(refname:short)", "refs/heads/"], cwd=sg_path).split(b"\n") for b in branches: if b and b.startswith(b"packit-patches-"): break else: raise AssertionError( "packit-patches- branch was not found - this should trigger the linearization" ) assert set([x.name for x in sg_path.joinpath("fedora").glob("*.patch")]) == { "0001-MERGE-COMMIT.patch", "0002-ugly-merge-commit.patch", }
def test_schema_validation(tmpdir, raw_package_config, expected_output): with cwd(tmpdir): Path("packit.json").write_text(raw_package_config) Path("packit.spec").write_text("hello") output = PackitAPI.validate_package_config(Path(".")) assert expected_output in output
def run_dist2src(*args, working_dir=None, **kwargs): working_dir = working_dir or Path.cwd() with cwd(working_dir): cli_runner = CliRunner() # if you want to run debugger inside you need to do 2 things: # get real std{in,out} at the level of imports because click patches it # invoke pdb like this: "import pdb; pdb.Pdb(stdin=stdin, stdout=stdout).set_trace()" cli_runner.invoke(cli, *args, catch_exceptions=False, **kwargs)
def test_srpm_command_for_path(upstream_or_distgit_path, tmpdir): with cwd(tmpdir): call_real_packit( parameters=["--debug", "srpm", str(upstream_or_distgit_path)]) srpm_path = list(Path.cwd().glob("*.src.rpm"))[0] assert srpm_path.exists() build_srpm(srpm_path)
def test_srpm_on_example(example_repo): c = get_test_config() api = get_packit_api( config=c, local_project=LocalProject(working_dir=str(example_repo))) with cwd(example_repo): path = api.create_srpm() assert path.exists() build_srpm(path)
def run_packit(*args, working_dir=None, **kwargs): working_dir = working_dir or Path.cwd() with cwd(working_dir): cli_runner = CliRunner() cli_result = cli_runner.invoke(packit_base, *args, catch_exceptions=False, **kwargs) print(cli_result.stdout) # contains both std{err,out}
def call_packit(fnc=None, parameters=None, envs=None, working_dir=None): working_dir = working_dir or "." fnc = fnc or packit_base runner = CliRunner() envs = envs or {} parameters = parameters or [] # catch exceptions enables debugger with cwd(working_dir): return runner.invoke(fnc, args=parameters, env=envs, catch_exceptions=False)
def test_srpm(mock_remote_functionality_sourcegit, api_instance_source_git): sg_path = Path(api_instance_source_git.upstream_local_project.working_dir) mock_spec_download_remote_s(sg_path / "fedora") create_merge_commit_in_source_git(sg_path) with cwd(sg_path): api_instance_source_git.create_srpm(upstream_ref="0.1.0") srpm_path = list(sg_path.glob("beer-0.1.0-2.*.src.rpm"))[0] assert srpm_path.is_file() build_srpm(srpm_path)
def test_srpm_command_for_path_with_multiple_sources( upstream_and_remote_with_multiple_sources, ): workdir, _ = upstream_and_remote_with_multiple_sources with cwd(workdir): call_real_packit(parameters=["--debug", "srpm", str(workdir)]) srpm_path = list(Path.cwd().glob("*.src.rpm"))[0] assert srpm_path.exists() assert (Path.cwd() / "python-ogr.spec").exists() build_srpm(srpm_path)
def test_srpm_snapd(snapd): pc = get_local_package_config(str(snapd)) up_lp = LocalProject(working_dir=str(snapd)) c = get_test_config() api = PackitAPI(c, pc, up_lp) with cwd(snapd): path = api.create_srpm() assert path.exists() build_srpm(path)
def api_instance_source_git(sourcegit_n_distgit): sourcegit, distgit = sourcegit_n_distgit with cwd(sourcegit): c = get_test_config() pc = get_local_package_config(str(sourcegit)) pc.upstream_project_url = str(sourcegit) pc.dist_git_clone_path = str(distgit) up_lp = LocalProject(working_dir=str(sourcegit)) api = PackitAPI(c, pc, up_lp) return api
def test_srpm_on_cockpit_ostree(cockpit_ostree): upstream_path, dist_git_path = cockpit_ostree pc = get_local_package_config(str(upstream_path)) up_lp = LocalProject(working_dir=str(upstream_path)) c = get_test_config() api = PackitAPI(c, pc, up_lp) with cwd(upstream_path): api.create_srpm()
def test_generate_pass(upstream_without_config): with cwd(upstream_without_config): assert not (upstream_without_config / ".packit.yaml").is_file() # This test requires packit on pythonpath result = call_packit(parameters=["generate"]) assert result.exit_code == 0 assert (upstream_without_config / ".packit.yaml").is_file()
def download_upstream_archive(self) -> Path: """ Fetch archive for the current upstream release defined in dist-git's spec :return: str, path to the archive """ with cwd(self.local_project.working_dir): self.specfile.download_remote_sources() archive = self.absolute_specfile_dir / self.upstream_archive_name logger.info(f"Downloaded archive: {archive}") return archive
def test_raw_files_to_sync(packit_files, expected): with cwd(TESTS_DIR): pc = PackageConfig( dist_git_base_url="https://packit.dev/", downstream_package_name="packit", dist_git_namespace="awesome", specfile_path="fedora/package.spec", synced_files=packit_files, ) assert set(pc.synced_files.get_raw_files_to_sync( Path("."), Path("."))) == set(expected)
def upstream_instance(upstream_n_distgit, tmpdir): with cwd(tmpdir): u, d = upstream_n_distgit c = get_test_config() pc = get_local_package_config(str(u)) pc.upstream_project_url = str(u) pc.dist_git_clone_path = str(d) lp = LocalProject(working_dir=str(u)) ups = Upstream(c, pc, lp) yield u, ups
def upstream_instance(upstream_and_remote, distgit_and_remote, tmp_path): with cwd(tmp_path): u, _ = upstream_and_remote d, _ = distgit_and_remote c = get_test_config() pc = get_local_package_config(str(u)) pc.upstream_project_url = str(u) pc.dist_git_clone_path = str(d) lp = LocalProject(working_dir=str(u)) ups = Upstream(c, pc, lp) yield u, ups
def download_upstream_archive(self) -> Path: """ Fetch archive for the current upstream release defined in dist-git's spec :return: str, path to the archive """ with cwd(self.local_project.working_dir): self.specfile.download_remote_sources() archive = self.absolute_specfile_dir / self.upstream_archive_name if not archive.exists(): raise PackitException( "Upstream archive was not downloaded, something is wrong.") logger.info(f"Downloaded archive: {archive}") return archive
def fetch_upstream_archive(self): # TODO: there is a bug in rebase-helper that it saves the source in cwd # File "/src/packit/base_git.py", line 298, in fetch_upstream_archive # self.specfile.download_remote_sources() # File "rebasehelper/specfile.py", line 220, in download_remote_sources # LookasideCacheHelper.download('fedpkg', os.path.dirname(self.path), self.get_ # File "rebasehelper/helpers/lookaside_cache_helper.py", line 122, in download # cls._download_source(tool, url, package, source['filename'], source['hashtype'], # File "rebasehelper/helpers/lookaside_cache_helper.py", line 109, in _download_source # try: # File "rebasehelper/helpers/download_helper.py", line 162, in download_file # with open(destination_path, 'wb') as local_file: # PermissionError: [Errno 13] Permission denied: 'systemd-8bca462.tar.gz' with cwd(self.absolute_specfile_dir): self.specfile.download_remote_sources()
def test_basic_bodhi_update( upstream_n_distgit, mock_remote_functionality_upstream, branch, update_type, update_notes, koji_builds, bodhi_response, ): # https://github.com/fedora-infra/bodhi/issues/3058 from bodhi.client.bindings import BodhiClient u, d = upstream_n_distgit with cwd(u): c = get_test_config() pc = get_local_package_config(str(u)) pc.upstream_project_url = str(u) pc.dist_git_clone_path = str(d) up_lp = LocalProject(working_dir=u) api = PackitAPI(c, pc, up_lp) flexmock( BodhiClient, latest_builds=lambda package: { "f29-override": "sen-0.6.0-3.fc29", "f29-updates": "sen-0.6.0-3.fc29", "f29-updates-candidate": "sen-0.6.0-3.fc29", "f29-updates-pending": "sen-0.6.0-3.fc29", "f29-updates-testing": "sen-0.6.0-3.fc29", "f29-updates-testing-pending": "sen-0.6.0-3.fc29", "f30-override": "sen-0.6.0-4.fc30", "f30-updates": "sen-0.6.0-4.fc30", "f30-updates-candidate": "sen-0.6.1-1.fc30", "f30-updates-pending": "sen-0.6.0-4.fc30", "f30-updates-testing": "sen-0.6.0-4.fc30", "f30-updates-testing-pending": "sen-0.6.0-4.fc30", }, save=lambda **kwargs: bodhi_response, ) api.create_update( dist_git_branch=branch, update_type=update_type, update_notes=update_notes, koji_builds=koji_builds, )
def test_basic_local_update_from_downstream( downstream_n_distgit, mock_downstream_remote_functionality): flexmock(LocalProject, _parse_namespace_from_git_url=lambda: None) u, d = downstream_n_distgit with cwd(u): c = get_test_config() pc = get_local_package_config(str(u)) pc.upstream_project_url = str(u) pc.dist_git_clone_path = str(d) up_lp = LocalProject(working_dir=str(u)) api = PackitAPI(c, pc, up_lp) api.sync_from_downstream("master", "master", True) assert (u / "beer.spec").is_file() spec = get_specfile(str(u / "beer.spec")) assert spec.get_version() == "0.0.0"
def test_srpm(mock_remote_functionality_sourcegit, api_instance_source_git): sg_path = Path(api_instance_source_git.upstream_local_project.working_dir) mock_spec_download_remote_s(sg_path / "fedora") create_merge_commit_in_source_git(sg_path) with cwd(sg_path): api_instance_source_git.create_srpm(upstream_ref="0.1.0") srpm_path = list(sg_path.glob("beer-0.1.0-2.*.src.rpm"))[0] assert srpm_path.is_file() build_srpm(srpm_path) branches = subprocess.check_output( ["git", "for-each-ref", "--format=%(refname:short)", "refs/heads/"], cwd=sg_path).split(b"\n") for b in branches: if b and b.startswith(b"packit-patches-"): raise AssertionError( "packit-patches- branch was found - the history shouldn't have been linearized" ) assert set([x.name for x in sg_path.joinpath("fedora").glob("*.patch")]) == { "0001-switching-to-amarillo-hops.patch", "0002-actually-let-s-do-citra.patch", }
def test_push_updates(upstream_n_distgit, query_response, request_response): from bodhi.client.bindings import BodhiClient u, d = upstream_n_distgit with cwd(u): c = get_test_config() pc = get_local_package_config(str(u)) pc.upstream_project_url = str(u) pc.dist_git_clone_path = str(d) up_lp = LocalProject(working_dir=u) api = PackitAPI(c, pc, up_lp) flexmock(BodhiClient) BodhiClient.should_receive("query").and_return(query_response).once() BodhiClient.should_receive("request").with_args( update="FEDORA-2019-89c99f680c", request="stable" ).and_return(request_response).once() api.push_updates()
def test_update_on_cockpit_ostree(cockpit_ostree): upstream_path, dist_git_path = cockpit_ostree def mocked_new_sources(sources=None): if not Path(sources).is_file(): raise RuntimeError("archive does not exist") flexmock(FedPKG, init_ticket=lambda x=None: None, new_sources=mocked_new_sources) flexmock( DistGit, push_to_fork=lambda *args, **kwargs: None, is_archive_in_lookaside_cache=lambda archive_path: False, upload_to_lookaside_cache=lambda path: None, download_upstream_archive=lambda: "the-archive", ) flexmock( PackitAPI, push_and_create_pr=lambda pr_title, pr_description, dist_git_branch: None, ) pc = get_local_package_config(str(upstream_path)) up_lp = LocalProject(working_dir=str(upstream_path)) c = get_test_config() api = PackitAPI(c, pc, up_lp) api._dg = DistGit(c, pc) api._dg._local_project = LocalProject(working_dir=dist_git_path) with cwd(upstream_path): api.sync_release( "master", use_local_content=False, version="179", force_new_sources=False, create_pr=True, )
def test_basic_build(upstream_n_distgit, mock_remote_functionality_upstream): u, d = upstream_n_distgit with cwd(u): c = get_test_config() pc = get_local_package_config(str(u)) pc.upstream_project_url = str(u) pc.dist_git_clone_path = str(d) up_lp = LocalProject(working_dir=u) api = PackitAPI(c, pc, up_lp) flexmock(utils).should_receive("run_command").with_args( cmd=[ "fedpkg", "build", "--scratch", "--nowait", "--target", "asdqwe" ], cwd=api.dg.local_project.working_dir, error_message="Submission of build to koji failed.", fail=True, ).once() api.build("master", scratch=True, nowait=True, koji_target="asdqwe")
def test_basic_local_update(upstream_n_distgit, mock_remote_functionality_upstream): """ basic propose-update test: mock remote API, use local upstream and dist-git """ u, d = upstream_n_distgit with cwd(u): c = get_test_config() pc = get_local_package_config(str(u)) pc.upstream_project_url = str(u) pc.dist_git_clone_path = str(d) up_lp = LocalProject(working_dir=str(u)) api = PackitAPI(c, pc, up_lp) api.sync_release("master", "0.1.0") assert (d / TARBALL_NAME).is_file() spec = get_specfile(str(d / "beer.spec")) assert spec.get_version() == "0.1.0" assert (d / "README.packit").is_file() # assert that we have changelog entries for both versions changelog = "\n".join(spec.spec_content.section("%changelog")) assert "0.0.0" in changelog assert "0.1.0" in changelog