tests.unit_tests.test_oval_result_eval - Code Metrics - OpenSCAP/openscap-report - Measure and Improve Code Quality continuously with Scrutinizer

tests.unit_tests.test_oval_result_eval A
last analyzed 2024-09-09 11:38 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	270
Duplicated Lines	0 %

Importance

Changes

Metric	Value
eloc	205
dl	0
loc	270
rs	10
c	0
b	0
f	0
wmc	1

1 Function

Rating	Name	Duplication	Size	Complexity
B	test_evaluate_oval_result()	0	46	1

# Copyright 2022, Red Hat, Inc.
# SPDX-License-Identifier: LGPL-2.1-or-later

import pytest

from openscap_report.scap_results_parser.data_structures import (EMPTY_RESULT,
                                                                 OvalResult)

BAD_RESULT_COUNTS = {
    "number_of_true": -1,
    "number_of_false": -1,
    "number_of_error": -1,
    "number_of_unknown": -1,
    "number_of_noteval": -1,
    "number_of_notappl": -1
}

RESULT_COUNTS_1 = {
    "number_of_true": 3,
    "number_of_false": 3,
    "number_of_error": 3,
    "number_of_unknown": 0,
    "number_of_noteval": -1,
    "number_of_notappl": 3
}

RESULT_COUNTS_NOTAPPL = EMPTY_RESULT.copy()
RESULT_COUNTS_NOTAPPL["number_of_notappl"] = 5

# AND cases
RESULT_COUNTS_AND_TRUE = {
    "number_of_true": 2,
    "number_of_false": 0,
    "number_of_error": 0,
    "number_of_unknown": 0,
    "number_of_noteval": 0,
    "number_of_notappl": 1
}

RESULT_COUNTS_AND_FALSE = {
    "number_of_true": 2,
    "number_of_false": 2,
    "number_of_error": 0,
    "number_of_unknown": 1,
    "number_of_noteval": 1,
    "number_of_notappl": 1
}

RESULT_COUNTS_AND_ERROR = {
    "number_of_true": 1,
    "number_of_false": 0,
    "number_of_error": 3,
    "number_of_unknown": 1,
    "number_of_noteval": 1,
    "number_of_notappl": 1
}

RESULT_COUNTS_AND_UNKNOWN = {
    "number_of_true": 0,
    "number_of_false": 0,
    "number_of_error": 0,
    "number_of_unknown": 3,
    "number_of_noteval": 1,
    "number_of_notappl": 2
}

RESULT_COUNTS_AND_NOTEVAL = {
    "number_of_true": 2,
    "number_of_false": 0,
    "number_of_error": 0,
    "number_of_unknown": 0,
    "number_of_noteval": 3,
    "number_of_notappl": 2
}

# OR cases
RESULT_COUNTS_OR_TRUE = {
    "number_of_true": 2,
    "number_of_false": 2,
    "number_of_error": 0,
    "number_of_unknown": 2,
    "number_of_noteval": 0,
    "number_of_notappl": 1
}

RESULT_COUNTS_OR_FALSE = {
    "number_of_true": 0,
    "number_of_false": 2,
    "number_of_error": 0,
    "number_of_unknown": 0,
    "number_of_noteval": 0,
    "number_of_notappl": 1
}

RESULT_COUNTS_OR_ERROR = {
    "number_of_true": 0,
    "number_of_false": 2,
    "number_of_error": 3,
    "number_of_unknown": 1,
    "number_of_noteval": 1,
    "number_of_notappl": 1
}

RESULT_COUNTS_OR_UNKNOWN = {
    "number_of_true": 0,
    "number_of_false": 2,
    "number_of_error": 0,
    "number_of_unknown": 3,
    "number_of_noteval": 1,
    "number_of_notappl": 2
}

RESULT_COUNTS_OR_NOTEVAL = {
    "number_of_true": 0,
    "number_of_false": 2,
    "number_of_error": 0,
    "number_of_unknown": 0,
    "number_of_noteval": 3,
    "number_of_notappl": 3
}

# ONE cases
RESULT_COUNTS_ONE_TRUE = {
    "number_of_true": 1,
    "number_of_false": 2,
    "number_of_error": 0,
    "number_of_unknown": 0,
    "number_of_noteval": 0,
    "number_of_notappl": 1
}

RESULT_COUNTS_ONE_FALSE = {
    "number_of_true": 2,
    "number_of_false": 2,
    "number_of_error": 3,
    "number_of_unknown": 5,
    "number_of_noteval": 2,
    "number_of_notappl": 1
}

RESULT_COUNTS_ONE_FALSE_1 = {
    "number_of_true": 0,
    "number_of_false": 2,
    "number_of_error": 0,
    "number_of_unknown": 0,
    "number_of_noteval": 0,
    "number_of_notappl": 1
}

RESULT_COUNTS_ONE_ERROR = {
    "number_of_true": 1,
    "number_of_false": 2,
    "number_of_error": 3,
    "number_of_unknown": 1,
    "number_of_noteval": 1,
    "number_of_notappl": 1
}

RESULT_COUNTS_ONE_UNKNOWN = {
    "number_of_true": 1,
    "number_of_false": 2,
    "number_of_error": 0,
    "number_of_unknown": 3,
    "number_of_noteval": 4,
    "number_of_notappl": 2
}

RESULT_COUNTS_ONE_NOTEVAL = {
    "number_of_true": 1,
    "number_of_false": 2,
    "number_of_error": 0,
    "number_of_unknown": 0,
    "number_of_noteval": 3,
    "number_of_notappl": 6
}

# XOR cases
RESULT_COUNTS_XOR_TRUE = {
    "number_of_true": 7,
    "number_of_false": 5,
    "number_of_error": 0,
    "number_of_unknown": 0,
    "number_of_noteval": 0,
    "number_of_notappl": 1
}

RESULT_COUNTS_XOR_FALSE = {
    "number_of_true": 8,
    "number_of_false": 5,
    "number_of_error": 0,
    "number_of_unknown": 0,
    "number_of_noteval": 0,
    "number_of_notappl": 1
}

RESULT_COUNTS_XOR_ERROR = {
    "number_of_true": 5,
    "number_of_false": 2,
    "number_of_error": 3,
    "number_of_unknown": 1,
    "number_of_noteval": 2,
    "number_of_notappl": 1
}

RESULT_COUNTS_XOR_UNKNOWN = {
    "number_of_true": 2,
    "number_of_false": 2,
    "number_of_error": 0,
    "number_of_unknown": 3,
    "number_of_noteval": 1,
    "number_of_notappl": 2
}

RESULT_COUNTS_XOR_NOTEVAL = {
    "number_of_true": 2,
    "number_of_false": 2,
    "number_of_error": 0,
    "number_of_unknown": 0,
    "number_of_noteval": 3,
    "number_of_notappl": 5
}


@pytest.mark.unit_test
@pytest.mark.parametrize("eval_function, result", [
    (OvalResult(**RESULT_COUNTS_NOTAPPL).is_notapp_result, True),

    (OvalResult(**BAD_RESULT_COUNTS).eval_operator_and, None),
    (OvalResult(**BAD_RESULT_COUNTS).eval_operator_one, None),
    (OvalResult(**BAD_RESULT_COUNTS).eval_operator_or, None),
    (OvalResult(**BAD_RESULT_COUNTS).eval_operator_xor, None),

    (OvalResult(**EMPTY_RESULT).eval_operator_and, None),
    (OvalResult(**EMPTY_RESULT).eval_operator_one, None),
    (OvalResult(**EMPTY_RESULT).eval_operator_or, None),
    (OvalResult(**EMPTY_RESULT).eval_operator_xor, "false"),

    (OvalResult(**RESULT_COUNTS_1).eval_operator_and, "false"),
    (OvalResult(**RESULT_COUNTS_1).eval_operator_one, None),
    (OvalResult(**RESULT_COUNTS_1).eval_operator_or, "true"),
    (OvalResult(**RESULT_COUNTS_1).eval_operator_xor, "error"),

    (OvalResult(**RESULT_COUNTS_AND_TRUE).eval_operator_and, "true"),
    (OvalResult(**RESULT_COUNTS_AND_FALSE).eval_operator_and, "false"),
    (OvalResult(**RESULT_COUNTS_AND_ERROR).eval_operator_and, "error"),
    (OvalResult(**RESULT_COUNTS_AND_UNKNOWN).eval_operator_and, "unknown"),
    (OvalResult(**RESULT_COUNTS_AND_NOTEVAL).eval_operator_and, "noteval"),

    (OvalResult(**RESULT_COUNTS_OR_TRUE).eval_operator_or, "true"),
    (OvalResult(**RESULT_COUNTS_OR_FALSE).eval_operator_or, "false"),
    (OvalResult(**RESULT_COUNTS_OR_ERROR).eval_operator_or, "error"),
    (OvalResult(**RESULT_COUNTS_OR_UNKNOWN).eval_operator_or, "unknown"),
    (OvalResult(**RESULT_COUNTS_OR_NOTEVAL).eval_operator_or, "noteval"),

    (OvalResult(**RESULT_COUNTS_ONE_TRUE).eval_operator_one, "true"),
    (OvalResult(**RESULT_COUNTS_ONE_FALSE).eval_operator_one, "false"),
    (OvalResult(**RESULT_COUNTS_ONE_FALSE_1).eval_operator_one, "false"),
    (OvalResult(**RESULT_COUNTS_ONE_ERROR).eval_operator_one, "error"),
    (OvalResult(**RESULT_COUNTS_ONE_UNKNOWN).eval_operator_one, "unknown"),
    (OvalResult(**RESULT_COUNTS_ONE_NOTEVAL).eval_operator_one, "noteval"),

    (OvalResult(**RESULT_COUNTS_XOR_TRUE).eval_operator_xor, "true"),
    (OvalResult(**RESULT_COUNTS_XOR_FALSE).eval_operator_xor, "false"),
    (OvalResult(**RESULT_COUNTS_XOR_ERROR).eval_operator_xor, "error"),
    (OvalResult(**RESULT_COUNTS_XOR_UNKNOWN).eval_operator_xor, "unknown"),
    (OvalResult(**RESULT_COUNTS_XOR_NOTEVAL).eval_operator_xor, "noteval"),
])
def test_evaluate_oval_result(eval_function, result):
    assert eval_function() is result


1			# Copyright 2022, Red Hat, Inc.
2			# SPDX-License-Identifier: LGPL-2.1-or-later
3
4			import pytest
5
6			from openscap_report.scap_results_parser.data_structures import (EMPTY_RESULT,
7			OvalResult)
8
9			BAD_RESULT_COUNTS = {
10			"number_of_true": -1,
11			"number_of_false": -1,
12			"number_of_error": -1,
13			"number_of_unknown": -1,
14			"number_of_noteval": -1,
15			"number_of_notappl": -1
16			}
17
18			RESULT_COUNTS_1 = {
19			"number_of_true": 3,
20			"number_of_false": 3,
21			"number_of_error": 3,
22			"number_of_unknown": 0,
23			"number_of_noteval": -1,
24			"number_of_notappl": 3
25			}
26
27			RESULT_COUNTS_NOTAPPL = EMPTY_RESULT.copy()
28			RESULT_COUNTS_NOTAPPL["number_of_notappl"] = 5
29
30			# AND cases
31			RESULT_COUNTS_AND_TRUE = {
32			"number_of_true": 2,
33			"number_of_false": 0,
34			"number_of_error": 0,
35			"number_of_unknown": 0,
36			"number_of_noteval": 0,
37			"number_of_notappl": 1
38			}
39
40			RESULT_COUNTS_AND_FALSE = {
41			"number_of_true": 2,
42			"number_of_false": 2,
43			"number_of_error": 0,
44			"number_of_unknown": 1,
45			"number_of_noteval": 1,
46			"number_of_notappl": 1
47			}
48
49			RESULT_COUNTS_AND_ERROR = {
50			"number_of_true": 1,
51			"number_of_false": 0,
52			"number_of_error": 3,
53			"number_of_unknown": 1,
54			"number_of_noteval": 1,
55			"number_of_notappl": 1
56			}
57
58			RESULT_COUNTS_AND_UNKNOWN = {
59			"number_of_true": 0,
60			"number_of_false": 0,
61			"number_of_error": 0,
62			"number_of_unknown": 3,
63			"number_of_noteval": 1,
64			"number_of_notappl": 2
65			}
66
67			RESULT_COUNTS_AND_NOTEVAL = {
68			"number_of_true": 2,
69			"number_of_false": 0,
70			"number_of_error": 0,
71			"number_of_unknown": 0,
72			"number_of_noteval": 3,
73			"number_of_notappl": 2
74			}
75
76			# OR cases
77			RESULT_COUNTS_OR_TRUE = {
78			"number_of_true": 2,
79			"number_of_false": 2,
80			"number_of_error": 0,
81			"number_of_unknown": 2,
82			"number_of_noteval": 0,
83			"number_of_notappl": 1
84			}
85
86			RESULT_COUNTS_OR_FALSE = {
87			"number_of_true": 0,
88			"number_of_false": 2,
89			"number_of_error": 0,
90			"number_of_unknown": 0,
91			"number_of_noteval": 0,
92			"number_of_notappl": 1
93			}
94
95			RESULT_COUNTS_OR_ERROR = {
96			"number_of_true": 0,
97			"number_of_false": 2,
98			"number_of_error": 3,
99			"number_of_unknown": 1,
100			"number_of_noteval": 1,
101			"number_of_notappl": 1
102			}
103
104			RESULT_COUNTS_OR_UNKNOWN = {
105			"number_of_true": 0,
106			"number_of_false": 2,
107			"number_of_error": 0,
108			"number_of_unknown": 3,
109			"number_of_noteval": 1,
110			"number_of_notappl": 2
111			}
112
113			RESULT_COUNTS_OR_NOTEVAL = {
114			"number_of_true": 0,
115			"number_of_false": 2,
116			"number_of_error": 0,
117			"number_of_unknown": 0,
118			"number_of_noteval": 3,
119			"number_of_notappl": 3
120			}
121
122			# ONE cases
123			RESULT_COUNTS_ONE_TRUE = {
124			"number_of_true": 1,
125			"number_of_false": 2,
126			"number_of_error": 0,
127			"number_of_unknown": 0,
128			"number_of_noteval": 0,
129			"number_of_notappl": 1
130			}
131
132			RESULT_COUNTS_ONE_FALSE = {
133			"number_of_true": 2,
134			"number_of_false": 2,
135			"number_of_error": 3,
136			"number_of_unknown": 5,
137			"number_of_noteval": 2,
138			"number_of_notappl": 1
139			}
140
141			RESULT_COUNTS_ONE_FALSE_1 = {
142			"number_of_true": 0,
143			"number_of_false": 2,
144			"number_of_error": 0,
145			"number_of_unknown": 0,
146			"number_of_noteval": 0,
147			"number_of_notappl": 1
148			}
149
150			RESULT_COUNTS_ONE_ERROR = {
151			"number_of_true": 1,
152			"number_of_false": 2,
153			"number_of_error": 3,
154			"number_of_unknown": 1,
155			"number_of_noteval": 1,
156			"number_of_notappl": 1
157			}
158
159			RESULT_COUNTS_ONE_UNKNOWN = {
160			"number_of_true": 1,
161			"number_of_false": 2,
162			"number_of_error": 0,
163			"number_of_unknown": 3,
164			"number_of_noteval": 4,
165			"number_of_notappl": 2
166			}
167
168			RESULT_COUNTS_ONE_NOTEVAL = {
169			"number_of_true": 1,
170			"number_of_false": 2,
171			"number_of_error": 0,
172			"number_of_unknown": 0,
173			"number_of_noteval": 3,
174			"number_of_notappl": 6
175			}
176
177			# XOR cases
178			RESULT_COUNTS_XOR_TRUE = {
179			"number_of_true": 7,
180			"number_of_false": 5,
181			"number_of_error": 0,
182			"number_of_unknown": 0,
183			"number_of_noteval": 0,
184			"number_of_notappl": 1
185			}
186
187			RESULT_COUNTS_XOR_FALSE = {
188			"number_of_true": 8,
189			"number_of_false": 5,
190			"number_of_error": 0,
191			"number_of_unknown": 0,
192			"number_of_noteval": 0,
193			"number_of_notappl": 1
194			}
195
196			RESULT_COUNTS_XOR_ERROR = {
197			"number_of_true": 5,
198			"number_of_false": 2,
199			"number_of_error": 3,
200			"number_of_unknown": 1,
201			"number_of_noteval": 2,
202			"number_of_notappl": 1
203			}
204
205			RESULT_COUNTS_XOR_UNKNOWN = {
206			"number_of_true": 2,
207			"number_of_false": 2,
208			"number_of_error": 0,
209			"number_of_unknown": 3,
210			"number_of_noteval": 1,
211			"number_of_notappl": 2
212			}
213
214			RESULT_COUNTS_XOR_NOTEVAL = {
215			"number_of_true": 2,
216			"number_of_false": 2,
217			"number_of_error": 0,
218			"number_of_unknown": 0,
219			"number_of_noteval": 3,
220			"number_of_notappl": 5
221			}
222
223
224			@pytest.mark.unit_test
225			@pytest.mark.parametrize("eval_function, result", [
226			(OvalResult(**RESULT_COUNTS_NOTAPPL).is_notapp_result, True),
227
228			(OvalResult(**BAD_RESULT_COUNTS).eval_operator_and, None),
229			(OvalResult(**BAD_RESULT_COUNTS).eval_operator_one, None),
230			(OvalResult(**BAD_RESULT_COUNTS).eval_operator_or, None),
231			(OvalResult(**BAD_RESULT_COUNTS).eval_operator_xor, None),
232
233			(OvalResult(**EMPTY_RESULT).eval_operator_and, None),
234			(OvalResult(**EMPTY_RESULT).eval_operator_one, None),
235			(OvalResult(**EMPTY_RESULT).eval_operator_or, None),
236			(OvalResult(**EMPTY_RESULT).eval_operator_xor, "false"),
237
238			(OvalResult(**RESULT_COUNTS_1).eval_operator_and, "false"),
239			(OvalResult(**RESULT_COUNTS_1).eval_operator_one, None),
240			(OvalResult(**RESULT_COUNTS_1).eval_operator_or, "true"),
241			(OvalResult(**RESULT_COUNTS_1).eval_operator_xor, "error"),
242
243			(OvalResult(**RESULT_COUNTS_AND_TRUE).eval_operator_and, "true"),
244			(OvalResult(**RESULT_COUNTS_AND_FALSE).eval_operator_and, "false"),
245			(OvalResult(**RESULT_COUNTS_AND_ERROR).eval_operator_and, "error"),
246			(OvalResult(**RESULT_COUNTS_AND_UNKNOWN).eval_operator_and, "unknown"),
247			(OvalResult(**RESULT_COUNTS_AND_NOTEVAL).eval_operator_and, "noteval"),
248
249			(OvalResult(**RESULT_COUNTS_OR_TRUE).eval_operator_or, "true"),
250			(OvalResult(**RESULT_COUNTS_OR_FALSE).eval_operator_or, "false"),
251			(OvalResult(**RESULT_COUNTS_OR_ERROR).eval_operator_or, "error"),
252			(OvalResult(**RESULT_COUNTS_OR_UNKNOWN).eval_operator_or, "unknown"),
253			(OvalResult(**RESULT_COUNTS_OR_NOTEVAL).eval_operator_or, "noteval"),
254
255			(OvalResult(**RESULT_COUNTS_ONE_TRUE).eval_operator_one, "true"),
256			(OvalResult(**RESULT_COUNTS_ONE_FALSE).eval_operator_one, "false"),
257			(OvalResult(**RESULT_COUNTS_ONE_FALSE_1).eval_operator_one, "false"),
258			(OvalResult(**RESULT_COUNTS_ONE_ERROR).eval_operator_one, "error"),
259			(OvalResult(**RESULT_COUNTS_ONE_UNKNOWN).eval_operator_one, "unknown"),
260			(OvalResult(**RESULT_COUNTS_ONE_NOTEVAL).eval_operator_one, "noteval"),
261
262			(OvalResult(**RESULT_COUNTS_XOR_TRUE).eval_operator_xor, "true"),
263			(OvalResult(**RESULT_COUNTS_XOR_FALSE).eval_operator_xor, "false"),
264			(OvalResult(**RESULT_COUNTS_XOR_ERROR).eval_operator_xor, "error"),
265			(OvalResult(**RESULT_COUNTS_XOR_UNKNOWN).eval_operator_xor, "unknown"),
266			(OvalResult(**RESULT_COUNTS_XOR_NOTEVAL).eval_operator_xor, "noteval"),
267			])
268			def test_evaluate_oval_result(eval_function, result):
269			assert eval_function() is result
270

OpenSCAP / openscap-report

tests.unit_tests.test_oval_result_eval A last analyzed 2024-09-09 11:38 UTC

Complexity

Size/Duplication

Importance

1 Function

Duplication Side-by-Side

Filter issues like

tests.unit_tests.test_oval_result_eval A
last analyzed 2024-09-09 11:38 UTC