def test_copr_project_and_namespace(
jobs,
job_config_trigger_type,
tag_name,
job_owner,
job_project,
):
copr_build_helper = CoprBuildJobHelper(
service_config=flexmock(deployment="stg"),
package_config=PackageConfig(jobs=jobs),
job_config=jobs[0], # BuildHelper looks at all jobs in the end
project=flexmock(
namespace="the/example/namespace",
repo="the-example-repo",
service=flexmock(instance_url="https://git.instance.io"),
),
metadata=flexmock(pr_id=None,
identifier="the-event-identifier",
tag_name=tag_name),
db_trigger=flexmock(job_config_trigger_type=job_config_trigger_type),
)
copr_build_helper._api = flexmock(copr_helper=flexmock(
copr_client=flexmock(config={"username": "******"})))
assert copr_build_helper.job_project == job_project
assert copr_build_helper.job_owner == job_owner
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
class CoprBuildStartHandler(FedmsgHandler):
topic = "org.fedoraproject.prod.copr.build.start"
name = JobType.copr_build_started
def __init__(self, config: ServiceConfig, job: JobConfig,
event: CoprBuildEvent):
super().__init__(config=config, job=job, event=event)
self.project = self.event.get_project()
self.package_config = self.event.get_package_config()
self.build_job_helper = CoprBuildJobHelper(
config=self.config,
package_config=self.package_config,
project=self.project,
event=event,
)
def run(self):
if self.event.chroot == "srpm-builds":
# we don't want to set the check status for this
msg = "SRPM build in copr has started"
logger.debug(msg)
return HandlerResults(success=True, details={"msg": msg})
# TODO: drop the code below once we move to PG completely; the build is present in event
# pg
build_pg = CoprBuild.get_by_build_id(str(self.event.build_id),
self.event.chroot)
if not build_pg:
logger.info(
f"build {self.event.build_id} is not in pg, falling back to redis"
)
# redis - old school
build = CoprBuildDB().get_build(self.event.build_id)
if not build:
# TODO: how could this happen?
msg = f"Copr build {self.event.build_id} not in CoprBuildDB"
logger.warning(msg)
return HandlerResults(success=False, details={"msg": msg})
status = "pending"
if build_pg:
url = get_log_url(build_pg.id)
build_pg.set_status(status)
copr_build_logs = get_copr_build_logs_url(self.event)
build_pg.set_build_logs_url(copr_build_logs)
else:
url = copr_url_from_event(self.event)
self.build_job_helper.report_status_to_all_for_chroot(
description="RPM build has started...",
state=status,
url=url,
chroot=self.event.chroot,
)
msg = f"Build on {self.event.chroot} in copr has started..."
return HandlerResults(success=True, details={"msg": msg})
def __init__(self, config: ServiceConfig, job: JobConfig,
event: CoprBuildEvent):
super().__init__(config=config, job=job, event=event)
self.project = self.event.get_project()
self.package_config = self.event.get_package_config()
self.build_job_helper = CoprBuildJobHelper(
config=self.config,
package_config=self.package_config,
project=self.project,
event=event,
)
class CoprBuildStartHandler(FedmsgHandler):
topic = "org.fedoraproject.prod.copr.build.start"
triggers = [TheJobTriggerType.copr_start]
def __init__(
self,
config: ServiceConfig,
job_config: Optional[JobConfig],
event: CoprBuildEvent,
):
super().__init__(config=config, job_config=job_config, event=event)
self.project = self.event.get_project()
self.package_config = self.event.get_package_config()
self.build_job_helper = CoprBuildJobHelper(
config=self.config,
package_config=self.package_config,
project=self.project,
event=event,
)
def run(self):
if self.event.chroot == "srpm-builds":
# we don't want to set the check status for this
msg = "SRPM build in copr has started"
logger.debug(msg)
return HandlerResults(success=True, details={"msg": msg})
# TODO: drop the code below once we move to PG completely; the build is present in event
# pg
build = CoprBuildModel.get_by_build_id(str(self.event.build_id),
self.event.chroot)
if not build:
msg = f"Copr build {self.event.build_id} not in CoprBuildDB"
logger.warning(msg)
return HandlerResults(success=False, details={"msg": msg})
url = get_log_url(build.id)
build.set_status("pending")
copr_build_logs = get_copr_build_logs_url(self.event)
build.set_build_logs_url(copr_build_logs)
self.build_job_helper.report_status_to_all_for_chroot(
description="RPM build has started...",
state=CommitStatus.pending,
url=url,
chroot=self.event.chroot,
)
msg = f"Build on {self.event.chroot} in copr has started..."
return HandlerResults(success=True, details={"msg": msg})
def test_copr_build_not_comment_on_success(copr_build_end, pc_build_pr,
copr_build_pr):
steve = SteveJobs()
flexmock(GithubProject).should_receive("is_private").and_return(False)
flexmock(CoprBuildEvent).should_receive("get_package_config").and_return(
pc_build_pr)
flexmock(CoprBuildJobHelper).should_receive("get_build_check").and_return(
EXPECTED_BUILD_CHECK_NAME)
flexmock(CoprBuildEndHandler).should_receive(
"was_last_packit_comment_with_congratulation").and_return(True)
flexmock(GithubProject).should_receive("pr_comment").never()
flexmock(CoprBuildModel).should_receive("get_by_build_id").and_return(
copr_build_pr)
copr_build_pr.should_receive("set_status").with_args("success")
copr_build_pr.should_receive("set_end_time").once()
url = get_copr_build_log_url_from_flask(1)
flexmock(requests).should_receive("get").and_return(requests.Response())
flexmock(
requests.Response).should_receive("raise_for_status").and_return(None)
# check if packit-service set correct PR status
flexmock(StatusReporter).should_receive("report").with_args(
state=CommitStatus.success,
description="RPMs were built successfully.",
url=url,
check_names=CoprBuildJobHelper.get_build_check(
copr_build_end["chroot"]),
).once()
# skip testing farm
flexmock(CoprBuildJobHelper).should_receive("job_tests").and_return(None)
steve.process_message(copr_build_end)
def build_helper(
event, metadata=None, trigger=None, jobs=None, db_trigger=None, selected_job=None
):
if jobs and metadata:
raise Exception("Only one of jobs and metadata can be used.")
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 [
JobConfig(
type=JobType.copr_build,
trigger=trigger or JobConfigTriggerType.pull_request,
metadata=metadata,
)
]
pkg_conf = PackageConfig(jobs=jobs, downstream_package_name="dummy")
handler = CoprBuildJobHelper(
service_config=ServiceConfig(),
package_config=pkg_conf,
job_config=selected_job or jobs[0],
project=GitProject(
repo="the-example-repo",
service=flexmock(),
namespace="the-example-namespace",
),
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(ServiceConfig(), pkg_conf)
return handler
def set_srpm_url(self, build_job_helper: CoprBuildJobHelper) -> None:
if self.build.srpm_build.url is not None:
# URL has been already set
return
srpm_url = build_job_helper.get_build(
self.copr_event.build_id
).source_package.get("url")
self.build.srpm_build.set_url(srpm_url)
def test_copr_build_not_comment_on_success(copr_build_end, pc_build_pr,
copr_build):
steve = SteveJobs()
flexmock(SteveJobs, _is_private=False)
flexmock(CoprHelper).should_receive("get_copr_client").and_return(
Client(
config={
"copr_url": "https://copr.fedorainfracloud.org",
"username": "******",
}))
flexmock(CoprBuildJobHelper).should_receive("copr_build_model").and_return(
flexmock())
flexmock(CoprBuildEvent).should_receive("get_package_config").and_return(
pc_build_pr)
flexmock(CoprBuildJobHelper).should_receive("get_build_check").and_return(
EXPECTED_BUILD_CHECK_NAME)
flexmock(CoprBuildEndHandler).should_receive(
"was_last_build_successful").and_return(True)
flexmock(GithubProject).should_receive("pr_comment").never()
flexmock(CoprBuild).should_receive("get_by_build_id").and_return(
copr_build)
flexmock(CoprBuild).should_receive("set_status").with_args("success")
flexmock(CoprBuildDB).should_receive("get_build").and_return({
"commit_sha":
"XXXXX",
"pr_id":
24,
"repo_name":
"hello-world",
"repo_namespace":
"packit-service",
"ref":
"XXXX",
"https_url":
"https://github.com/packit-service/hello-world",
})
url = get_log_url(1)
flexmock(requests).should_receive("get").and_return(requests.Response())
flexmock(
requests.Response).should_receive("raise_for_status").and_return(None)
# check if packit-service set correct PR status
flexmock(StatusReporter).should_receive("report").with_args(
state=CommitStatus.success,
description="RPMs were built successfully.",
url=url,
check_names=CoprBuildJobHelper.get_build_check(
copr_build_end["chroot"]),
).once()
# skip testing farm
flexmock(CoprBuildJobHelper).should_receive("job_tests").and_return(None)
steve.process_message(copr_build_end)
def run(self):
build_job_helper = CoprBuildJobHelper(
config=self.config,
package_config=self.event.package_config,
project=self.event.project,
event=self.event,
)
if self.event.chroot == "srpm-builds":
# we don't want to set the check status for this
msg = "SRPM build in copr has started."
logger.debug(msg)
return HandlerResults(success=True, details={"msg": msg})
# TODO: drop the code below once we move to PG completely; the build is present in event
# pg
build = CoprBuildModel.get_by_build_id(
str(self.event.build_id), self.event.chroot
)
if not build:
msg = f"Copr build {self.event.build_id} not in CoprBuildDB."
logger.warning(msg)
return HandlerResults(success=False, details={"msg": msg})
start_time = (
datetime.utcfromtimestamp(self.event.timestamp)
if self.event.timestamp
else None
)
build.set_start_time(start_time)
url = get_copr_build_log_url_from_flask(build.id)
build.set_status("pending")
copr_build_logs = get_copr_build_logs_url(self.event)
build.set_build_logs_url(copr_build_logs)
build_job_helper.report_status_to_all_for_chroot(
description="RPM build is in progress...",
state=CommitStatus.pending,
url=url,
chroot=self.event.chroot,
)
msg = f"Build on {self.event.chroot} in copr has started..."
return HandlerResults(success=True, details={"msg": msg})
def test_copr_build_not_comment_on_success(copr_build_end, pc_build_pr,
copr_build_pr):
flexmock(GithubProject).should_receive("is_private").and_return(False)
flexmock(GithubProject).should_receive("get_pr").and_return(
flexmock(source_project=flexmock()).should_receive("comment").never())
flexmock(AbstractCoprBuildEvent).should_receive(
"get_package_config").and_return(pc_build_pr)
flexmock(CoprBuildJobHelper).should_receive("get_build_check").and_return(
EXPECTED_BUILD_CHECK_NAME)
flexmock(CoprBuildEndHandler).should_receive(
"was_last_packit_comment_with_congratulation").and_return(True)
flexmock(CoprBuildModel).should_receive("get_by_build_id").and_return(
copr_build_pr)
copr_build_pr.should_call("set_status").with_args("success").once()
copr_build_pr.should_receive("set_end_time").once()
url = get_copr_build_info_url(1)
flexmock(requests).should_receive("get").and_return(requests.Response())
flexmock(
requests.Response).should_receive("raise_for_status").and_return(None)
# check if packit-service set correct PR status
flexmock(StatusReporter).should_receive("report").with_args(
state=BaseCommitStatus.success,
description="RPMs were built successfully.",
url=url,
check_names=CoprBuildJobHelper.get_build_check(
copr_build_end["chroot"]),
markdown_content=None,
).once()
# skip testing farm
flexmock(CoprBuildJobHelper).should_receive(
"get_built_packages").and_return([])
flexmock(CoprBuildJobHelper).should_receive("job_tests").and_return(None)
flexmock(Signature).should_receive("apply_async").once()
flexmock(Pushgateway).should_receive("push").once().and_return()
# skip SRPM url since it touches multiple classes
flexmock(CoprBuildEndHandler).should_receive("set_srpm_url").and_return(
None)
processing_results = SteveJobs().process_message(copr_build_end)
event_dict, job, job_config, package_config = get_parameters_from_results(
processing_results)
assert json.dumps(event_dict)
run_copr_build_end_handler(
package_config=package_config,
event=event_dict,
job_config=job_config,
)
def run(self):
build_job_helper = CoprBuildJobHelper(
service_config=self.service_config,
package_config=self.package_config,
project=self.project,
metadata=self.data,
db_trigger=self.db_trigger,
job_config=self.job_config,
)
if self.copr_event.chroot == "srpm-builds":
# we don't want to set the check status for this
msg = "SRPM build in copr has started."
logger.debug(msg)
return TaskResults(success=True, details={"msg": msg})
if not self.build:
msg = f"Copr build {self.copr_event.build_id} not in CoprBuildDB."
logger.warning(msg)
return TaskResults(success=False, details={"msg": msg})
start_time = (
datetime.utcfromtimestamp(self.copr_event.timestamp)
if self.copr_event.timestamp
else None
)
self.build.set_start_time(start_time)
url = get_copr_build_info_url_from_flask(self.build.id)
self.build.set_status("pending")
copr_build_logs = self.copr_event.get_copr_build_logs_url()
self.build.set_build_logs_url(copr_build_logs)
build_job_helper.report_status_to_all_for_chroot(
description="RPM build is in progress...",
state=CommitStatus.pending,
url=url,
chroot=self.copr_event.chroot,
)
msg = f"Build on {self.copr_event.chroot} in copr has started..."
return TaskResults(success=True, details={"msg": msg})
def test_targets(jobs, trigger, build_targets, test_targets):
copr_build_handler = CoprBuildJobHelper(
config=flexmock(),
package_config=PackageConfig(jobs=jobs),
project=flexmock(),
event=flexmock(trigger=trigger),
)
assert copr_build_handler.package_config.jobs
assert [j.type for j in copr_build_handler.package_config.jobs]
assert set(copr_build_handler.build_chroots) == build_targets
assert set(copr_build_handler.tests_chroots) == test_targets
def build_helper(
event: Union[PullRequestGithubEvent, PullRequestCommentGithubEvent,
CoprBuildEvent, PushGitHubEvent, ReleaseEvent, ],
metadata=None,
trigger=None,
jobs=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.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(
repo="the-example-repo",
service=flexmock(),
namespace="the-example-namespace",
),
event=event,
)
handler._api = PackitAPI(ServiceConfig(), pkg_conf)
return handler
def test_copr_build_end(
copr_build_end,
pc_build_pr,
copr_build_pr,
pc_comment_pr_succ,
pr_comment_called,
):
flexmock(GithubProject).should_receive("is_private").and_return(False)
flexmock(GithubProject).should_receive("get_pr").and_return(
flexmock(source_project=flexmock())
)
pc_build_pr.jobs[0].notifications.pull_request.successful_build = pc_comment_pr_succ
flexmock(AbstractCoprBuildEvent).should_receive("get_package_config").and_return(
pc_build_pr
)
flexmock(CoprBuildEndHandler).should_receive(
"was_last_packit_comment_with_congratulation"
).and_return(False)
if pr_comment_called:
flexmock(GithubProject).should_receive("pr_comment")
else:
flexmock(GithubProject).should_receive("pr_comment").never()
flexmock(CoprBuildModel).should_receive("get_by_build_id").and_return(copr_build_pr)
copr_build_pr.should_receive("set_status").with_args("success")
copr_build_pr.should_receive("set_end_time").once()
url = get_copr_build_info_url_from_flask(1)
flexmock(requests).should_receive("get").and_return(requests.Response())
flexmock(requests.Response).should_receive("raise_for_status").and_return(None)
# check if packit-service set correct PR status
flexmock(StatusReporter).should_receive("report").with_args(
state=CommitStatus.success,
description="RPMs were built successfully.",
url=url,
check_names=CoprBuildJobHelper.get_build_check(copr_build_end["chroot"]),
).once()
# no test job defined => testing farm should be skipped
flexmock(TestingFarmJobHelper).should_receive("run_testing_farm").times(0)
flexmock(Signature).should_receive("apply_async").once()
processing_results = SteveJobs().process_message(copr_build_end)
event_dict, job, job_config, package_config = get_parameters_from_results(
processing_results
)
run_copr_build_end_handler(
package_config=package_config,
event=event_dict,
job_config=job_config,
)
def test_targets(jobs, job_config_trigger_type, build_chroots, test_chroots):
copr_build_helper = CoprBuildJobHelper(
service_config=flexmock(),
package_config=PackageConfig(jobs=jobs),
job_config=jobs[0], # BuildHelper looks at all jobs in the end
project=flexmock(),
metadata=flexmock(pr_id=None),
db_trigger=flexmock(job_config_trigger_type=job_config_trigger_type),
)
assert copr_build_helper.package_config.jobs
assert [j.type for j in copr_build_helper.package_config.jobs]
assert copr_build_helper.configured_build_targets == build_chroots
assert copr_build_helper.configured_tests_targets == test_chroots
def test_copr_build_end_push(copr_build_end, pc_build_push, copr_build_branch_push):
flexmock(GithubProject).should_receive("is_private").and_return(False)
flexmock(GithubProject).should_receive("get_pr").and_return(
flexmock(source_project=flexmock())
)
flexmock(AbstractCoprBuildEvent).should_receive("get_package_config").and_return(
pc_build_push
)
flexmock(CoprBuildEndHandler).should_receive(
"was_last_packit_comment_with_congratulation"
).and_return(False)
# we cannot comment for branch push events
flexmock(GithubProject).should_receive("pr_comment").never()
flexmock(CoprBuildModel).should_receive("get_by_build_id").and_return(
copr_build_branch_push
)
copr_build_branch_push.should_receive("set_status").with_args("success")
copr_build_branch_push.should_receive("set_end_time").once()
url = get_copr_build_info_url_from_flask(1)
flexmock(requests).should_receive("get").and_return(requests.Response())
flexmock(requests.Response).should_receive("raise_for_status").and_return(None)
# check if packit-service set correct PR status
flexmock(StatusReporter).should_receive("report").with_args(
state=CommitStatus.success,
description="RPMs were built successfully.",
url=url,
check_names=CoprBuildJobHelper.get_build_check(copr_build_end["chroot"]),
).once()
# skip testing farm
flexmock(CoprBuildJobHelper).should_receive("job_tests").and_return(None)
flexmock(Signature).should_receive("apply_async").once()
processing_results = SteveJobs().process_message(copr_build_end)
event_dict, job, job_config, package_config = get_parameters_from_results(
processing_results
)
run_copr_build_end_handler(
package_config=package_config,
event=event_dict,
job_config=job_config,
)
def test_targets(jobs, trigger, job_config_trigger_type, build_chroots,
test_chroots):
copr_build_handler = CoprBuildJobHelper(
config=flexmock(),
package_config=PackageConfig(jobs=jobs),
project=flexmock(),
event=flexmock(
trigger=trigger,
db_trigger=flexmock(
job_config_trigger_type=job_config_trigger_type),
pr_id=None,
),
)
assert copr_build_handler.package_config.jobs
assert [j.type for j in copr_build_handler.package_config.jobs]
assert copr_build_handler.build_targets == build_chroots
assert copr_build_handler.tests_targets == test_chroots
def test_targets(jobs, trigger, job_config_trigger_type, build_chroots,
test_chroots):
copr_build_handler = CoprBuildJobHelper(
service_config=flexmock(),
package_config=PackageConfig(jobs=jobs),
job_config=jobs[0], # BuildHelper looks at all jobs in the end
project=flexmock(),
metadata=flexmock(trigger=trigger, pr_id=None),
db_trigger=flexmock(job_config_trigger_type=job_config_trigger_type),
)
flexmock(packit_service.worker.build.copr_build).should_receive(
"get_build_targets").and_return(build_chroots).and_return(test_chroots)
assert copr_build_handler.package_config.jobs
assert [j.type for j in copr_build_handler.package_config.jobs]
assert copr_build_handler.build_targets == build_chroots
assert copr_build_handler.tests_targets == test_chroots
def test_copr_targets_overrides(jobs, job_config_trigger_type,
targets_override, build_targets, test_targets):
copr_build_helper = CoprBuildJobHelper(
service_config=flexmock(),
package_config=PackageConfig(jobs=jobs),
job_config=jobs[0], # BuildHelper looks at all jobs in the end
project=flexmock(),
metadata=flexmock(pr_id=None),
db_trigger=flexmock(job_config_trigger_type=job_config_trigger_type),
targets_override=targets_override,
)
flexmock(copr_build).should_receive("get_valid_build_targets").with_args(
"fedora-31", "fedora-32", default=None).and_return(STABLE_CHROOTS)
flexmock(copr_build).should_receive("get_valid_build_targets").with_args(
"fedora-32", "fedora-31", default=None).and_return(STABLE_CHROOTS)
flexmock(copr_build).should_receive("get_valid_build_targets").with_args(
default=None).and_return(set())
assert copr_build_helper.build_targets == build_targets
assert copr_build_helper.tests_targets == test_targets
def test_local_project_not_called_when_initializing_api():
jobs = [
JobConfig(
type=JobType.copr_build,
trigger=JobConfigTriggerType.pull_request,
metadata=JobMetadataConfig(),
)
]
copr_build_helper = CoprBuildJobHelper(
service_config=flexmock(use_stage=lambda: False),
package_config=PackageConfig(jobs=jobs),
job_config=jobs[0],
project=flexmock(),
metadata=flexmock(pr_id=1),
db_trigger=flexmock(
job_config_trigger_type=JobConfigTriggerType.pull_request),
)
flexmock(LocalProject).should_receive("__init__").never()
assert copr_build_helper.api
assert copr_build_helper.api.copr_helper
def test_repository_cache_invocation():
copr_build_helper = CoprBuildJobHelper(
service_config=flexmock(
repository_cache="/tmp/repository-cache",
add_repositories_to_repository_cache=False,
command_handler_work_dir="/tmp/some-dir",
),
package_config=PackageConfig(jobs=[
JobConfig(
type=JobType.copr_build,
trigger=JobConfigTriggerType.pull_request,
metadata=JobMetadataConfig(_targets=STABLE_VERSIONS),
)
], ),
job_config=JobConfig(
type=JobType.copr_build,
trigger=JobConfigTriggerType.pull_request,
metadata=JobMetadataConfig(_targets=STABLE_VERSIONS),
),
project=flexmock(
service=flexmock(),
get_git_urls=lambda:
{"git": "https://github.com/some-namespace/some-repo.git"},
repo=flexmock(),
namespace=flexmock(),
),
metadata=flexmock(pr_id=None, git_ref=flexmock()),
db_trigger=flexmock(
job_config_trigger_type=JobConfigTriggerType.pull_request),
)
flexmock(RepositoryCache).should_call("__init__").once()
flexmock(RepositoryCache).should_receive("get_repo").with_args(
"https://github.com/some-namespace/some-repo.git",
directory=Path("/tmp/some-dir"),
).and_return(
flexmock(
git=flexmock().should_receive("checkout").and_return().mock(),
commit=lambda: "commit",
)).once()
assert copr_build_helper.local_project
def test_build_handler_job_and_test_properties(
jobs,
init_job,
job_config_trigger_type,
result_job_build,
result_job_tests,
):
copr_build_helper = CoprBuildJobHelper(
service_config=flexmock(),
package_config=PackageConfig(jobs=jobs),
job_config=init_job,
project=flexmock(),
metadata=flexmock(pr_id=None),
db_trigger=flexmock(job_config_trigger_type=job_config_trigger_type),
)
assert copr_build_helper.package_config.jobs
assert [j.type for j in copr_build_helper.package_config.jobs]
assert copr_build_helper.job_build == result_job_build
assert copr_build_helper.job_tests == result_job_tests
def test_copr_build_end(copr_build_end, pc_build_pr, copr_build_pr,
pc_comment_pr_succ, pr_comment_called):
steve = SteveJobs()
flexmock(SteveJobs, _is_private=False)
flexmock(CoprHelper).should_receive("get_copr_client").and_return(
Client(
config={
"copr_url": "https://copr.fedorainfracloud.org",
"username": "******",
}))
pc_build_pr.notifications.pull_request.successful_build = pc_comment_pr_succ
flexmock(CoprBuildEvent).should_receive("get_package_config").and_return(
pc_build_pr)
flexmock(CoprBuildEndHandler).should_receive(
"was_last_build_successful").and_return(False)
if pr_comment_called:
flexmock(GithubProject).should_receive("pr_comment")
else:
flexmock(GithubProject).should_receive("pr_comment").never()
flexmock(CoprBuildModel).should_receive("get_by_build_id").and_return(
copr_build_pr)
copr_build_pr.should_receive("set_status").with_args("success")
url = get_log_url(1)
flexmock(requests).should_receive("get").and_return(requests.Response())
flexmock(
requests.Response).should_receive("raise_for_status").and_return(None)
# check if packit-service set correct PR status
flexmock(StatusReporter).should_receive("report").with_args(
state=CommitStatus.success,
description="RPMs were built successfully.",
url=url,
check_names=CoprBuildJobHelper.get_build_check(
copr_build_end["chroot"]),
).once()
# skip testing farm
flexmock(CoprBuildJobHelper).should_receive("job_tests").and_return(None)
steve.process_message(copr_build_end)
def run(self):
build_job_helper = CoprBuildJobHelper(
config=self.config,
package_config=self.event.package_config,
project=self.event.project,
event=self.event,
)
if self.event.chroot == "srpm-builds":
# we don't want to set check for this
msg = "SRPM build in copr has finished."
logger.debug(msg)
return HandlerResults(success=True, details={"msg": msg})
build = CoprBuildModel.get_by_build_id(
str(self.event.build_id), self.event.chroot
)
if not build:
# TODO: how could this happen?
msg = f"Copr build {self.event.build_id} not in CoprBuildDB."
logger.warning(msg)
return HandlerResults(success=False, details={"msg": msg})
if build.status in [
PG_COPR_BUILD_STATUS_FAILURE,
PG_COPR_BUILD_STATUS_SUCCESS,
]:
msg = (
f"Copr build {self.event.build_id} is already"
f" processed (status={build.status})."
)
logger.info(msg)
return HandlerResults(success=True, details={"msg": msg})
end_time = (
datetime.utcfromtimestamp(self.event.timestamp)
if self.event.timestamp
else None
)
build.set_end_time(end_time)
url = get_copr_build_log_url_from_flask(build.id)
# https://pagure.io/copr/copr/blob/master/f/common/copr_common/enums.py#_42
if self.event.status != COPR_API_SUCC_STATE:
failed_msg = "RPMs failed to be built."
build_job_helper.report_status_to_all_for_chroot(
state=CommitStatus.failure,
description=failed_msg,
url=url,
chroot=self.event.chroot,
)
build.set_status(PG_COPR_BUILD_STATUS_FAILURE)
return HandlerResults(success=False, details={"msg": failed_msg})
if (
build_job_helper.job_build
and build_job_helper.job_build.trigger == JobConfigTriggerType.pull_request
and self.event.pr_id
and isinstance(self.event.project, GithubProject)
and not self.was_last_packit_comment_with_congratulation()
and self.event.package_config.notifications.pull_request.successful_build
):
msg = (
f"Congratulations! One of the builds has completed. :champagne:\n\n"
"You can install the built RPMs by following these steps:\n\n"
"* `sudo yum install -y dnf-plugins-core` on RHEL 8\n"
"* `sudo dnf install -y dnf-plugins-core` on Fedora\n"
f"* `dnf copr enable {self.event.owner}/{self.event.project_name}`\n"
"* And now you can install the packages.\n"
"\nPlease note that the RPMs should be used only in a testing environment."
)
self.event.project.pr_comment(pr_id=self.event.pr_id, body=msg)
build_job_helper.report_status_to_build_for_chroot(
state=CommitStatus.success,
description="RPMs were built successfully.",
url=url,
chroot=self.event.chroot,
)
build_job_helper.report_status_to_test_for_chroot(
state=CommitStatus.pending,
description="RPMs were built successfully.",
url=url,
chroot=self.event.chroot,
)
build.set_status(PG_COPR_BUILD_STATUS_SUCCESS)
if (
build_job_helper.job_tests
and self.event.chroot in build_job_helper.tests_targets
):
testing_farm_handler = GithubTestingFarmHandler(
config=self.config,
job_config=build_job_helper.job_tests,
event=self.event,
chroot=self.event.chroot,
)
testing_farm_handler.run()
else:
logger.debug("Testing farm not in the job config.")
return HandlerResults(success=True, details={})
class CoprBuildEndHandler(FedmsgHandler):
topic = "org.fedoraproject.prod.copr.build.end"
triggers = [TheJobTriggerType.copr_end]
def __init__(
self,
config: ServiceConfig,
job_config: Optional[JobConfig],
event: CoprBuildEvent,
):
super().__init__(config=config, job_config=job_config, event=event)
self.project = self.event.get_project()
self.package_config = self.event.get_package_config()
self.build_job_helper = CoprBuildJobHelper(
config=self.config,
package_config=self.package_config,
project=self.project,
event=event,
)
def was_last_build_successful(self):
"""
Check if the last copr build of the PR was successful
:return: bool
"""
comments = self.project.get_pr_comments(pr_id=self.event.pr_id, reverse=True)
for comment in comments:
if comment.author.startswith("packit-as-a-service"):
if "Congratulations!" in comment.comment:
return True
return False
# if there is no comment from p-s
return False
def run(self):
if self.event.chroot == "srpm-builds":
# we don't want to set check for this
msg = "SRPM build in copr has finished"
logger.debug(msg)
return HandlerResults(success=True, details={"msg": msg})
# TODO: drop the code below once we move to PG completely; the build is present in event
# pg
build_pg = CoprBuild.get_by_build_id(
str(self.event.build_id), self.event.chroot
)
if not build_pg:
logger.info(
f"build {self.event.build_id} is not in pg, falling back to redis"
)
# redis - old school
build = CoprBuildDB().get_build(self.event.build_id)
if not build:
# TODO: how could this happen?
msg = f"Copr build {self.event.build_id} not in CoprBuildDB"
logger.warning(msg)
return HandlerResults(success=False, details={"msg": msg})
if build_pg:
url = get_log_url(build_pg.id)
else:
url = copr_url_from_event(self.event)
# https://pagure.io/copr/copr/blob/master/f/common/copr_common/enums.py#_42
if self.event.status != 1:
failed_msg = "RPMs failed to be built."
self.build_job_helper.report_status_to_all_for_chroot(
state=CommitStatus.failure,
description=failed_msg,
url=url,
chroot=self.event.chroot,
)
if build_pg:
build_pg.set_status("failure")
return HandlerResults(success=False, details={"msg": failed_msg})
if (
self.build_job_helper.job_build
and self.build_job_helper.job_build.trigger
== TheJobTriggerType.pull_request
and not self.was_last_build_successful()
and self.package_config.notifications.pull_request.successful_build
):
msg = (
f"Congratulations! One of the builds has completed. :champagne:\n\n"
"You can install the built RPMs by following these steps:\n\n"
"* `sudo yum install -y dnf-plugins-core` on RHEL 8\n"
"* `sudo dnf install -y dnf-plugins-core` on Fedora\n"
f"* `dnf copr enable {self.event.owner}/{self.event.project_name}`\n"
"* And now you can install the packages.\n"
"\nPlease note that the RPMs should be used only in a testing environment."
)
self.project.pr_comment(pr_id=self.event.pr_id, body=msg)
self.build_job_helper.report_status_to_build_for_chroot(
state=CommitStatus.success,
description="RPMs were built successfully.",
url=url,
chroot=self.event.chroot,
)
self.build_job_helper.report_status_to_test_for_chroot(
state=CommitStatus.pending,
description="RPMs were built successfully.",
url=url,
chroot=self.event.chroot,
)
if build_pg:
build_pg.set_status("success")
if (
self.build_job_helper.job_tests
and self.event.chroot in self.build_job_helper.tests_chroots
):
testing_farm_handler = GithubTestingFarmHandler(
config=self.config,
job_config=self.build_job_helper.job_tests,
event=self.event,
chroot=self.event.chroot,
)
testing_farm_handler.run()
else:
logger.debug("Testing farm not in the job config.")
return HandlerResults(success=True, details={})
def test_copr_build_end(
copr_build_end,
pc_build_pr,
copr_build_pr,
pc_comment_pr_succ,
pr_comment_called,
):
pr = flexmock(source_project=flexmock())
flexmock(GithubProject).should_receive("is_private").and_return(False)
flexmock(GithubProject).should_receive("get_pr").and_return(pr)
pc_build_pr.jobs[
0].notifications.pull_request.successful_build = pc_comment_pr_succ
flexmock(AbstractCoprBuildEvent).should_receive(
"get_package_config").and_return(pc_build_pr)
flexmock(CoprBuildEndHandler).should_receive(
"was_last_packit_comment_with_congratulation").and_return(False)
if pr_comment_called:
pr.should_receive("comment")
else:
pr.should_receive("comment").never()
flexmock(CoprBuildModel).should_receive("get_by_build_id").and_return(
copr_build_pr)
copr_build_pr.should_call("set_status").with_args("success").once()
copr_build_pr.should_receive("set_end_time").once()
url = get_copr_build_info_url(1)
flexmock(requests).should_receive("get").and_return(requests.Response())
flexmock(
requests.Response).should_receive("raise_for_status").and_return(None)
# check if packit-service set correct PR status
flexmock(StatusReporter).should_receive("report").with_args(
state=BaseCommitStatus.success,
description="RPMs were built successfully.",
url=url,
check_names=CoprBuildJobHelper.get_build_check(
copr_build_end["chroot"]),
markdown_content=None,
).once()
# no test job defined => testing farm should be skipped
flexmock(TestingFarmJobHelper).should_receive("run_testing_farm").times(0)
flexmock(Signature).should_receive("apply_async").once()
# fix SRPM url since it touches multiple classes
(flexmock(CoprBuildJobHelper).should_receive("get_build").with_args(
1044215).and_return(
flexmock(source_package={"url": "https://my.host/my.srpm"
})).at_least().once())
flexmock(copr_build_pr._srpm_build_for_mocking).should_receive(
"set_url").with_args("https://my.host/my.srpm").mock()
flexmock(Pushgateway).should_receive("push").once().and_return()
processing_results = SteveJobs().process_message(copr_build_end)
event_dict, job, job_config, package_config = get_parameters_from_results(
processing_results)
assert json.dumps(event_dict)
flexmock(CoprBuildJobHelper).should_receive(
"get_built_packages").and_return([])
run_copr_build_end_handler(
package_config=package_config,
event=event_dict,
job_config=job_config,
)
def run(self):
build_job_helper = CoprBuildJobHelper(
service_config=self.service_config,
package_config=self.package_config,
project=self.project,
metadata=self.data,
db_trigger=self.db_trigger,
job_config=self.job_config,
)
if self.copr_event.chroot == "srpm-builds":
# we don't want to set check for this
msg = "SRPM build in copr has finished."
logger.debug(msg)
return TaskResults(success=True, details={"msg": msg})
if not self.build:
# TODO: how could this happen?
msg = f"Copr build {self.copr_event.build_id} not in CoprBuildDB."
logger.warning(msg)
return TaskResults(success=False, details={"msg": msg})
if self.build.status in [
PG_COPR_BUILD_STATUS_FAILURE,
PG_COPR_BUILD_STATUS_SUCCESS,
]:
msg = (f"Copr build {self.copr_event.build_id} is already"
f" processed (status={self.copr_event.build.status}).")
logger.info(msg)
return TaskResults(success=True, details={"msg": msg})
end_time = (datetime.utcfromtimestamp(self.copr_event.timestamp)
if self.copr_event.timestamp else None)
self.build.set_end_time(end_time)
url = get_copr_build_info_url_from_flask(self.build.id)
# https://pagure.io/copr/copr/blob/master/f/common/copr_common/enums.py#_42
if self.copr_event.status != COPR_API_SUCC_STATE:
failed_msg = "RPMs failed to be built."
build_job_helper.report_status_to_all_for_chroot(
state=CommitStatus.failure,
description=failed_msg,
url=url,
chroot=self.copr_event.chroot,
)
self.build.set_status(PG_COPR_BUILD_STATUS_FAILURE)
return TaskResults(success=False, details={"msg": failed_msg})
if (build_job_helper.job_build and build_job_helper.job_build.trigger
== JobConfigTriggerType.pull_request and self.copr_event.pr_id
and isinstance(self.project, (GithubProject, GitlabProject))
and not self.was_last_packit_comment_with_congratulation() and
self.job_config.notifications.pull_request.successful_build):
msg = (
f"Congratulations! One of the builds has completed. :champagne:\n\n"
":warning: Please note that our current plans include removal of these "
"comments in the near future (at least 2 weeks after including this "
"disclaimer), if you have serious concerns regarding their removal "
"or would like to continue receiving them please reach out to us. "
":warning:\n\n"
"You can install the built RPMs by following these steps:\n\n"
"* `sudo yum install -y dnf-plugins-core` on RHEL 8\n"
"* `sudo dnf install -y dnf-plugins-core` on Fedora\n"
f"* `dnf copr enable {self.copr_event.owner}/{self.copr_event.project_name}`\n"
"* And now you can install the packages.\n"
"\nPlease note that the RPMs should be used only in a testing environment."
)
self.project.pr_comment(pr_id=self.copr_event.pr_id, body=msg)
build_job_helper.report_status_to_build_for_chroot(
state=CommitStatus.success,
description="RPMs were built successfully.",
url=url,
chroot=self.copr_event.chroot,
)
build_job_helper.report_status_to_test_for_chroot(
state=CommitStatus.pending,
description="RPMs were built successfully.",
url=url,
chroot=self.copr_event.chroot,
)
self.build.set_status(PG_COPR_BUILD_STATUS_SUCCESS)
if (build_job_helper.job_tests
and self.copr_event.chroot in build_job_helper.tests_targets):
signature(
TaskName.testing_farm.value,
kwargs={
"package_config": dump_package_config(self.package_config),
"job_config": dump_job_config(build_job_helper.job_tests),
"event": self.data.get_dict(),
"chroot": self.copr_event.chroot,
"build_id": self.build.id,
},
).apply_async()
else:
logger.debug("Testing farm not in the job config.")
return TaskResults(success=True, details={})
