10418146768

Committed 16 Aug 2024 09:57AM UTC coverage: 92.072% (-0.08%) from 92.152%

Build # 10418146768

Build Type

Pull #284

github

Committed by

web-flow

Commit Message

Merge 12e851078 into cbca92909

Pull Request Pull Request #284: Deduplicate test code

Run Details

730 of 852 branches covered (85.68%)

Branch coverage included in aggregate %.

132 of 132 new or added lines in 4 files covered. (100.0%)

6 existing lines in 2 files now uncovered.

3904 of 4181 relevant lines covered (93.37%)

0.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.31

/greenwave/listeners/resultsdb.py

# SPDX-License-Identifier: GPL-2.0+
from greenwave.listeners.base import BaseListener
from greenwave.product_versions import subject_product_versions
from greenwave.subjects.factory import (
    UnknownSubjectDataError,
    create_subject_from_data,
)


def _unpack_value(value):
    """
    If value is list with single element, returns the element, otherwise
    returns the value.
    """
    if isinstance(value, list) and len(value) == 1:
        value = value[0]
    return value


def _get_brew_task_id(msg):
    data = msg.get("data")
    if not data:
        return None

    task_id = _unpack_value(data.get("brew_task_id"))
    try:
        return int(task_id)
    except (ValueError, TypeError):
        return None


class ResultsDBListener(BaseListener):
    monitor_labels = {"handler": "resultsdb"}

    def __init__(self, config_obj=None):
        super().__init__(uid_suffix="resultsdb", config_obj=config_obj)
        self.topic = self.app.config["LISTENER_RESULTSDB_QUEUE"]
        self.koji_base_url = self.app.config["KOJI_BASE_URL"]

    @staticmethod
    def announcement_subject(msg):
        """
        Returns pairs of (subject type, subject identifier) for announcement
        consideration from the message.
        """

        try:
            data = msg["data"]  # New format
        except KeyError:
            data = msg["task"]  # Old format

        unpacked = {k: _unpack_value(v) for k, v in data.items()}

        try:
            subject = create_subject_from_data(unpacked)
        except UnknownSubjectDataError:
            return None

        # note: it is *intentional* that we do not handle old format
        # compose-type messages, because it is impossible to reliably
        # produce a decision from these. compose decisions can only be
        # reliably made from new format messages, where we can rely on
        # productmd.compose.id being available. See:
        # https://pagure.io/greenwave/issue/122
        # https://pagure.io/taskotron/resultsdb/issue/92
        # https://pagure.io/taskotron/resultsdb/pull-request/101
        # https://pagure.io/greenwave/pull-request/262#comment-70350
        if subject.type == "compose" and "productmd.compose.id" not in data:
            return None

        return subject

    def _consume_message(self, msg):
        super()._consume_message(message=msg)
        try:
            testcase = msg["testcase"]["name"]
        except KeyError:
            testcase = msg["task"]["name"]

        try:
            submit_time = msg["submit_time"]
        except KeyError:
            submit_time = msg["result"]["submit_time"]

        outcome = msg.get("outcome")
        if outcome in self.app.config["OUTCOMES_INCOMPLETE"]:
            self.app.logger.debug("Assuming no decision change on outcome %r", outcome)
            return False

        brew_task_id = _get_brew_task_id(msg)

        subject = self.announcement_subject(msg)
        if subject is None:
            return False

        self.app.logger.debug("Considering subject: %r", subject)

        product_versions = subject_product_versions(
            subject,
            self.koji_base_url,
            brew_task_id,
        )

        self.app.logger.debug("Guessed product versions: %r", product_versions)

        if not product_versions:
            product_versions = [None]

        for product_version in product_versions:
            self._publish_decision_change(
                submit_time=submit_time,
                subject=subject,
                testcase=testcase,
                product_version=product_version,
                publish_testcase=False,
            )

        return True

1	# SPDX-License-Identifier: GPL-2.0+
2	from greenwave.listeners.base import BaseListener	1✔
3	from greenwave.product_versions import subject_product_versions	1✔
4	from greenwave.subjects.factory import (	1✔
5	UnknownSubjectDataError,
6	create_subject_from_data,
7	)
8
9
10	def _unpack_value(value):	1✔
11	"""
12	If value is list with single element, returns the element, otherwise
13	returns the value.
14	"""
15	if isinstance(value, list) and len(value) == 1:	1✔
16	value = value[0]	1✔
17	return value	1✔
18
19
20	def _get_brew_task_id(msg):	1✔
21	data = msg.get("data")	1✔
22	if not data:	1!
UNCOV 23	return None	×
24
25	task_id = _unpack_value(data.get("brew_task_id"))	1✔
26	try:	1✔
27	return int(task_id)	1✔
28	except (ValueError, TypeError):	1✔
29	return None	1✔
30
31
32	class ResultsDBListener(BaseListener):	1✔
33	monitor_labels = {"handler": "resultsdb"}	1✔
34
35	def __init__(self, config_obj=None):	1✔
36	super().__init__(uid_suffix="resultsdb", config_obj=config_obj)	1✔
37	self.topic = self.app.config["LISTENER_RESULTSDB_QUEUE"]	1✔
38	self.koji_base_url = self.app.config["KOJI_BASE_URL"]	1✔
39
40	@staticmethod	1✔
41	def announcement_subject(msg):	1✔
42	"""
43	Returns pairs of (subject type, subject identifier) for announcement
44	consideration from the message.
45	"""
46
47	try:	1✔
48	data = msg["data"] # New format	1✔
49	except KeyError:	1✔
50	data = msg["task"] # Old format	1✔
51
52	unpacked = {k: _unpack_value(v) for k, v in data.items()}	1✔
53
54	try:	1✔
55	subject = create_subject_from_data(unpacked)	1✔
56	except UnknownSubjectDataError:	1✔
57	return None	1✔
58
59	# note: it is intentional that we do not handle old format
60	# compose-type messages, because it is impossible to reliably
61	# produce a decision from these. compose decisions can only be
62	# reliably made from new format messages, where we can rely on
63	# productmd.compose.id being available. See:
64	# https://pagure.io/greenwave/issue/122
65	# https://pagure.io/taskotron/resultsdb/issue/92
66	# https://pagure.io/taskotron/resultsdb/pull-request/101
67	# https://pagure.io/greenwave/pull-request/262#comment-70350
68	if subject.type == "compose" and "productmd.compose.id" not in data:	1✔
69	return None	1✔
70
71	return subject	1✔
72
73	def _consume_message(self, msg):	1✔
74	super()._consume_message(message=msg)	1✔
75	try:	1✔
76	testcase = msg["testcase"]["name"]	1✔
UNCOV 77	except KeyError:	×
UNCOV 78	testcase = msg["task"]["name"]	×
79
80	try:	1✔
81	submit_time = msg["submit_time"]	1✔
UNCOV 82	except KeyError:	×
UNCOV 83	submit_time = msg["result"]["submit_time"]	×
84
85	outcome = msg.get("outcome")	1✔
86	if outcome in self.app.config["OUTCOMES_INCOMPLETE"]:	1✔
87	self.app.logger.debug("Assuming no decision change on outcome %r", outcome)	1✔
88	return False	1✔
89
90	brew_task_id = _get_brew_task_id(msg)	1✔
91
92	subject = self.announcement_subject(msg)	1✔
93	if subject is None:	1✔
94	return False	1✔
95
96	self.app.logger.debug("Considering subject: %r", subject)	1✔
97
98	product_versions = subject_product_versions(	1✔
99	subject,
100	self.koji_base_url,
101	brew_task_id,
102	)
103
104	self.app.logger.debug("Guessed product versions: %r", product_versions)	1✔
105
106	if not product_versions:	1✔
107	product_versions = [None]	1✔
108
109	for product_version in product_versions:	1✔
110	self._publish_decision_change(	1✔
111	submit_time=submit_time,
112	subject=subject,
113	testcase=testcase,
114	product_version=product_version,
115	publish_testcase=False,
116	)
117
118	return True	1✔

release-engineering / greenwave / 10418146768

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous