8649010355

Committed 11 Apr 2024 03:08PM UTC coverage: 81.193% (-2.3%) from 83.5%

Build # 8649010355

Build Type

Pull #158

github

Committed by

web-flow

Commit Message

Merge be96a422c into 3cc229911

Pull Request Pull Request #158: Check code with mypy and reformat with pre-commit

Run Details

343 of 456 branches covered (75.22%)

Branch coverage included in aggregate %.

124 of 155 new or added lines in 15 files covered. (80.0%)

4 existing lines in 3 files now uncovered.

1073 of 1288 relevant lines covered (83.31%)

0.83 hits per line

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

97.14

/resultsdb/parsers/api_v3.py

# SPDX-License-Identifier: GPL-2.0+
from collections.abc import Iterator
from textwrap import dedent
from typing import Annotated

from pydantic import (
    BaseModel,
    ConfigDict,
    EmailStr,
    Field,
    HttpUrl,
    PlainSerializer,
    StringConstraints,
    field_validator,
    model_validator,
)

from resultsdb.models.results import result_outcomes

RESULT_OUTCOMES_ADDITIONAL = {
    "QUEUED",
    "RUNNING",
    "ERROR",
}

EXAMPLE_COMMON_PARAMS = dict(
    testcase="testcase1",
    outcome="PASSED",
    ci_name="ci1",
    ci_team="team1",
    ci_docs="https://test.example.com/docs",
    ci_email="test@example.com",
)

MAIN_RESULT_ATTRIBUTES = frozenset(
    {
        "testcase",
        "testcase_ref_url",
        "outcome",
        "ref_url",
        "note",
        "scratch",
    }
)

MAX_STRING_SIZE = 8192


def to_str(x):
    return str(x)


UrlStr = Annotated[
    HttpUrl,
    PlainSerializer(to_str, when_used="always"),
]


def result_outcomes_extended():
    outcomes = result_outcomes()
    additional_outcomes = tuple(
        outcome for outcome in RESULT_OUTCOMES_ADDITIONAL if outcome not in outcomes
    )
    return outcomes + additional_outcomes


def field(description: str, **kwargs):
    return Field(description=dedent(description).strip(), **kwargs)


class ResultParamsBase(BaseModel):
    """
    Base class for parameters to an API endpoint for creating results
    for a specific artifact type.

    Implement the following class methods in the derived classes:

    - artifact_type() - returns "type" for the new result data
    - example() - returns an example (instantiation of the derived class)
    """

    outcome: str = field(
        """
        Result of the test run. Can also indicate the intention to run
        the test in the near future (QUEUED), an unfinished run (RUNNING)
        or a CI error (ERROR).
        """
    )
    testcase: Annotated[str, StringConstraints(min_length=1)] = field(
        """
        Full test case name.
        """
    )
    testcase_ref_url: UrlStr | None = field(
        """
        Link to documentation for testing events for distributed CI systems to
        make them sustainable. Should contain information about how to
        contribute to the specific test, how to reproduce it, ideally on
        localhost and how to retrigger the test.
        """,
        default=None,
    )
    note: str | None = field(
        """
        Optional note related to the test result.
        """,
        default=None,
    )
    ref_url: UrlStr | None = field(
        """
        Specific runner URL. For example a Jenkins build URL.
        """,
        default=None,
    )

    error_reason: str | None = field(
        """
        Reason of the error.

        <b>Required</b> with ERROR outcome.
        """,
        default=None,
    )
    issue_url: UrlStr | None = field(
        """
        If the CI system is able to automatically file an issue/ticket for the
        error, put the URL here.

        Only valid with ERROR outcome.
        """,
        default=None,
    )

    system_provider: str | None = field(
        """
        System used for provisioning.
        This can also be hostname of the specific system instance.

        Examples: openstack, beaker, beaker.example.com, openshift, rhev
        """,
        default=None,
    )
    system_architecture: str | None = field(
        """
        Architecture of the system/distro used for testing.

        Examples: x86_64, ppc64le, s390x, aarch64
        """,
        default=None,
    )
    system_variant: str | None = field(
        """
        The compose or image variant, if applicable.

        Examples: Server, Workstation
        """,
        default=None,
    )

    scenario: str | None = field(
        """
        Test scenario. Identifies scenario under which the test(s) are
        executed. This is useful in case of artifacts consisting of
        multiple items which are subject of the same testsuite. For example
        "productmd-compose" artifact contains multiple variants and
        architectures all with their own repositories and installation
        media on which the same testsuite is executed. The variant and
        architecture would be in such case the scenario. The scenario is
        free form text where the tested item identifier is encoded.

        Examples: KDE-live-iso x86_64 64bit, Server x86_64
        """,
        default=None,
    )

    ci_name: str = field(
        """
        A human readable name for the CI system.

        Examples: BaseOS CI, OSCI Compose Gating Bot
        """
    )
    ci_team: str = field(
        """
        A human readable name of the team running the testing
        or gating. This is useful for example to distinguish
        multiple teams running on the same Jenkins instance.

        Examples: BaseOS QE, Libvirt QE, RTT, OSCI
        """
    )
    ci_docs: UrlStr = field(
        """
        Link to documentation with details about the system.
        """
    )
    ci_email: EmailStr = field(
        """
        Contact email address.
        """
    )
    ci_url: UrlStr | None = field(
        """
        URL link to the system or system's web interface.
        """,
        default=None,
    )
    ci_irc: str | None = field(
        """
        IRC contact for help (prefix with '#' for channel).

        Examples: #osci
        """,
        default=None,
    )

    scratch: bool | None = field(
        """
        Indication if the build is a scratch build.

        If true, the final "type" would contain suffix "_scratch".
        """,
        default=False,
    )
    rebuild: UrlStr | None = field(
        """
        URL to rebuild the run. Usually leads to a separate page with rebuild options.
        """,
        default=None,
    )
    log: UrlStr | None = field(
        """
        URL of build log. Can be an HTML page
        """,
        default=None,
    )

    model_config = ConfigDict(str_max_length=MAX_STRING_SIZE)

    def result_data(self) -> Iterator[tuple[(str, str)]]:
        """Generator yielding property name and value pairs to store in DB."""
        if self.scratch:
            yield ("type", f"{self.artifact_type()}_scratch")
        else:
            yield ("type", self.artifact_type())

        properties = self.model_dump(
            exclude_unset=True, exclude=self.exclude() | MAIN_RESULT_ATTRIBUTES
        )
        for name, value in properties.items():
            if isinstance(value, list):
                for subvalue in value:
                    yield (name, str(subvalue))
            else:
                yield (name, str(value))

    @field_validator("outcome", mode="before")
    @classmethod
    def outcome_must_be_valid(cls, v):
        if v not in result_outcomes_extended():
            raise ValueError(f'must be one of: {", ".join(result_outcomes_extended())}')
        return v

    @model_validator(mode="after")
    def only_available_for_error_outcome(self):
        if (
            self.error_reason is not None or self.issue_url is not None
        ) and self.outcome != "ERROR":
            raise ValueError(
                "error_reason and issue_url can be only set for ERROR outcome"
            )
        return self

    @classmethod
    def exclude(cls):
        """Returns set of attributes that should be excluded."""
        return set()


class BrewResultParams(ResultParamsBase):
    """Create new test result for a brew-build."""

    item: Annotated[str, StringConstraints(min_length=1)] = field(
        """
        Name-version-release of the brew-build.
        """
    )

    brew_task_id: int = field(
        """
        Task ID of the koji/brew build.
        """
    )

    @classmethod
    def example(cls):
        return cls(
            item="glibc-2.26-27.fc27",
            brew_task_id=123456,
            **EXAMPLE_COMMON_PARAMS,
        )

    @classmethod
    def artifact_type(cls) -> str:
        return "brew-build"


class RedHatContainerImageResultParams(ResultParamsBase):
    """Create new test result for a redhat-container-image."""

    item: Annotated[str, StringConstraints(min_length=1)] = field(
        """
        Name-version-release of the container image.
        """
    )

    id: str = field(
        """
        A digest that uniquely identifies the image within a repository.

        Example:
        <code>sha256:67dad89757a55bfdfabec8abd0e22f8c7c12a1856514726470228063ed86593b</code>
        """
    )
    issuer: str = field(
        """
        Build issuer of the artifact.

        Example: jdoe
        """
    )
    component: str = field(
        """
        Image's product name.

        Examples: openshiftcontainerplatform, redhatenterpriselinux
        """
    )

    full_names: list[str] = field(
        """
        Array of full names of the container image.
        One full name is in the form of "registry:port/namespace/name:tag".
        """
    )
    brew_task_id: int | None = field(
        """
        Brew task ID of the buildContainer task.
        """,
        default=None,
    )
    brew_build_id: int | None = field(
        """
        Brew build ID of container.
        """,
        default=None,
    )
    registry_url: str | None = field(
        """
        Registry url from the container image full name.
        """,
        default=None,
    )
    tag: str | None = field(
        """
        Tag from the container image full name.
        """,
        default=None,
    )
    name: str | None = field(
        """
        Name from the container image full name.

        Example: python-27-rhel8
        """,
        default=None,
    )
    namespace: str | None = field(
        """
        Namespace from the container image full name.

        Example: rhscl
        """,
        default=None,
    )
    source: str | None = field(
        """
        The first item in the request field from task details. This is
        usually a link to git repository with a reference, delimited with
        the '#' sign. In case of a scratch build or other build built via
        uploading a src.rpm the build task source will look like the bash
        scratch build.

        Example: git+https://github.com/docker/rootfs.git#container:docker
        """,
        default=None,
    )

    @classmethod
    def example(cls):
        return cls(
            item="rhoam-operator-bundle-container-v1.25.0-13",
            id="sha256:27a51bc590483f0cd8c6085825a82a5697832e1d8b0e6aab0651262b84855803",
            issuer="CPaaS",
            component="rhoam-operator-bundle-container",
            full_names=[
                "registry.example.com/rh-osbs/operator@"
                "sha256:27a51bc590483f0cd8c6085825a82a5697832e1d8b0e6aab0651262b84855803",
            ],
            **EXAMPLE_COMMON_PARAMS,
        )

    @classmethod
    def artifact_type(cls):
        return "redhat-container-image"


class RedHatModuleResultParams(ResultParamsBase):
    "Create new test result for a module."

    item: Annotated[str, StringConstraints(min_length=1)] = field(
        """
        Name-version-release of the module
        """
    )

    @classmethod
    def example(cls):
        return cls(
            item="llvm-toolset-rhel8-8000020190511064904-55190bc5",
            **EXAMPLE_COMMON_PARAMS,
        )

    @classmethod
    def artifact_type(cls):
        return "redhat-module"


class ProductmdComposeResultParams(ResultParamsBase):
    "Create new test result for a compose."

    id: Annotated[str, StringConstraints(min_length=1)] = field(
        """
        ID of the compose as recorded in the productmd metadata
        (payload.compose.id field inside the metadata/composeinfo.json file
        located in the compose directory)

        The additional "item" data field would be set to both the "{id}" and
        also "{id}/{system_architecture}/{system_variant}".

        Example: RHEL-7.4-20180531.2
        """
    )

    @property
    def item(self):
        variant = self.system_variant or "unknown"
        arch = self.system_architecture or ""
        return [
            f"{self.id}/{variant}/{arch}",
            self.id,
        ]

    def result_data(self):
        yield from super().result_data()
        for item in self.item:
            yield ("item", item)

    @classmethod
    def exclude(cls):
        return {"id"}

    @classmethod
    def example(cls):
        return cls(
            id="RHEL-8.8.0-20221129.0",
            **EXAMPLE_COMMON_PARAMS,
        )

    @classmethod
    def artifact_type(cls):
        return "productmd-compose"


class PermissionsParams(BaseModel):
    """List permissions for posting results for matching test cases."""

    testcase: str | None = field(
        """
        Filter only permissions matching test case name glob expression.

        Example: <code>compose.*</code>
        """,
        default=None,
    )


RESULTS_PARAMS_CLASSES = (
    BrewResultParams,
    ProductmdComposeResultParams,
    RedHatContainerImageResultParams,
    RedHatModuleResultParams,
)

1	# SPDX-License-Identifier: GPL-2.0+
2	from collections.abc import Iterator	1✔
3	from textwrap import dedent	1✔
4	from typing import Annotated	1✔
5
6	from pydantic import (	1✔
7	BaseModel,
8	ConfigDict,
9	EmailStr,
10	Field,
11	HttpUrl,
12	PlainSerializer,
13	StringConstraints,
14	field_validator,
15	model_validator,
16	)
17
18	from resultsdb.models.results import result_outcomes	1✔
19
20	RESULT_OUTCOMES_ADDITIONAL = {	1✔
21	"QUEUED",
22	"RUNNING",
23	"ERROR",
24	}
25
26	EXAMPLE_COMMON_PARAMS = dict(	1✔
27	testcase="testcase1",
28	outcome="PASSED",
29	ci_name="ci1",
30	ci_team="team1",
31	ci_docs="https://test.example.com/docs",
32	ci_email="test@example.com",
33	)
34
35	MAIN_RESULT_ATTRIBUTES = frozenset(	1✔
36	{
37	"testcase",
38	"testcase_ref_url",
39	"outcome",
40	"ref_url",
41	"note",
42	"scratch",
43	}
44	)
45
46	MAX_STRING_SIZE = 8192	1✔
47
48
49	def to_str(x):	1✔
50	return str(x)	1✔
51
52
53	UrlStr = Annotated[	1✔
54	HttpUrl,
55	PlainSerializer(to_str, when_used="always"),
56	]
57
58
59	def result_outcomes_extended():	1✔
60	outcomes = result_outcomes()	1✔
61	additional_outcomes = tuple(	1✔
62	outcome for outcome in RESULT_OUTCOMES_ADDITIONAL if outcome not in outcomes
63	)
64	return outcomes + additional_outcomes	1✔
65
66
67	def field(description: str, **kwargs):	1✔
68	return Field(description=dedent(description).strip(), **kwargs)	1✔
69
70
71	class ResultParamsBase(BaseModel):	1✔
72	"""
73	Base class for parameters to an API endpoint for creating results
74	for a specific artifact type.
75
76	Implement the following class methods in the derived classes:
77
78	- artifact_type() - returns "type" for the new result data
79	- example() - returns an example (instantiation of the derived class)
80	"""
81
82	outcome: str = field(	1✔
83	"""
84	Result of the test run. Can also indicate the intention to run
85	the test in the near future (QUEUED), an unfinished run (RUNNING)
86	or a CI error (ERROR).
87	"""
88	)
89	testcase: Annotated[str, StringConstraints(min_length=1)] = field(	1✔
90	"""
91	Full test case name.
92	"""
93	)
94	testcase_ref_url: UrlStr \| None = field(	1✔
95	"""
96	Link to documentation for testing events for distributed CI systems to
97	make them sustainable. Should contain information about how to
98	contribute to the specific test, how to reproduce it, ideally on
99	localhost and how to retrigger the test.
100	""",
101	default=None,
102	)
103	note: str \| None = field(	1✔
104	"""
105	Optional note related to the test result.
106	""",
107	default=None,
108	)
109	ref_url: UrlStr \| None = field(	1✔
110	"""
111	Specific runner URL. For example a Jenkins build URL.
112	""",
113	default=None,
114	)
115
116	error_reason: str \| None = field(	1✔
117	"""
118	Reason of the error.
119
120	<b>Required</b> with ERROR outcome.
121	""",
122	default=None,
123	)
124	issue_url: UrlStr \| None = field(	1✔
125	"""
126	If the CI system is able to automatically file an issue/ticket for the
127	error, put the URL here.
128
129	Only valid with ERROR outcome.
130	""",
131	default=None,
132	)
133
134	system_provider: str \| None = field(	1✔
135	"""
136	System used for provisioning.
137	This can also be hostname of the specific system instance.
138
139	Examples: openstack, beaker, beaker.example.com, openshift, rhev
140	""",
141	default=None,
142	)
143	system_architecture: str \| None = field(	1✔
144	"""
145	Architecture of the system/distro used for testing.
146
147	Examples: x86_64, ppc64le, s390x, aarch64
148	""",
149	default=None,
150	)
151	system_variant: str \| None = field(	1✔
152	"""
153	The compose or image variant, if applicable.
154
155	Examples: Server, Workstation
156	""",
157	default=None,
158	)
159
160	scenario: str \| None = field(	1✔
161	"""
162	Test scenario. Identifies scenario under which the test(s) are
163	executed. This is useful in case of artifacts consisting of
164	multiple items which are subject of the same testsuite. For example
165	"productmd-compose" artifact contains multiple variants and
166	architectures all with their own repositories and installation
167	media on which the same testsuite is executed. The variant and
168	architecture would be in such case the scenario. The scenario is
169	free form text where the tested item identifier is encoded.
170
171	Examples: KDE-live-iso x86_64 64bit, Server x86_64
172	""",
173	default=None,
174	)
175
176	ci_name: str = field(	1✔
177	"""
178	A human readable name for the CI system.
179
180	Examples: BaseOS CI, OSCI Compose Gating Bot
181	"""
182	)
183	ci_team: str = field(	1✔
184	"""
185	A human readable name of the team running the testing
186	or gating. This is useful for example to distinguish
187	multiple teams running on the same Jenkins instance.
188
189	Examples: BaseOS QE, Libvirt QE, RTT, OSCI
190	"""
191	)
192	ci_docs: UrlStr = field(	1✔
193	"""
194	Link to documentation with details about the system.
195	"""
196	)
197	ci_email: EmailStr = field(	1✔
198	"""
199	Contact email address.
200	"""
201	)
202	ci_url: UrlStr \| None = field(	1✔
203	"""
204	URL link to the system or system's web interface.
205	""",
206	default=None,
207	)
208	ci_irc: str \| None = field(	1✔
209	"""
210	IRC contact for help (prefix with '#' for channel).
211
212	Examples: #osci
213	""",
214	default=None,
215	)
216
217	scratch: bool \| None = field(	1✔
218	"""
219	Indication if the build is a scratch build.
220
221	If true, the final "type" would contain suffix "_scratch".
222	""",
223	default=False,
224	)
225	rebuild: UrlStr \| None = field(	1✔
226	"""
227	URL to rebuild the run. Usually leads to a separate page with rebuild options.
228	""",
229	default=None,
230	)
231	log: UrlStr \| None = field(	1✔
232	"""
233	URL of build log. Can be an HTML page
234	""",
235	default=None,
236	)
237
238	model_config = ConfigDict(str_max_length=MAX_STRING_SIZE)	1✔
239
240	def result_data(self) -> Iterator[tuple[(str, str)]]:	1✔
241	"""Generator yielding property name and value pairs to store in DB."""
242	if self.scratch:	1✔
243	yield ("type", f"{self.artifact_type()}_scratch")	1✔
244	else:
245	yield ("type", self.artifact_type())	1✔
246
247	properties = self.model_dump(	1✔
248	exclude_unset=True, exclude=self.exclude() \| MAIN_RESULT_ATTRIBUTES
249	)
250	for name, value in properties.items():	1✔
251	if isinstance(value, list):	1✔
252	for subvalue in value:	1✔
253	yield (name, str(subvalue))	1✔
254	else:
255	yield (name, str(value))	1✔
256
257	@field_validator("outcome", mode="before")	1✔
258	@classmethod	1✔
259	def outcome_must_be_valid(cls, v):	1✔
260	if v not in result_outcomes_extended():	1!
261	raise ValueError(f'must be one of: {", ".join(result_outcomes_extended())}')	×
262	return v	1✔
263
264	@model_validator(mode="after")	1✔
265	def only_available_for_error_outcome(self):	1✔
266	if (	1!
267	self.error_reason is not None or self.issue_url is not None
268	) and self.outcome != "ERROR":
NEW 269	raise ValueError(	×
270	"error_reason and issue_url can be only set for ERROR outcome"
271	)
272	return self	1✔
273
274	@classmethod	1✔
275	def exclude(cls):	1✔
276	"""Returns set of attributes that should be excluded."""
277	return set()	1✔
278
279
280	class BrewResultParams(ResultParamsBase):	1✔
281	"""Create new test result for a brew-build."""
282
283	item: Annotated[str, StringConstraints(min_length=1)] = field(	1✔
284	"""
285	Name-version-release of the brew-build.
286	"""
287	)
288
289	brew_task_id: int = field(	1✔
290	"""
291	Task ID of the koji/brew build.
292	"""
293	)
294
295	@classmethod	1✔
296	def example(cls):	1✔
297	return cls(	1✔
298	item="glibc-2.26-27.fc27",
299	brew_task_id=123456,
300	**EXAMPLE_COMMON_PARAMS,
301	)
302
303	@classmethod	1✔
304	def artifact_type(cls) -> str:	1✔
305	return "brew-build"	1✔
306
307
308	class RedHatContainerImageResultParams(ResultParamsBase):	1✔
309	"""Create new test result for a redhat-container-image."""
310
311	item: Annotated[str, StringConstraints(min_length=1)] = field(	1✔
312	"""
313	Name-version-release of the container image.
314	"""
315	)
316
317	id: str = field(	1✔
318	"""
319	A digest that uniquely identifies the image within a repository.
320
321	Example:
322	<code>sha256:67dad89757a55bfdfabec8abd0e22f8c7c12a1856514726470228063ed86593b</code>
323	"""
324	)
325	issuer: str = field(	1✔
326	"""
327	Build issuer of the artifact.
328
329	Example: jdoe
330	"""
331	)
332	component: str = field(	1✔
333	"""
334	Image's product name.
335
336	Examples: openshiftcontainerplatform, redhatenterpriselinux
337	"""
338	)
339
340	full_names: list[str] = field(	1✔
341	"""
342	Array of full names of the container image.
343	One full name is in the form of "registry:port/namespace/name:tag".
344	"""
345	)
346	brew_task_id: int \| None = field(	1✔
347	"""
348	Brew task ID of the buildContainer task.
349	""",
350	default=None,
351	)
352	brew_build_id: int \| None = field(	1✔
353	"""
354	Brew build ID of container.
355	""",
356	default=None,
357	)
358	registry_url: str \| None = field(	1✔
359	"""
360	Registry url from the container image full name.
361	""",
362	default=None,
363	)
364	tag: str \| None = field(	1✔
365	"""
366	Tag from the container image full name.
367	""",
368	default=None,
369	)
370	name: str \| None = field(	1✔
371	"""
372	Name from the container image full name.
373
374	Example: python-27-rhel8
375	""",
376	default=None,
377	)
378	namespace: str \| None = field(	1✔
379	"""
380	Namespace from the container image full name.
381
382	Example: rhscl
383	""",
384	default=None,
385	)
386	source: str \| None = field(	1✔
387	"""
388	The first item in the request field from task details. This is
389	usually a link to git repository with a reference, delimited with
390	the '#' sign. In case of a scratch build or other build built via
391	uploading a src.rpm the build task source will look like the bash
392	scratch build.
393
394	Example: git+https://github.com/docker/rootfs.git#container:docker
395	""",
396	default=None,
397	)
398
399	@classmethod	1✔
400	def example(cls):	1✔
401	return cls(	1✔
402	item="rhoam-operator-bundle-container-v1.25.0-13",
403	id="sha256:27a51bc590483f0cd8c6085825a82a5697832e1d8b0e6aab0651262b84855803",
404	issuer="CPaaS",
405	component="rhoam-operator-bundle-container",
406	full_names=[
407	"registry.example.com/rh-osbs/operator@"
408	"sha256:27a51bc590483f0cd8c6085825a82a5697832e1d8b0e6aab0651262b84855803",
409	],
410	**EXAMPLE_COMMON_PARAMS,
411	)
412
413	@classmethod	1✔
414	def artifact_type(cls):	1✔
415	return "redhat-container-image"	1✔
416
417
418	class RedHatModuleResultParams(ResultParamsBase):	1✔
419	"Create new test result for a module."
420
421	item: Annotated[str, StringConstraints(min_length=1)] = field(	1✔
422	"""
423	Name-version-release of the module
424	"""
425	)
426
427	@classmethod	1✔
428	def example(cls):	1✔
429	return cls(	1✔
430	item="llvm-toolset-rhel8-8000020190511064904-55190bc5",
431	**EXAMPLE_COMMON_PARAMS,
432	)
433
434	@classmethod	1✔
435	def artifact_type(cls):	1✔
436	return "redhat-module"	1✔
437
438
439	class ProductmdComposeResultParams(ResultParamsBase):	1✔
440	"Create new test result for a compose."
441
442	id: Annotated[str, StringConstraints(min_length=1)] = field(	1✔
443	"""
444	ID of the compose as recorded in the productmd metadata
445	(payload.compose.id field inside the metadata/composeinfo.json file
446	located in the compose directory)
447
448	The additional "item" data field would be set to both the "{id}" and
449	also "{id}/{system_architecture}/{system_variant}".
450
451	Example: RHEL-7.4-20180531.2
452	"""
453	)
454
455	@property	1✔
456	def item(self):	1✔
457	variant = self.system_variant or "unknown"	1✔
458	arch = self.system_architecture or ""	1✔
459	return [	1✔
460	f"{self.id}/{variant}/{arch}",
461	self.id,
462	]
463
464	def result_data(self):	1✔
465	yield from super().result_data()	1✔
466	for item in self.item:	1✔
467	yield ("item", item)	1✔
468
469	@classmethod	1✔
470	def exclude(cls):	1✔
471	return {"id"}	1✔
472
473	@classmethod	1✔
474	def example(cls):	1✔
475	return cls(	1✔
476	id="RHEL-8.8.0-20221129.0",
477	**EXAMPLE_COMMON_PARAMS,
478	)
479
480	@classmethod	1✔
481	def artifact_type(cls):	1✔
482	return "productmd-compose"	1✔
483
484
485	class PermissionsParams(BaseModel):	1✔
486	"""List permissions for posting results for matching test cases."""
487
488	testcase: str \| None = field(	1✔
489	"""
490	Filter only permissions matching test case name glob expression.
491
492	Example: <code>compose.*</code>
493	""",
494	default=None,
495	)
496
497
498	RESULTS_PARAMS_CLASSES = (	1✔
499	BrewResultParams,
500	ProductmdComposeResultParams,
501	RedHatContainerImageResultParams,
502	RedHatModuleResultParams,
503	)

release-engineering / resultsdb / 8649010355

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