def test_get_unreleased(self):
event1 = Event.create(db.session, "test_msg_id1", "test", events.TestingEvent)
event1.state = EventState.COMPLETE
event1.released = False
event2 = Event.create(db.session, "test_msg_id2", "test", events.TestingEvent)
event2.state = EventState.COMPLETE
event2.released = True
event3 = Event.create(db.session, "test_msg_id3", "test", events.TestingEvent)
event3.state = EventState.SKIPPED
event3.released = False
event4 = Event.create(db.session, "test_msg_id4", "test", events.TestingEvent)
event4.state = EventState.SKIPPED
event4.released = True
db.session.commit()
# No state means only COMPLETE should be returned
ret = Event.get_unreleased(db.session)
self.assertEqual(ret, [event1])
# No state means only COMPLETE should be returned
ret = Event.get_unreleased(db.session, states=[EventState.SKIPPED])
self.assertEqual(ret, [event3])
def test_return_added_dependency_relationship(self):
event = Event.create(db.session, "test_msg_id", "test", events.TestingEvent)
event1 = Event.create(db.session, "test_msg_id2", "test2", events.TestingEvent)
db.session.commit()
dep_rel = event.add_event_dependency(db.session, event1)
db.session.commit()
self.assertEqual(event.id, dep_rel.event_id)
self.assertEqual(event1.id, dep_rel.event_dependency_id)
def test_add_existing_dependent_event(self):
event = Event.create(db.session, "test_msg_id", "test", events.TestingEvent)
event1 = Event.create(db.session, "test_msg_id2", "test2", events.TestingEvent)
db.session.commit()
event.add_event_dependency(db.session, event1)
db.session.commit()
rel = event.add_event_dependency(db.session, event1)
self.assertIsNone(rel)
self.assertEqual(event.event_dependencies, [event1])
self.assertEqual(event1.depending_events, [event])
def test_add_a_dependent_event(self):
event = Event.create(db.session, "test_msg_id", "test", events.TestingEvent)
event1 = Event.create(db.session, "test_msg_id2", "test2", events.TestingEvent)
db.session.commit()
event.add_event_dependency(db.session, event1)
db.session.commit()
self.assertEqual(event.event_dependencies, [event1])
self.assertEqual(event.event_dependencies[0].search_key, "test2")
self.assertEqual(event1.event_dependencies, [])
self.assertEqual(event1.depending_events, [event])
self.assertEqual(event.depending_events, [])
def test_not_rebuild_if_errata_state_is_not_allowed(
self, rebuild_if_not_exists):
rebuild_if_not_exists.return_value = [Mock(), Mock()]
Event.create(db.session, "msg-id-123", "123456",
ErrataAdvisoryRPMsSignedEvent, False)
db.session.commit()
event = ErrataAdvisoryStateChangedEvent(
'msg-id-123',
ErrataAdvisory(123456, 'name', 'SHIPPED_LIVE', ['rpm']))
handler = UpdateDBOnAdvisoryChange()
msgs = handler.handle(event)
self.assertEqual([], msgs)
def test_event_transition(self):
for i, state in enumerate([
EventState.COMPLETE, EventState.COMPLETE.value, "complete"]):
event = Event.create(db.session, "test_msg_id_{}".format(i), "test", events.TestingEvent)
event.transition(state, "reason")
self.assertEqual(event.state, EventState.COMPLETE.value)
self.assertTrue(event.time_done is not None)
def test_event_json_min(self):
with patch('freshmaker.models.datetime') as datetime_patch:
datetime_patch.utcnow.return_value = datetime.datetime(2017, 8, 21, 13, 42, 20)
event = Event.create(db.session, "test_msg_id5", "RHSA-2017-289", events.TestingEvent)
build = ArtifactBuild.create(db.session, event, "ed", "module", 1234)
build.state = ArtifactBuildState.FAILED
ArtifactBuild.create(db.session, event, "mksh", "module", 1235, build)
db.session.commit()
self.assertEqual(event.json_min(), {
'builds_summary': {'BUILD': 1, 'FAILED': 1, 'total': 2},
'dry_run': False,
'event_type_id': 3,
'id': 1,
'message_id': 'test_msg_id5',
'requester': None,
'search_key': 'RHSA-2017-289',
'state': 0,
'state_name': 'INITIALIZED',
'state_reason': None,
'time_created': '2017-08-21T13:42:20Z',
'time_done': None,
'url': 'http://localhost:5001/api/1/events/1',
'requested_rebuilds': [],
'requester_metadata': {},
'depending_events': [],
'depends_on_events': [],
})
def test_rebuild_if_not_exists_already_exists(self, advisories_from_event):
handler = UpdateDBOnAdvisoryChange()
db_event = Event.create(db.session, "msg124", "123",
ErrataAdvisoryRPMsSignedEvent)
db.session.commit()
for manual in [True, False]:
for db_event_state in [
EventState.INITIALIZED, EventState.BUILDING,
EventState.COMPLETE, EventState.FAILED, EventState.SKIPPED
]:
db_event.state = db_event_state
db.session.commit()
for state in [
"REL_PREP", "PUSH_READY", "IN_PUSH", "SHIPPED_LIVE"
]:
advisories_from_event.return_value = [
ErrataAdvisory(123, "RHSA-2017", state, ["rpm"],
"Critical")
]
ev = ErrataAdvisoryStateChangedEvent(
"msg123",
ErrataAdvisory(123, 'RHSA-2017', state, ['rpm']))
ev.manual = manual
ev.dry_run = manual # use also manual just for the sake of test.
ret = handler.handle(ev)
if db_event_state == EventState.FAILED or ev.manual:
self.assertEqual(len(ret), 1)
self.assertEqual(ret[0].manual, manual)
self.assertEqual(ret[0].dry_run, manual)
else:
self.assertEqual(len(ret), 0)
def test_creating_event_and_builds(self):
event = Event.create(db.session, "test_msg_id", "RHSA-2017-284", events.TestingEvent)
build = ArtifactBuild.create(db.session, event, "ed", "module", 1234,
rebuild_reason=RebuildReason.DIRECTLY_AFFECTED.value)
ArtifactBuild.create(db.session, event, "mksh", "module", 1235, build,
rebuild_reason=RebuildReason.DEPENDENCY.value)
db.session.commit()
db.session.expire_all()
e = db.session.query(Event).filter(event.id == 1).one()
self.assertEqual(e.message_id, "test_msg_id")
self.assertEqual(e.search_key, "RHSA-2017-284")
self.assertEqual(e.event_type, events.TestingEvent)
self.assertEqual(len(e.builds.all()), 2)
self.assertEqual(e.builds[0].name, "ed")
self.assertEqual(e.builds[0].type, 2)
self.assertEqual(e.builds[0].state, 0)
self.assertEqual(e.builds[0].build_id, 1234)
self.assertEqual(e.builds[0].dep_on, None)
self.assertEqual(e.builds[0].rebuild_reason, RebuildReason.DIRECTLY_AFFECTED.value)
self.assertEqual(e.builds[1].name, "mksh")
self.assertEqual(e.builds[1].type, 2)
self.assertEqual(e.builds[1].state, 0)
self.assertEqual(e.builds[1].build_id, 1235)
self.assertEqual(e.builds[1].dep_on.name, "ed")
self.assertEqual(e.builds[1].rebuild_reason, RebuildReason.DEPENDENCY.value)
def test_depending_artifact_builds(self):
event = Event.create(db.session, "test_msg_id", "test", events.TestingEvent)
parent = ArtifactBuild.create(db.session, event, "parent", "module", 1234)
build2 = ArtifactBuild.create(db.session, event, "mksh", "module", 1235, parent)
build3 = ArtifactBuild.create(db.session, event, "runtime", "module", 1236, parent)
ArtifactBuild.create(db.session, event, "perl-runtime", "module", 1237)
db.session.commit()
deps = set(parent.depending_artifact_builds())
self.assertEqual(deps, set([build2, build3]))
def setUp(self):
super(TestPrepareYumRepo, self).setUp()
self.ev = Event.create(db.session, 'msg-id', '123', 100)
ArtifactBuild.create(db.session,
self.ev,
"parent",
"image",
state=ArtifactBuildState.PLANNED)
db.session.commit()
def test_get_published_original_nvr(self):
event1 = Event.create(db.session, "id1", "RHSA-1", TestingEvent)
ArtifactBuild.create(db.session,
event1,
"ed0",
"image",
1234,
original_nvr="nvr1",
rebuilt_nvr="nvr1-001")
event2 = Event.create(db.session, "id2", "RHSA-1",
ManualRebuildWithAdvisoryEvent)
ArtifactBuild.create(db.session,
event2,
"ed1",
"image",
12345,
original_nvr="nvr1-001",
rebuilt_nvr="nvr1-002")
event3 = Event.create(db.session, "id3", "RHSA-1",
ManualRebuildWithAdvisoryEvent)
ArtifactBuild.create(db.session,
event3,
"ed2",
"image",
123456,
original_nvr="nvr1-002",
rebuilt_nvr="nvr1-003")
db.session.commit()
self.pyxis()._pagination.side_effect = [[{
"repositories": [{
"published": False
}]
}], [{
"repositories": [{
"published": True
}]
}]]
ret_nvr = self.handler.get_published_original_nvr("nvr1-003")
self.assertEqual(ret_nvr, "nvr1-001")
def test_get_root_dep_on(self):
event = Event.create(db.session, "test_msg_id", "test", events.TestingEvent)
build1 = ArtifactBuild.create(db.session, event, "ed", "module", 1234)
build2 = ArtifactBuild.create(db.session, event, "mksh", "module", 1235, build1)
build3 = ArtifactBuild.create(db.session, event, "runtime", "module", 1236, build2)
build4 = ArtifactBuild.create(db.session, event, "perl-runtime", "module", 1237, build3)
db.session.commit()
db.session.expire_all()
self.assertEqual(build1.get_root_dep_on(), None)
self.assertEqual(build2.get_root_dep_on(), build1)
self.assertEqual(build3.get_root_dep_on(), build1)
self.assertEqual(build4.get_root_dep_on(), build1)
def test_get_published_original_nvr_single_event(self):
event1 = Event.create(db.session, "id1", "RHSA-1", TestingEvent)
ArtifactBuild.create(db.session, event1, "ed0", "image", 1234,
original_nvr="nvr1-0-1",
rebuilt_nvr="nvr1-0-2")
db.session.commit()
self.pyxis()._pagination.return_value = [
{"repositories": [{"published": True}]}
]
ret_nvr = self.handler.get_published_original_nvr("nvr1-0-2")
self.assertEqual(ret_nvr, "nvr1-0-1")
def test_mark_as_released_wrong_advisory_status(self):
db_event = Event.create(db.session, "msg124", "123",
ErrataAdvisoryRPMsSignedEvent, False)
db.session.commit()
for state in ["NEW_FILES", "QE", "REL_PREP", "PUSH_READY", "IN_PUSH"]:
ev = ErrataAdvisoryStateChangedEvent(
"msg123", ErrataAdvisory(123, "name", state, ['rpm']))
handler = UpdateDBOnAdvisoryChange()
handler.handle(ev)
db.session.refresh(db_event)
self.assertEqual(db_event.released, False)
def handle(self, event):
log.info("Finding out all advisories including %s", event.nvr)
# When get a signed RPM, first step is to find out advisories
# containing that RPM and ensure all builds are signed.
errata = Errata()
advisories = errata.advisories_from_event(event)
# Filter out advisories which are not allowed by configuration.
advisories = [
advisory for advisory in advisories if self.allow_build(
ArtifactType.IMAGE,
advisory_name=advisory.name,
advisory_security_impact=advisory.security_impact,
advisory_highest_cve_severity=advisory.highest_cve_severity,
advisory_state=advisory.state)
]
# Filter out advisories which are already in Freshmaker DB.
advisories = self._filter_out_existing_advisories(advisories)
if not advisories:
log.info("No advisories found suitable for rebuilding Docker "
"images")
return []
if not all((errata.builds_signed(advisory.errata_id)
for advisory in advisories)):
log.info(
'Not all builds in %s are signed. Do not rebuild any '
'docker image until signed.', advisories)
return []
# Now we know that all advisories with this signed RPM have also other
# RPMs signed. We can then proceed and generate
# ErrataAdvisoryRPMsSignedEvent.
new_events = []
for advisory in advisories:
new_event = ErrataAdvisoryRPMsSignedEvent(
event.msg_id + "." + str(advisory.name), advisory)
db_event = Event.create(db.session,
new_event.msg_id,
new_event.search_key,
new_event.__class__,
released=False)
db.session.add(db_event)
new_events.append(new_event)
db.session.commit()
return new_events
def test_mark_as_released(self):
db_event = Event.create(db.session, "msg124", "123",
ErrataAdvisoryRPMsSignedEvent, False)
db.session.commit()
self.assertEqual(db_event.released, False)
ev = ErrataAdvisoryStateChangedEvent(
"msg123", ErrataAdvisory(123, "name", "SHIPPED_LIVE", ["rpm"]))
handler = UpdateDBOnAdvisoryChange()
handler.handle(ev)
db.session.refresh(db_event)
self.assertEqual(db_event.released, True)
def test_build_transition_recursion_not_done_for_ok_states(self):
for i, state in enumerate([ArtifactBuildState.DONE.value,
ArtifactBuildState.PLANNED.value]):
event = Event.create(db.session, "test_msg_id_{}".format(i), "test", events.TestingEvent)
build1 = ArtifactBuild.create(db.session, event, "ed", "module", 1234)
build2 = ArtifactBuild.create(db.session, event, "mksh", "module", 1235, build1)
build3 = ArtifactBuild.create(db.session, event, "runtime", "module", 1236, build2)
build4 = ArtifactBuild.create(db.session, event, "perl-runtime", "module", 1237)
db.session.commit()
build1.transition(state, "reason")
self.assertEqual(build1.state, state)
self.assertEqual(build1.state_reason, "reason")
for build in [build2, build3, build4]:
self.assertEqual(build4.state, ArtifactBuildState.BUILD.value)
self.assertEqual(build4.state_reason, None)
def _create_test_event(self, event_id, search_key, build_name, compose_id):
db_event = Event.create(db.session,
event_id,
search_key,
EVENT_TYPES[ErrataAdvisoryRPMsSignedEvent],
state=EventState.INITIALIZED,
released=False)
build_1 = ArtifactBuild.create(db.session,
db_event,
build_name,
ArtifactType.IMAGE,
state=ArtifactBuildState.PLANNED)
compose_1 = Compose(odcs_compose_id=compose_id)
db.session.add(compose_1)
db.session.commit()
db.session.add(
ArtifactBuildCompose(build_id=build_1.id, compose_id=compose_1.id))
db.session.commit()
return db_event
def setUp(self):
super(TestArtifactBuildComposesRel, self). setUp()
self.compose_1 = Compose(odcs_compose_id=-1)
self.compose_2 = Compose(odcs_compose_id=2)
self.compose_3 = Compose(odcs_compose_id=3)
self.compose_4 = Compose(odcs_compose_id=4)
db.session.add(self.compose_1)
db.session.add(self.compose_2)
db.session.add(self.compose_3)
db.session.add(self.compose_4)
self.event = Event.create(
db.session, 'msg-1', 'search-key-1',
EVENT_TYPES[ErrataAdvisoryRPMsSignedEvent],
state=EventState.INITIALIZED,
released=False)
self.build_1 = ArtifactBuild.create(
db.session, self.event, 'build-1', ArtifactType.IMAGE)
self.build_1.build_id = 3
self.build_2 = ArtifactBuild.create(
db.session, self.event, 'build-2', ArtifactType.IMAGE)
self.build_2.build_id = -2
self.build_3 = ArtifactBuild.create(
db.session, self.event, 'build-3', ArtifactType.IMAGE)
self.build_3.build_id = None
db.session.commit()
rels = (
(self.build_1.id, self.compose_1.id),
(self.build_1.id, self.compose_2.id),
(self.build_1.id, self.compose_3.id),
(self.build_2.id, self.compose_2.id),
(self.build_2.id, self.compose_4.id),
)
for build_id, compose_id in rels:
db.session.add(
ArtifactBuildCompose(
build_id=build_id, compose_id=compose_id))
db.session.commit()
def setUp(self):
super(TestPrepareYumReposForRebuilds, self).setUp()
self.patcher = helpers.Patcher()
self.mock_prepare_yum_repo = self.patcher.patch(
'freshmaker.odcsclient.FreshmakerODCSClient.prepare_yum_repo',
side_effect=[
{
'id': 1,
'result_repofile': 'http://localhost/repo/1'
},
{
'id': 2,
'result_repofile': 'http://localhost/repo/2'
},
{
'id': 3,
'result_repofile': 'http://localhost/repo/3'
},
{
'id': 4,
'result_repofile': 'http://localhost/repo/4'
},
])
self.mock_find_dependent_event = self.patcher.patch(
'freshmaker.models.Event.find_dependent_events')
self.db_event = Event.create(db.session,
'msg-1',
'search-key-1',
1,
state=EventState.INITIALIZED,
released=False)
self.build_1 = ArtifactBuild.create(db.session, self.db_event,
'build-1', ArtifactType.IMAGE)
self.build_2 = ArtifactBuild.create(db.session, self.db_event,
'build-2', ArtifactType.IMAGE)
db.session.commit()
def test_build_transition_recursion(self):
for i, state in enumerate([ArtifactBuildState.FAILED.value,
ArtifactBuildState.CANCELED.value]):
event = Event.create(db.session, "test_msg_id_{}".format(i), "test", events.TestingEvent)
build1 = ArtifactBuild.create(db.session, event, "ed", "module", 1234)
build2 = ArtifactBuild.create(db.session, event, "mksh", "module", 1235, build1)
build3 = ArtifactBuild.create(db.session, event, "runtime", "module", 1236, build2)
build4 = ArtifactBuild.create(db.session, event, "perl-runtime", "module", 1237)
db.session.commit()
build1.transition(state, "reason")
self.assertEqual(build1.state, state)
self.assertEqual(build1.state_reason, "reason")
for build in [build2, build3]:
self.assertEqual(build.state, state)
self.assertEqual(
build.state_reason, "Cannot build artifact, because its "
"dependency cannot be built.")
self.assertEqual(build4.state, ArtifactBuildState.BUILD.value)
self.assertEqual(build4.state_reason, None)
def setUp(self):
super(TestGetRepoURLs, self).setUp()
self.compose_1 = Compose(odcs_compose_id=5)
self.compose_2 = Compose(odcs_compose_id=6)
self.compose_3 = Compose(odcs_compose_id=7)
self.compose_4 = Compose(odcs_compose_id=8)
db.session.add(self.compose_1)
db.session.add(self.compose_2)
db.session.add(self.compose_3)
db.session.add(self.compose_4)
self.event = Event.create(db.session,
'msg-1',
'search-key-1',
EVENT_TYPES[ErrataAdvisoryRPMsSignedEvent],
state=EventState.BUILDING,
released=False)
build_args = {}
build_args["repository"] = "repo"
build_args["commit"] = "hash"
build_args["original_parent"] = None
build_args["target"] = "target"
build_args["branch"] = "branch"
build_args["arches"] = "x86_64"
build_args["renewed_odcs_compose_ids"] = None
self.build_1 = ArtifactBuild.create(db.session,
self.event,
'build-1',
ArtifactType.IMAGE,
state=ArtifactBuildState.PLANNED,
original_nvr="foo-1-2")
self.build_1.build_args = json.dumps(build_args)
self.build_2 = ArtifactBuild.create(db.session,
self.event,
'build-2',
ArtifactType.IMAGE,
state=ArtifactBuildState.PLANNED,
original_nvr="foo-2-2")
self.build_2.build_args = json.dumps(build_args)
db.session.commit()
rels = (
(self.build_1.id, self.compose_1.id),
(self.build_1.id, self.compose_2.id),
(self.build_1.id, self.compose_3.id),
(self.build_1.id, self.compose_4.id),
)
for build_id, compose_id in rels:
db.session.add(
ArtifactBuildCompose(build_id=build_id, compose_id=compose_id))
db.session.commit()
def mocked_odcs_get_compose(compose_id):
return {
"id": compose_id,
"result_repofile": "http://localhost/%d.repo" % compose_id,
"state": COMPOSE_STATES["done"],
}
self.patch_odcs_get_compose = patch(
"freshmaker.handlers.ContainerBuildHandler.odcs_get_compose",
side_effect=mocked_odcs_get_compose)
self.odcs_get_compose = self.patch_odcs_get_compose.start()
def test_str(self):
event = Event.create(db.session, "test_msg_id1", "test",
events.TestingEvent)
self.assertEqual(str(event), "<TestingEvent, search_key=test>")
def test_str_unknown_event_type(self):
event = Event.create(db.session, "test_msg_id1", "test", 1024)
self.assertEqual(
str(event), "<UnknownEventType 1024, search_key=test>")
def setUp(self):
super(TestRebuildImagesOnODCSComposeDone, self).setUp()
# Test data
# (Inner build depends on outer build)
# Event (ErrataAdvisoryRPMsSignedEvent):
# build 1: [compose 1, pulp compose 1]
# build 2: [compose 1, pulp compose 2]
# build 3: [compose 1, pulp compose 3]
# build 4: [compose 1, pulp compose 4]
# build 5: [compose 1, pulp compose 5]
# build 6 (not planned): [compose 1, pulp compose 6]
self.db_event = Event.create(
db.session,
'msg-1',
'search-key-1',
EVENT_TYPES[ErrataAdvisoryRPMsSignedEvent],
state=EventState.INITIALIZED,
released=False)
self.build_1 = ArtifactBuild.create(db.session,
self.db_event,
'build-1',
ArtifactType.IMAGE,
state=ArtifactBuildState.PLANNED)
self.build_2 = ArtifactBuild.create(db.session,
self.db_event,
'build-2',
ArtifactType.IMAGE,
dep_on=self.build_1,
state=ArtifactBuildState.PLANNED)
self.build_3 = ArtifactBuild.create(db.session,
self.db_event,
'build-3',
ArtifactType.IMAGE,
state=ArtifactBuildState.PLANNED)
self.build_4 = ArtifactBuild.create(db.session,
self.db_event,
'build-4',
ArtifactType.IMAGE,
dep_on=self.build_3,
state=ArtifactBuildState.PLANNED)
self.build_5 = ArtifactBuild.create(db.session,
self.db_event,
'build-5',
ArtifactType.IMAGE,
dep_on=self.build_3,
state=ArtifactBuildState.PLANNED)
self.build_6 = ArtifactBuild.create(db.session,
self.db_event,
'build-6',
ArtifactType.IMAGE,
state=ArtifactBuildState.BUILD)
self.compose_1 = Compose(odcs_compose_id=1)
db.session.add(self.compose_1)
db.session.commit()
builds = [
self.build_1, self.build_2, self.build_3, self.build_4,
self.build_5, self.build_6
]
composes = [self.compose_1] * 6
for build, compose in zip(builds, composes):
db.session.add(
ArtifactBuildCompose(build_id=build.id, compose_id=compose.id))
db.session.commit()
# Create another DB event, build and compose just to have more data
# in database.
another_db_event = Event.create(
db.session,
'msg-2',
'search-key-2',
EVENT_TYPES[ErrataAdvisoryRPMsSignedEvent],
state=EventState.INITIALIZED,
released=False)
another_build_1 = ArtifactBuild.create(
db.session,
another_db_event,
'another-build-1',
ArtifactType.IMAGE,
state=ArtifactBuildState.PLANNED)
another_compose_1 = Compose(odcs_compose_id=2)
db.session.add(another_compose_1)
db.session.commit()
db.session.add(
ArtifactBuildCompose(build_id=another_build_1.id,
compose_id=another_compose_1.id))
db.session.commit()
def test_prepare_builds(self, get_koji_data):
get_koji_data.return_value = {
"repository": "repo",
"commit": "commit_1",
"target": "target_1",
"git_branch": "git_branch_1",
"arches": ["arch_1", "arch_1"]
}
pullspec_override_url = "https://localhost/api/2/pullspec_overrides/"
db_event = Event.create(db.session, "id1", "RHSA-1", TestingEvent)
db.session.commit()
bundle_data = [{
"images": ["image1", "image2"],
"nvr":
"nvr-1-1",
"auto_rebuild":
True,
"osbs_pinning":
True,
"pullspec_replacements": [{
'new': 'registry/repo/operator@sha256:123',
'original': 'registry/repo/operator:v2.2.0',
'pinned': True,
}],
"update": {
"metadata": {
'name': "amq-streams.2.2.0+0.1608854400.p",
"annotations": {
"olm.substitutesFor": "2.2.0"
},
},
'spec': {
'version': "2.2.0+0.1608854400.p",
}
},
}]
ret_builds = self.handler._prepare_builds(db_event, bundle_data)
builds = ArtifactBuild.query.all()
self.assertEqual(builds, ret_builds)
submitted_build = builds[0]
expected_csv_modifications = {
"pullspec_replacements": [{
"new": "registry/repo/operator@sha256:123",
"original": "registry/repo/operator:v2.2.0",
"pinned": True,
}],
"update": {
"metadata": {
"name": "amq-streams.2.2.0+0.1608854400.p",
"annotations": {
"olm.substitutesFor": "2.2.0"
},
},
"spec": {
"version": "2.2.0+0.1608854400.p",
}
},
}
self.assertEqual(submitted_build.bundle_pullspec_overrides,
expected_csv_modifications)
expected_build_args = {
"repository":
"repo",
"commit":
"commit_1",
"target":
"target_1",
"branch":
"git_branch_1",
"arches": ["arch_1", "arch_1"],
"original_parent":
None,
"operator_csv_modifications_url":
"https://localhost/api/2/pullspec_overrides/1",
}
self.assertEqual(json.loads(submitted_build.build_args),
expected_build_args)
self.assertEqual(submitted_build.state,
ArtifactBuildState.PLANNED.value)
self.assertEqual(
json.loads(
submitted_build.build_args)["operator_csv_modifications_url"],
pullspec_override_url + str(submitted_build.id))
def setUp(self):
super(TestFindDependentEvents, self). setUp()
self.event_1 = Event.create(
db.session, 'msg-1', 'search-key-1',
EVENT_TYPES[ErrataAdvisoryRPMsSignedEvent],
state=EventState.INITIALIZED,
released=False)
ArtifactBuild.create(
db.session, self.event_1, 'build-1', ArtifactType.IMAGE)
ArtifactBuild.create(
db.session, self.event_1, 'build-2', ArtifactType.IMAGE)
ArtifactBuild.create(
db.session, self.event_1, 'build-3', ArtifactType.IMAGE)
ArtifactBuild.create(
db.session, self.event_1, 'build-4', ArtifactType.IMAGE)
self.event_2 = Event.create(
db.session, 'msg-2', 'search-key-2',
EVENT_TYPES[ErrataAdvisoryRPMsSignedEvent],
state=EventState.BUILDING,
released=False)
ArtifactBuild.create(
db.session, self.event_2, 'build-2', ArtifactType.IMAGE)
ArtifactBuild.create(
db.session, self.event_2, 'build-5', ArtifactType.IMAGE)
ArtifactBuild.create(
db.session, self.event_2, 'build-6', ArtifactType.IMAGE)
self.event_3 = Event.create(
db.session, 'msg-3', 'search-key-3',
EVENT_TYPES[ErrataAdvisoryRPMsSignedEvent],
state=EventState.COMPLETE,
released=False)
ArtifactBuild.create(
db.session, self.event_3, 'build-2', ArtifactType.IMAGE)
ArtifactBuild.create(
db.session, self.event_3, 'build-4', ArtifactType.IMAGE)
ArtifactBuild.create(
db.session, self.event_3, 'build-7', ArtifactType.IMAGE)
ArtifactBuild.create(
db.session, self.event_3, 'build-8', ArtifactType.IMAGE)
# Some noises
# Failed events should not be included
self.event_4 = Event.create(
db.session, 'msg-4', 'search-key-4',
EVENT_TYPES[ErrataAdvisoryRPMsSignedEvent],
state=EventState.FAILED,
released=False)
ArtifactBuild.create(
db.session, self.event_4, 'build-3', ArtifactType.IMAGE)
# Manual triggered rebuild should not be included as well
self.event_5 = Event.create(
db.session, 'msg-5', 'search-key-5',
EVENT_TYPES[ErrataAdvisoryRPMsSignedEvent],
state=EventState.BUILDING,
released=False, manual=True)
ArtifactBuild.create(
db.session, self.event_5, 'build-4', ArtifactType.IMAGE)
# Released event should not be included also
self.event_6 = Event.create(
db.session, 'msg-6', 'search-key-6',
EVENT_TYPES[ErrataAdvisoryRPMsSignedEvent],
state=EventState.COMPLETE,
released=True)
ArtifactBuild.create(
db.session, self.event_5, 'build-4', ArtifactType.IMAGE)
db.session.commit()
def test_event_dependencies(self):
event = Event.create(db.session, "test_msg_id", "test", events.TestingEvent)
db.session.commit()
self.assertEqual(event.event_dependencies, [])
self.assertEqual(event.depending_events, [])
