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"]
