def test_handler_cleanup(tmp_path, trick_p_s_with_k8s): tmp_path.joinpath("a").mkdir() tmp_path.joinpath("b").write_text("a") tmp_path.joinpath("c").symlink_to("b") tmp_path.joinpath("d").symlink_to("a", target_is_directory=True) tmp_path.joinpath("e").symlink_to("nope", target_is_directory=False) tmp_path.joinpath("f").symlink_to("nopez", target_is_directory=True) tmp_path.joinpath(".g").write_text("g") tmp_path.joinpath(".h").symlink_to(".g", target_is_directory=False) c = ServiceConfig() pc = flexmock(PackageConfig) c.command_handler_work_dir = tmp_path jc = JobConfig( type=JobType.copr_build, trigger=JobConfigTriggerType.pull_request, metadata=JobMetadataConfig(), ) j = JobHandler( package_config=pc, job_config=jc, event={}, ) flexmock(j).should_receive("service_config").and_return(c) j._clean_workplace() assert len(list(tmp_path.iterdir())) == 0
def mock_issue_comment_functionality(): packit_yaml = ( "{'specfile_path': 'packit.spec', 'synced_files': []," "'jobs': [{'trigger': 'release', 'job': 'propose_downstream'," "'metadata': {'dist-git-branch': 'master'}}]," "'downstream_package_name': 'packit'}") flexmock( GithubProject, get_file_content=lambda path, ref: packit_yaml, full_repo_name="packit-service/packit", ) flexmock(Github, get_repo=lambda full_name_or_id: None) (flexmock(GithubProject).should_receive("can_merge_pr").with_args( "phracek").and_return(True)) flexmock(GithubProject).should_receive("issue_comment").and_return(None) flexmock(GithubProject).should_receive("issue_close").and_return(None) gr = GithubRelease( tag_name="0.5.1", url="packit-service/packit", created_at="", tarball_url="https://foo/bar", git_tag=flexmock(GitTag), project=flexmock(GithubProject), raw_release=flexmock(PyGithubRelease), ) flexmock(GithubProject).should_receive("get_releases").and_return([gr]) config = ServiceConfig() config.command_handler_work_dir = SANDCASTLE_WORK_DIR flexmock(ServiceConfig).should_receive("get_service_config").and_return( config) flexmock(LocalProject, refresh_the_arguments=lambda: None) flexmock(Whitelist, check_and_report=True)
def test_installation(): config = ServiceConfig() config.command_handler_work_dir = SANDCASTLE_WORK_DIR flexmock(ServiceConfig).should_receive("get_service_config").and_return( config) flexmock(InstallationModel).should_receive("create").once() flexmock(Allowlist).should_receive("add_namespace").with_args( "github.com/packit-service", "jpopelka").and_return(False) flexmock(GithubProject).should_receive("create_issue").once() flexmock(Signature).should_receive("apply_async").once() flexmock(Pushgateway).should_receive("push").once().and_return() processing_results = SteveJobs().process_message(installation_event()) event_dict, job, job_config, package_config = get_parameters_from_results( processing_results) assert json.dumps(event_dict) results = run_installation_handler( package_config=package_config, event=event_dict, job_config=job_config, ) assert first_dict_value(results["job"])["success"]
def test_process_message(event): packit_yaml = { "specfile_path": "bar.spec", "synced_files": [], "jobs": [{"trigger": "release", "job": "propose_downstream"}], } flexmock(Github, get_repo=lambda full_name_or_id: None) flexmock( GithubProject, get_file_content=lambda path, ref: dumps(packit_yaml), full_repo_name="foo/bar", get_files=lambda filter_regex: [], ) flexmock(LocalProject, refresh_the_arguments=lambda: None) config = ServiceConfig() config.command_handler_work_dir = SANDCASTLE_WORK_DIR flexmock(ServiceConfig).should_receive("get_service_config").and_return(config) flexmock(PackitAPI).should_receive("sync_release").with_args( dist_git_branch="master", version="1.2.3" ).once() flexmock(Whitelist, check_and_report=True) flexmock(SteveJobs, _is_private=False) results = SteveJobs().process_message(event) assert "propose_downstream" in results["jobs"] assert results["event"]["trigger"] == "release"
def test_process_message(event): packit_yaml = { "specfile_path": "bar.spec", "synced_files": [], "jobs": [{ "trigger": "release", "job": "propose_downstream" }], } flexmock(Github, get_repo=lambda full_name_or_id: None) flexmock( GithubProject, get_file_content=lambda path, ref: dumps(packit_yaml), full_repo_name="foo/bar", get_files=lambda ref, filter_regex: [], get_sha_from_tag=lambda tag_name: "12345", get_web_url=lambda: "https://github.com/the-namespace/the-repo", is_private=lambda: False, ) flexmock(LocalProject, refresh_the_arguments=lambda: None) config = ServiceConfig() config.command_handler_work_dir = SANDCASTLE_WORK_DIR flexmock(ServiceConfig).should_receive("get_service_config").and_return( config) flexmock(PackitAPI).should_receive("sync_release").with_args( dist_git_branch="master", version="1.2.3").once() flexmock(AddReleaseDbTrigger).should_receive("db_trigger").and_return( flexmock(job_config_trigger_type=JobConfigTriggerType.release)) flexmock(Whitelist, check_and_report=True) results = SteveJobs().process_message(event) j = first_dict_value(results["jobs"]) assert "propose_downstream" in next(iter(results["jobs"])) assert j["success"] assert results["event"]["trigger"] == "release"
def test_dist_git_push_release_handle(github_release_webhook): packit_yaml = ( "{'specfile_path': 'hello-world.spec', 'synced_files': []" ", jobs: [{trigger: release, job: propose_downstream, metadata: {targets:[]}}]}" ) flexmock(Github, get_repo=lambda full_name_or_id: None) project = flexmock( get_file_content=lambda path, ref: packit_yaml, full_repo_name="packit-service/hello-world", repo="hello-world", get_files=lambda ref, filter_regex: [], get_sha_from_tag=lambda tag_name: "123456", get_web_url=lambda: "https://github.com/packit-service/hello-world", is_private=lambda: False, ) flexmock(LocalProject, refresh_the_arguments=lambda: None) flexmock(Whitelist, check_and_report=True) config = ServiceConfig() config.command_handler_work_dir = SANDCASTLE_WORK_DIR config.get_project = lambda url: project flexmock(ServiceConfig).should_receive("get_service_config").and_return(config) # it would make sense to make LocalProject offline flexmock(PackitAPI).should_receive("sync_release").with_args( dist_git_branch="master", version="0.3.0" ).once() flexmock(AddReleaseDbTrigger).should_receive("db_trigger").and_return( flexmock(job_config_trigger_type=JobConfigTriggerType.release) ) results = SteveJobs().process_message(github_release_webhook) assert first_dict_value(results["jobs"])["success"] assert results["event"]["trigger"] == "release"
def test_dist_git_push_release_handle_multiple_branches(release_event): packit_yaml = ("{'specfile_path': 'hello-world.spec', 'synced_files': []" ", jobs: [{trigger: release, job: propose_downstream, " "metadata: {targets:[], dist-git-branch: fedora-all}}]}") flexmock(Github, get_repo=lambda full_name_or_id: None) flexmock( GithubProject, get_file_content=lambda path, ref: packit_yaml, full_repo_name="packit-service/hello-world", get_files=lambda filter_regex: [], ) flexmock(LocalProject, refresh_the_arguments=lambda: None) flexmock(Whitelist, check_and_report=True) flexmock(SteveJobs, _is_private=False) config = ServiceConfig() config.command_handler_work_dir = SANDCASTLE_WORK_DIR flexmock(ServiceConfig).should_receive("get_service_config").and_return( config) # it would make sense to make LocalProject offline flexmock(PackitAPI).should_receive("sync_release").with_args( dist_git_branch="master", version="0.3.0").once() flexmock(PackitAPI).should_receive("sync_release").with_args( dist_git_branch="f32", version="0.3.0").once() flexmock(PackitAPI).should_receive("sync_release").with_args( dist_git_branch="f31", version="0.3.0").once() flexmock(PackitAPI).should_receive("sync_release").with_args( dist_git_branch="f30", version="0.3.0").once() flexmock(FedPKG).should_receive("clone").and_return(None) results = SteveJobs().process_message(release_event) assert results["jobs"]["propose_downstream"]["success"] assert results["event"]["trigger"] == "release"
def build_handler(metadata=None, trigger=None, jobs=None): if not metadata: metadata = { "owner": "nobody", "targets": [ "fedora-29-x86_64", "fedora-30-x86_64", "fedora-31-x86_64", "fedora-rawhide-x86_64", ], } jobs = jobs or [] jobs.append( JobConfig( job=JobType.copr_build, trigger=trigger or JobTriggerType.pull_request, metadata=metadata, )) pkg_conf = PackageConfig(jobs=jobs, downstream_package_name="dummy") event = Parser.parse_pr_event(pull_request()) handler = CoprBuildJobHelper( config=ServiceConfig(), package_config=pkg_conf, project=GitProject("", GitService(), ""), event=event, ) handler._api = PackitAPI(ServiceConfig(), pkg_conf) return handler
def build_helper( event: Union[PullRequestEvent, PullRequestCommentEvent, CoprBuildEvent, PushGitHubEvent, ReleaseEvent, ], metadata=None, trigger=None, jobs=None, ): if not metadata: metadata = { "owner": "nobody", "targets": [ "fedora-29-x86_64", "fedora-30-x86_64", "fedora-31-x86_64", "fedora-rawhide-x86_64", ], } jobs = jobs or [] jobs.append( JobConfig( type=JobType.copr_build, trigger=trigger or JobConfigTriggerType.pull_request, metadata=metadata, )) pkg_conf = PackageConfig(jobs=jobs, downstream_package_name="dummy") handler = CoprBuildJobHelper( config=ServiceConfig(), package_config=pkg_conf, project=GitProject("", GitService(), ""), event=event, ) handler._api = PackitAPI(ServiceConfig(), pkg_conf) return handler
def mock_pr_comment_functionality(request): packit_yaml = ( "{'specfile_path': 'the-specfile.spec', 'synced_files': [], 'jobs': " + str(request.param) + "}" ) flexmock( GithubProject, full_repo_name="packit-service/hello-world", get_file_content=lambda path, ref: packit_yaml, get_files=lambda ref, filter_regex: ["the-specfile.spec"], get_web_url=lambda: "https://github.com/the-namespace/the-repo", ) flexmock(Github, get_repo=lambda full_name_or_id: None) config = ServiceConfig() config.command_handler_work_dir = SANDCASTLE_WORK_DIR flexmock(ServiceConfig).should_receive("get_service_config").and_return(config) trigger = flexmock( job_config_trigger_type=JobConfigTriggerType.pull_request, id=123 ) flexmock(AddPullRequestDbTrigger).should_receive("db_trigger").and_return(trigger) flexmock(PullRequestModel).should_receive("get_by_id").with_args(123).and_return( trigger ) flexmock(LocalProject, refresh_the_arguments=lambda: None) flexmock(Allowlist, check_and_report=True)
def test_pr_test_command_handler(pr_embedded_command_comment_event): jobs = [{ "trigger": "pull_request", "job": "tests", "metadata": { "targets": "fedora-rawhide-x86_64" }, }] packit_yaml = ( "{'specfile_path': 'the-specfile.spec', 'synced_files': [], 'jobs': " + str(jobs) + "}") flexmock( GithubProject, full_repo_name="packit-service/hello-world", get_file_content=lambda path, ref: packit_yaml, get_files=lambda ref, filter_regex: ["the-specfile.spec"], get_web_url=lambda: "https://github.com/the-namespace/the-repo", get_pr=lambda pr_id: flexmock(head_commit="12345"), ) flexmock(Github, get_repo=lambda full_name_or_id: None) config = ServiceConfig() config.command_handler_work_dir = SANDCASTLE_WORK_DIR flexmock(ServiceConfig).should_receive("get_service_config").and_return( config) trigger = flexmock( job_config_trigger_type=JobConfigTriggerType.pull_request, id=123) flexmock(AddPullRequestDbTrigger).should_receive("db_trigger").and_return( trigger) flexmock(PullRequestModel).should_receive("get_by_id").with_args( 123).and_return(trigger) flexmock(LocalProject, refresh_the_arguments=lambda: None) flexmock(Allowlist, check_and_report=True) flexmock(PullRequestModel).should_receive("get_or_create").with_args( pr_id=9, namespace="packit-service", repo_name="hello-world", project_url="https://github.com/packit-service/hello-world", ).and_return( flexmock(id=9, job_config_trigger_type=JobConfigTriggerType.pull_request)) pr_embedded_command_comment_event["comment"]["body"] = "/packit test" flexmock(GithubProject, get_files="foo.spec") flexmock(GithubProject).should_receive("is_private").and_return(False) flexmock(Signature).should_receive("apply_async").once() flexmock(TestingFarmJobHelper).should_receive( "run_testing_farm_on_all").and_return( TaskResults(success=True, details={})) processing_results = SteveJobs().process_message( pr_embedded_command_comment_event) event_dict, job, job_config, package_config = get_parameters_from_results( processing_results) run_testing_farm_handler( package_config=package_config, event=event_dict, job_config=job_config, )
def test_dist_git_push_release_handle_one_failed( github_release_webhook, fedora_branches ): packit_yaml = ( "{'specfile_path': 'hello-world.spec', 'synced_files': []" ", jobs: [{trigger: release, job: propose_downstream, " "metadata: {targets:[], dist-git-branch: fedora-all}}]}" ) flexmock(Github, get_repo=lambda full_name_or_id: None) project = ( flexmock( get_file_content=lambda path, ref: packit_yaml, full_repo_name="packit-service/hello-world", repo="hello-world", get_files=lambda ref, filter_regex: [], get_sha_from_tag=lambda tag_name: "123456", get_web_url=lambda: "https://github.com/packit/hello-world", is_private=lambda: False, ) .should_receive("create_issue") .once() .mock() ) flexmock(LocalProject, refresh_the_arguments=lambda: None) flexmock(Whitelist, check_and_report=True) config = ServiceConfig() config.command_handler_work_dir = SANDCASTLE_WORK_DIR config.get_project = lambda url: project flexmock(ServiceConfig).should_receive("get_service_config").and_return(config) # it would make sense to make LocalProject offline for i, branch in enumerate(fedora_branches): sync_release = ( flexmock(PackitAPI) .should_receive("sync_release") .with_args(dist_git_branch=branch, version="0.3.0") .once() ) if i == 1: sync_release.and_raise(Exception, f"Failed {branch}").once() flexmock(FedPKG).should_receive("clone").and_return(None) flexmock(sentry_integration).should_receive("send_to_sentry").and_return().once() flexmock(AddReleaseDbTrigger).should_receive("db_trigger").and_return( flexmock(job_config_trigger_type=JobConfigTriggerType.release, id=123) ) flexmock(Signature).should_receive("apply_async").once() processing_results = SteveJobs().process_message(github_release_webhook) assert processing_results["details"]["event"]["trigger"] == "release" event_dict, package_config, job = get_parameters_from_results(processing_results) results = run_propose_downstream_handler( package_config=package_config, event=event_dict, job_config=job, ) assert not first_dict_value(results["job"])["success"]
def test_dist_git_push_release_handle_all_failed(github_release_webhook, fedora_branches): packit_yaml = ("{'specfile_path': 'hello-world.spec', 'synced_files': []" ", jobs: [{trigger: release, job: propose_downstream, " "metadata: {targets:[], dist-git-branch: fedora-all}}]}") flexmock(Github, get_repo=lambda full_name_or_id: None) table_content = "" for branch in fedora_branches: table_content += f"| `{branch}` | `Failed` |\n" project = (flexmock( get_file_content=lambda path, ref: packit_yaml, full_repo_name="packit-service/hello-world", repo="hello-world", get_files=lambda ref, filter_regex: [], get_sha_from_tag=lambda tag_name: "123456", get_web_url=lambda: "https://github.com/packit/hello-world", is_private=lambda: False, default_branch="main", ).should_receive("create_issue").with_args( title="[packit] Propose downstream failed for release 0.3.0", body="Packit failed on creating pull-requests in dist-git:\n\n" "| dist-git branch | error |\n" "| --------------- | ----- |\n" f"{table_content}\n\n" "You can retrigger the update by adding a comment (`/packit propose-downstream`)" " into this issue.\n", ).once().mock()) lp = flexmock(LocalProject, refresh_the_arguments=lambda: None) lp.git_project = project flexmock(DistGit).should_receive("local_project").and_return(lp) flexmock(Allowlist, check_and_report=True) config = ServiceConfig() config.command_handler_work_dir = SANDCASTLE_WORK_DIR config.get_project = lambda url: project flexmock(ServiceConfig).should_receive("get_service_config").and_return( config) # it would make sense to make LocalProject offline flexmock(PackitAPI).should_receive("sync_release").and_raise( Exception, "Failed").times(len(fedora_branches)) flexmock(AddReleaseDbTrigger).should_receive("db_trigger").and_return( flexmock(job_config_trigger_type=JobConfigTriggerType.release, id=123)) flexmock(sentry_integration).should_receive( "send_to_sentry").and_return().times(len(fedora_branches)) flexmock(Signature).should_receive("apply_async").once() processing_results = SteveJobs().process_message(github_release_webhook) event_dict, job, job_config, package_config = get_parameters_from_results( processing_results) results = run_propose_downstream_handler( package_config=package_config, event=event_dict, job_config=job_config, ) assert not first_dict_value(results["job"])["success"]
def mock_config(self): service_config = ServiceConfig() service_config.services = { GithubService(token="token"), GitlabService(token="token"), } service_config.dry_run = False service_config.github_requests_log_path = "/path" ServiceConfig.service_config = service_config
def setup_class(cls): service_config = ServiceConfig() service_config.services = { GithubService(token="12345"), PagureService(instance_url="https://git.stg.centos.org", token="6789"), } service_config.dry_run = False service_config.github_requests_log_path = "/path" ServiceConfig.service_config = service_config
def test_process_message(event, private, enabled_private_namespaces, success): packit_yaml = { "specfile_path": "bar.spec", "synced_files": [], "jobs": [{ "trigger": "release", "job": "propose_downstream" }], } flexmock(Github, get_repo=lambda full_name_or_id: None) gh_project = flexmock( GithubProject, get_file_content=lambda path, ref: dumps(packit_yaml), full_repo_name="the-namespace/the-repo", get_files=lambda ref, filter_regex: [], get_sha_from_tag=lambda tag_name: "12345", get_web_url=lambda: "https://github.com/the-namespace/the-repo", is_private=lambda: private, ) gh_project.default_branch = "main" lp = flexmock(LocalProject, refresh_the_arguments=lambda: None) lp.git_project = gh_project flexmock(DistGit).should_receive("local_project").and_return(lp) config = ServiceConfig( enabled_private_namespaces=enabled_private_namespaces) config.command_handler_work_dir = SANDCASTLE_WORK_DIR flexmock(ServiceConfig).should_receive("get_service_config").and_return( config) flexmock(PackitAPI).should_receive("sync_release").with_args( dist_git_branch="main", tag="1.2.3").times(1 if success else 0) flexmock(AddReleaseDbTrigger).should_receive("db_trigger").and_return( flexmock(job_config_trigger_type=JobConfigTriggerType.release, id=1)) flexmock(Allowlist, check_and_report=True) flexmock(Signature).should_receive("apply_async").times( 1 if success else 0) processing_results = SteveJobs().process_message(event) if not success: assert processing_results == [] return event_dict, job, job_config, package_config = get_parameters_from_results( processing_results) results = run_propose_downstream_handler( package_config=package_config, event=event_dict, job_config=job_config, ) assert "propose_downstream" in next(iter(results["job"])) assert first_dict_value(results["job"])["success"]
def f(path: str): """ path points to a file where the http communication will be saved """ conf = ServiceConfig() # TODO: add pagure support # conf._pagure_user_token = os.environ.get("PAGURE_TOKEN", "test") # conf._pagure_fork_token = os.environ.get("PAGURE_FORK_TOKEN", "test") conf._github_token = os.getenv("GITHUB_TOKEN", None) conf.dry_run = True target_path: Path = SAVED_HTTPD_REQS / path target_path.parent.mkdir(parents=True, exist_ok=True) conf.github_requests_log_path = str(target_path) return conf
def test_dont_retry_propose_downstream_task(github_release_webhook): packit_yaml = ( "{'specfile_path': 'hello-world.spec', 'synced_files': []" ", jobs: [{trigger: release, job: propose_downstream, metadata: {targets:[]}}]}" ) flexmock(Github, get_repo=lambda full_name_or_id: None) project = flexmock( get_file_content=lambda path, ref: packit_yaml, full_repo_name="packit-service/hello-world", repo="hello-world", get_files=lambda ref, filter_regex: [], get_sha_from_tag=lambda tag_name: "123456", get_web_url=lambda: "https://github.com/packit/hello-world", is_private=lambda: False, default_branch="main", ) lp = flexmock(LocalProject, refresh_the_arguments=lambda: None) lp.git_project = project flexmock(DistGit).should_receive("local_project").and_return(lp) flexmock(Allowlist, check_and_report=True) config = ServiceConfig() config.command_handler_work_dir = SANDCASTLE_WORK_DIR config.get_project = lambda url: project flexmock(ServiceConfig).should_receive("get_service_config").and_return( config) # it would make sense to make LocalProject offline flexmock(AddReleaseDbTrigger).should_receive("db_trigger").and_return( flexmock(job_config_trigger_type=JobConfigTriggerType.release, id=123)) flexmock(Signature).should_receive("apply_async").once() flexmock(PackitAPI).should_receive("sync_release").with_args( dist_git_branch="main", tag="0.3.0").and_raise( RebaseHelperError, "Failed to download file from URL example.com").once() flexmock(Context, retries=2) flexmock(Task).should_receive("retry").never() flexmock(project).should_receive("create_issue").once() processing_results = SteveJobs().process_message(github_release_webhook) event_dict, job, job_config, package_config = get_parameters_from_results( processing_results) results = run_propose_downstream_handler(event_dict, package_config, job_config) assert not first_dict_value(results["job"])["success"]
def mock_comment(request): project_class, release_class, forge, author = request.param packit_yaml = ( "{'specfile_path': 'packit.spec', 'synced_files': []," "'jobs': [{'trigger': 'release', 'job': 'propose_downstream'," "'metadata': {'dist-git-branch': 'main'}}]," "'downstream_package_name': 'packit'}" ) flexmock( project_class, get_file_content=lambda path, ref: packit_yaml, full_repo_name="packit-service/packit", get_web_url=lambda: f"https://{forge}.com/packit-service/packit", default_branch="main", ) ( flexmock(project_class) .should_receive("can_merge_pr") .with_args(author) .and_return(True) ) issue = flexmock() flexmock(project_class).should_receive("get_issue").and_return(issue) comment = flexmock() flexmock(issue).should_receive("get_comment").and_return(comment) flexmock(comment).should_receive("add_reaction").with_args("+1").once() flexmock(issue).should_receive("close").and_return(issue) gr = release_class( tag_name="0.5.1", url="packit-service/packit", created_at="", tarball_url="https://foo/bar", git_tag=flexmock(GitTag), project=flexmock(project_class), raw_release=flexmock(), ) flexmock(project_class).should_receive("get_latest_release").and_return(gr) config = ServiceConfig() config.command_handler_work_dir = SANDCASTLE_WORK_DIR flexmock(ServiceConfig).should_receive("get_service_config").and_return(config) flexmock(LocalProject, refresh_the_arguments=lambda: None) lp = flexmock(git_project=flexmock(default_branch="main")) lp.working_dir = "" flexmock(DistGit).should_receive("local_project").and_return(lp) flexmock(Allowlist, check_and_report=True) yield project_class, issue_comment_propose_downstream_event(forge)
def build_helper( event: Union[ PullRequestGithubEvent, PullRequestCommentGithubEvent, PushGitHubEvent, ReleaseEvent, ], metadata=None, trigger=None, jobs=None, db_trigger=None, ): if not metadata: metadata = JobMetadataConfig( targets=[ "fedora-29-x86_64", "fedora-30-x86_64", "fedora-31-x86_64", "fedora-rawhide-x86_64", ], owner="nobody", ) jobs = jobs or [] jobs.append( JobConfig( type=JobType.production_build, trigger=trigger or JobConfigTriggerType.pull_request, metadata=metadata, ) ) pkg_conf = PackageConfig(jobs=jobs, downstream_package_name="dummy") handler = KojiBuildJobHelper( service_config=ServiceConfig(), package_config=pkg_conf, job_config=pkg_conf.jobs[0], project=GitProject(repo=flexmock(), service=flexmock(), namespace=flexmock()), metadata=flexmock( trigger=event.trigger, pr_id=event.pr_id, git_ref=event.git_ref, commit_sha=event.commit_sha, identifier=event.identifier, ), db_trigger=db_trigger, ) handler._api = PackitAPI(config=ServiceConfig(), package_config=pkg_conf) return handler
def mock_pr_comment_functionality(): packit_yaml = ("{'specfile_path': '', 'synced_files': []," "'jobs': [{'trigger': 'pull_request', 'job': 'copr_build'," "'metadata': {'targets': 'fedora-rawhide-x86_64'}}]}") flexmock( GithubProject, get_file_content=lambda path, ref: packit_yaml, full_repo_name="packit-service/hello-world", ) flexmock(Github, get_repo=lambda full_name_or_id: None) flexmock(GithubProject).should_receive("who_can_merge_pr").and_return( {"phracek"}) flexmock(GithubProject).should_receive("get_all_pr_commits").with_args( 9).and_return(["528b803be6f93e19ca4130bf4976f2800a3004c4"]) config = ServiceConfig() config.command_handler_work_dir = SANDCASTLE_WORK_DIR flexmock(ServiceConfig).should_receive("get_service_config").and_return( config) copr_dict = { "login": "******", "username": "******", "token": "apple", "copr_url": "https://copr.fedorainfracloud.org", } flexmock(CoprClient).should_receive("create_from_config_file").and_return( CoprClient(copr_dict)) flexmock(LocalProject, refresh_the_arguments=lambda: None) flexmock(Whitelist, check_and_report=True)
def test_parse_optional_values(service_config_valid): """When optional values are set, they are correctly parsed""" config = ServiceConfig.get_from_dict({ **service_config_valid, "testing_farm_api_url": "https://other.url" }) assert config.testing_farm_api_url == "https://other.url"
def get_test_check(cls, chroot: str = None) -> str: config = ServiceConfig.get_service_config() deployment_str = ( "packit" if config.deployment == Deployment.prod else "packit-stg" ) chroot_str = f"-{chroot}" if chroot else "" return f"{deployment_str}/{cls.status_name_test}{chroot_str}"
def test_parse_valid(service_config_valid): config = ServiceConfig.get_from_dict(service_config_valid) assert config.debug assert config.deployment == Deployment.prod assert config.fas_user == "santa" assert config.fas_password == "does-not-exist" assert config.keytab_path == "/secrets/fedora.keytab" assert config.webhook_secret == "secret" assert config.validate_webhooks assert config.testing_farm_secret == "granko" assert config.testing_farm_api_url == TESTING_FARM_API_URL assert config.bugzilla_url == "https://ladybug-zilla" assert config.bugzilla_api_key == "ratamahatta" assert config.bugz_namespaces == {"^magic/namespace"} assert config.bugz_branches == {"^onlythis$"} assert config.command_handler_work_dir == "/tmp/sandcastle" assert config.admins == {"Dasher", "Dancer", "Vixen", "Comet", "Blitzen"} assert config.server_name == "hub.packit.org" assert config.gitlab_token_secret == "jwt_secret" assert len(config.gitlab_mr_targets_handled) == 3 assert (MRTarget("redhat/centos-stream/src/.+", "c9s") in config.gitlab_mr_targets_handled) assert MRTarget("packit-service/src/.+", None) in config.gitlab_mr_targets_handled assert MRTarget(None, "rawhide") in config.gitlab_mr_targets_handled assert config.enabled_private_namespaces == { "gitlab.com/private/namespace", "github.com/other-private-namespace", }
def get_flask_application(): # Sentry does not work in the service for now # SENTRY_SECRET is not passed to the service pod or container # https://github.com/packit-service/deployment/blob/master/openshift/packit-service.yml.j2 # configure_sentry( # runner_type="packit-service", # celery_integration=True, # sqlalchemy_integration=True, # flask_integration=True, # ) app = Flask(__name__) app.register_blueprint(blueprint) app.register_blueprint(builds_blueprint) s = ServiceConfig.get_service_config() # https://flask.palletsprojects.com/en/1.1.x/config/#SERVER_NAME # also needs to contain port if it's not 443 app.config["SERVER_NAME"] = s.server_name app.config["PREFERRED_URL_SCHEME"] = "https" if getenv("DEPLOYMENT") in ("dev", "stg"): app.config["DEBUG"] = True app.logger.setLevel(logging.DEBUG) logger = logging.getLogger("packit_service") logger.info( f"server name = {s.server_name}, all HTTP requests need to use this URL!" ) log_service_versions() # no need to thank me, just buy me a beer logger.debug(f"URL map = {app.url_map}") return app
def get_project(self) -> Optional[GitProject]: if not (self.project_url or self.db_trigger): return None return ServiceConfig.get_service_config().get_project( url=self.project_url or self.db_trigger.project.project_url )
def get_request_details(cls, request_id: str) -> Dict[str, Any]: """Testing Farm sends only request/pipeline id in a notification. We need to get more details ourselves.""" self = cls( service_config=ServiceConfig.get_service_config(), package_config=PackageConfig(), project=None, metadata=None, db_trigger=None, job_config=JobConfig( # dummy values to be able to construct the object type=JobType.tests, trigger=JobConfigTriggerType.pull_request, ), ) response = self.send_testing_farm_request( endpoint=f"requests/{request_id}", method="GET" ) if not response or response.status_code != 200: msg = f"Failed to get request/pipeline {request_id} details from TF. {response.reason}" logger.error(msg) return {} details = response.json() # logger.debug(f"Request/pipeline {request_id} details: {details}") return details
def get_flask_application(): configure_sentry( runner_type="packit-service", celery_integration=True, sqlalchemy_integration=True, flask_integration=True, ) app = Flask(__name__) app.register_blueprint(blueprint) app.register_blueprint(builds_blueprint) s = ServiceConfig.get_service_config() # https://flask.palletsprojects.com/en/1.1.x/config/#SERVER_NAME # also needs to contain port if it's not 443 app.config["SERVER_NAME"] = s.server_name app.config["PREFERRED_URL_SCHEME"] = "https" if getenv("DEPLOYMENT") in ("dev", "stg"): app.config["DEBUG"] = True app.logger.setLevel(logging.DEBUG) logger = logging.getLogger("packit_service") logger.info( f"server name = {s.server_name}, all HTTP requests need to use this URL!" ) log_service_versions() # no need to thank me, just buy me a beer logger.debug(f"URL map = {app.url_map}") return app
def test_copr_build_check_names(pull_request_event): flexmock(AddPullRequestDbTrigger).should_receive("db_trigger").and_return( flexmock(job_config_trigger_type=JobConfigTriggerType.release) ) helper = build_helper( event=pull_request_event, metadata=JobMetadataConfig(targets=["bright-future-x86_64"], owner="nobody"), ) flexmock(StatusReporter).should_receive("set_status").with_args( state=CommitStatus.pending, description="Building SRPM ...", check_name="packit-stg/rpm-build-bright-future-x86_64", url="", ).and_return() flexmock(StatusReporter).should_receive("set_status").with_args( state=CommitStatus.pending, description="Building RPM ...", check_name="packit-stg/rpm-build-bright-future-x86_64", url="https://localhost:5000/copr-build/1/logs", ).and_return() flexmock(GitProject).should_receive("set_commit_status").and_return().never() flexmock(SRPMBuildModel).should_receive("create").and_return(SRPMBuildModel()) flexmock(CoprBuildModel).should_receive("get_or_create").and_return( CoprBuildModel(id=1) ) flexmock(PullRequestEvent).should_receive("db_trigger").and_return(flexmock()) flexmock(PackitAPI).should_receive("run_copr_build").and_return(1, None) flexmock(Celery).should_receive("send_task").once() config = ServiceConfig.get_service_config() config.disable_sentry = True assert helper.run_copr_build()["success"]
def test_downstream_koji_build(): packit_yaml = ( "{'specfile_path': 'buildah.spec', 'synced_files': []," "'jobs': [{'trigger': 'commit', 'job': 'koji_build'}]," "'downstream_package_name': 'buildah'}" ) pagure_project = flexmock( PagureProject, full_repo_name="rpms/buildah", get_web_url=lambda: "https://src.fedoraproject.org/rpms/buildah", default_branch="main", ) pagure_project.should_receive("get_files").with_args( ref="abcd", filter_regex=r".+\.spec$" ).and_return(["buildah.spec"]) pagure_project.should_receive("get_file_content").with_args( path=".distro/source-git.yaml", ref="abcd" ).and_raise(FileNotFoundError, "Not found.") pagure_project.should_receive("get_file_content").with_args( path=".packit.yaml", ref="abcd" ).and_return(packit_yaml) flexmock(GitBranchModel).should_receive("get_or_create").with_args( branch_name="main", namespace="rpms", repo_name="buildah", project_url="https://src.fedoraproject.org/rpms/buildah", ).and_return(flexmock(id=9, job_config_trigger_type=JobConfigTriggerType.commit)) flexmock(ServiceConfig).should_receive("get_service_config").and_return( ServiceConfig( command_handler_work_dir=SANDCASTLE_WORK_DIR, repository_cache="/tmp/repository-cache", add_repositories_to_repository_cache=False, ) ) flexmock(LocalProject, refresh_the_arguments=lambda: None) flexmock(RepositoryCache).should_call("__init__").once() flexmock(Signature).should_receive("apply_async").once() flexmock(Pushgateway).should_receive("push").once().and_return() flexmock(PackitAPI).should_receive("build").with_args( dist_git_branch="main", scratch=False, nowait=True, from_upstream=False, ) processing_results = SteveJobs().process_message(distgit_commit_event()) event_dict, job, job_config, package_config = get_parameters_from_results( processing_results ) assert json.dumps(event_dict) results = run_downstream_koji_build( package_config=package_config, event=event_dict, job_config=job_config, ) assert first_dict_value(results["job"])["success"]