test_graph.test_node_operator_negate1() - Code Metrics - Inspection of "Merge pull request #95 from Honny1/reworkOvalNode" - OpenSCAP/oval-graph - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( ee9159...d47bb7 )

by Matěj

created 2020-03-03 15:08 UTC

test_graph.test_node_operator_negate1() A

↳ Parent: test_graph

Complexity

Conditions

Size

Total Lines	11
Code Lines	4

Duplication

Lines	11
Ratio	100 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nop	0
dl	11
loc	11
rs	10
c	0
b	0
f	0

import pytest

from oval_graph.oval_node import OvalNode

import tests.any_test_help

missing_error_pattern = "err - Missing required argument!"

bad_value_error_pattern = (
    r'err - Bad value of (negation|node_type|value) argument(!| for (value|operator) type!)')


def test_bad_tree():
    with pytest.raises(Exception, match="don't has any child"):
        assert bad_tree()


def test_bad_tree_only_and_no_child():
    with pytest.raises(Exception, match="has child!"):
        assert tree_only_and()


def test_bad_tree_only_or_no_child():
    with pytest.raises(Exception, match="has child!"):
        assert tree_only_or()


def test_bad_tree_with_bad_type_of_node():
    with pytest.raises(Exception, match=bad_value_error_pattern):
        assert tree_with_bad_type()


def test_bad_tree_with_bad_value_of_operator():
    with pytest.raises(Exception, match=bad_value_error_pattern):
        assert tree_with_bad_value_of_operator()


def test_bad_tree_with_bad_value_of_value():
    with pytest.raises(Exception, match=bad_value_error_pattern):
        assert tree_with_bad_value_of_value()


def test_bad_tree_with_bad_value_of_negation():
    with pytest.raises(Exception, match=bad_value_error_pattern):
        assert tree_with_bad_value_of_negation()


def test_bad_tree_with_miss_id_argument():
    with pytest.raises(Exception, match=missing_error_pattern):
        assert miss_id_argument()


def test_bad_tree_with_miss_value_argument():
    with pytest.raises(Exception, match=missing_error_pattern):
        assert miss_value_argument()


# degenered trees


def miss_id_argument():
    tree = OvalNode(
        node_type='operator',
        value='and',
        children=[
            OvalNode(
                node_id=2,
                node_type='value',
                value="false",
            ),
        ]
    )
    return


def miss_value_argument():
    tree = OvalNode(
        node_id=1,
        node_type='operator',
        children=[
            OvalNode(
                node_id=2,
                node_type='value',
                value="false",
            ),
        ]
    )
    return


def bad_tree():
    """
         t
         |
        and
         |
         t
    """
    t = OvalNode(
        node_id=1,
        node_type="value",
        value="true",
        children=[
            OvalNode(
                node_id=2,
                node_type="operator",
                value="and",
                children=[
                    OvalNode(
                        node_id=3,
                        node_type="value",
                        value="true",
                    ),
                ]
            ),
        ]
    )
    return


def tree_only_or():
    """
        or
    """
    tree = OvalNode(
        node_id=1,
        node_type="operator",
        value='or',
    )
    return


def tree_only_and():
    """
        and
    """
    tree = OvalNode(
        node_id=1,
        node_type="operator",
        value='and',
    )
    return


def tree_with_bad_value_of_operator():
    tree = OvalNode(
        node_id=1,
        node_type="operator",
        value='nad',
    )
    return


def tree_with_bad_value_of_value():
    tree = OvalNode(
        node_id=1,
        node_type="value",
        value='and',
    )
    return


def tree_with_bad_type():
    tree = OvalNode(
        node_id=1,
        node_type="car",
        value='and',
    )
    return


def tree_with_bad_value_of_negation():
    tree = OvalNode(
        node_id=1,
        node_type="operator",
        value="true",
        children=[
            OvalNode(
                node_id=2,
                node_type="value",
                value='true',
                negation="random_string",
            )
        ]
    )
    return

# normal trees


def test_UPPERCASETree():
    t = OvalNode(
        node_id=1,
        node_type="OPERATOR",
        value="AND",
        children=[
            OvalNode(
                node_id=2,
                node_type="VALUE",
                value="TRUE",
            ),
            OvalNode(
                node_id=3,
                node_type="VALUE",
                value="NOTAPPL",
            ),
        ]
    )
    return


def test_bigOvalTree():
    tree = OvalNode(
        node_id=1,
        node_type='operator',
        value='and',
        children=[
            OvalNode(
                node_id=2,
                node_type='value',
                value="false",
            ),
            OvalNode(
                node_id=3,
                node_type='operator',
                value="xor",
                children=[
                    OvalNode(
                        node_id=4,
                        node_type='value',
                        value='true',
                    ),
                    OvalNode(
                        node_id=5,
                        node_type='operator',
                        value='one',
                        children=[
                            OvalNode(
                                node_id=6,
                                node_type='value',
                                value='noteval',
                            ),
                            OvalNode(
                                node_id=7,
                                node_type='value',
                                value='true',
                            ),
                            OvalNode(
                                node_id=8,
                                node_type='value',
                                value='notappl',
                            ),
                        ]
                    ),
                    OvalNode(
                        node_id=9,
                        node_type='value',
                        value='error',
                    ),
                ]
            ),
            OvalNode(
                node_id=10,
                node_type='operator',
                value='or',
                children=[
                    OvalNode(
                        node_id=11,
                        node_type='value',
                        value="unknown",
                    ),
                    OvalNode(
                        node_id=12,
                        node_type='value',
                        value="true",
                    ),
                ]
            ),
        ]
    )

    test_data_src = 'test_data/bigOvalTree.json'
    dict_of_tree = tests.any_test_help.any_get_test_data_json(test_data_src)
    tests.any_test_help.any_test_treeEvaluation_with_tree(tree, "false")
    tests.any_test_help.any_test_tree_to_dict_of_tree(tree, dict_of_tree)
    tests.any_test_help.find_any_node(tree, 5)
    tests.any_test_help.any_test_dict_to_tree(dict_of_tree)

###################################################


def get_and_false_tree():
    """
        and
         |
         f
    """
    return OvalNode(
        node_id=1,
        node_type='operator',
        value='and',
        children=[
            OvalNode(
                node_id=2,
                node_type='value',
                value="false",
            ),
        ]
    )


def test_treeRepr():
    assert str(get_and_false_tree()) == "and"


def test_add_to_tree():
    test_data_src = 'test_data/add_to_tree.json'
    dict_of_tree = tests.any_test_help.any_get_test_data_json(test_data_src)

    tree = get_and_false_tree()
    tree1 = OvalNode(
        node_id=3,
        node_type='value',
        value="true",
    )
    tree.add_to_tree(1, tree1)
    assert tree.save_tree_to_dict() == dict_of_tree


def test_ChangeValueTree():
    """
        and
        /|\
       t t or
          / \
         f   t
    """
    Tree = OvalNode(
        node_id=1,
        node_type='operator',
        value='and',
        children=[
            OvalNode(
                node_id=2,
                node_type='value',
                value="true",
            ),
            OvalNode(
                node_id=3,
                node_type='value',
                value="false",
            ),
            OvalNode(
                node_id=4,
                node_type='operator',
                value='or',
                children=[
                    OvalNode(
                        node_id=5,
                        node_type='value',
                        value="false",
                    ),
                    OvalNode(
                        node_id=6,
                        node_type='value',
                        value="true",
                    ),
                ]
            ),
        ]
    )

    Tree.change_tree_value(3, "true")
    tests.any_test_help.any_test_treeEvaluation_with_tree(Tree, "true")


def test_node_operator_negate():
    """
        !and
         |
         f
    """
    tree = OvalNode(
        node_id=1,
        node_type='operator',
        value='and',
        negation=True,
        children=[
            OvalNode(
                node_id=2,
                node_type='value',
                value="false",
            ),
        ]
    )
    tests.any_test_help.any_test_treeEvaluation_with_tree(tree, "true")


def test_node_value_negate():
    """
        and
         |
         !f
    """
    tree = OvalNode(
        node_id=1,
        node_type='operator',
        value='and',
        children=[
            OvalNode(
                node_id=2,
                node_type='value',
                value="false",
                negation=True,
            ),
        ]
    )
    tests.any_test_help.any_test_treeEvaluation_with_tree(tree, "true")


def test_node_value_negate1():
    """
        and
         |
         !t
    """

    tree = OvalNode(
        node_id=1,
        node_type='operator',
        value='and',
        children=[
            OvalNode(
                node_id=2,
                node_type='value',
                value="true",
                negation=True,
            ),
        ]
    )
    tests.any_test_help.any_test_treeEvaluation_with_tree(tree, "false")


1			import pytest
2
3			from oval_graph.oval_node import OvalNode
4
5			import tests.any_test_help
6
7			missing_error_pattern = "err - Missing required argument!"
8
9			bad_value_error_pattern = (
10			r'err - Bad value of (negation\|node_type\|value) argument(!\| for (value\|operator) type!)')
11
12
13			def test_bad_tree():
14			with pytest.raises(Exception, match="don't has any child"):
15			assert bad_tree()
16
17
18			def test_bad_tree_only_and_no_child():
19			with pytest.raises(Exception, match="has child!"):
20			assert tree_only_and()
21
22
23			def test_bad_tree_only_or_no_child():
24			with pytest.raises(Exception, match="has child!"):
25			assert tree_only_or()
26
27
28			def test_bad_tree_with_bad_type_of_node():
29			with pytest.raises(Exception, match=bad_value_error_pattern):
30			assert tree_with_bad_type()
31
32
33			def test_bad_tree_with_bad_value_of_operator():
34			with pytest.raises(Exception, match=bad_value_error_pattern):
35			assert tree_with_bad_value_of_operator()
36
37
38			def test_bad_tree_with_bad_value_of_value():
39			with pytest.raises(Exception, match=bad_value_error_pattern):
40			assert tree_with_bad_value_of_value()
41
42
43			def test_bad_tree_with_bad_value_of_negation():
44			with pytest.raises(Exception, match=bad_value_error_pattern):
45			assert tree_with_bad_value_of_negation()
46
47
48			def test_bad_tree_with_miss_id_argument():
49			with pytest.raises(Exception, match=missing_error_pattern):
50			assert miss_id_argument()
51
52
53			def test_bad_tree_with_miss_value_argument():
54			with pytest.raises(Exception, match=missing_error_pattern):
55			assert miss_value_argument()
56
57
58			# degenered trees
59
60
61			def miss_id_argument():
62			tree = OvalNode(
63			node_type='operator',
64			value='and',
65			children=[
66			OvalNode(
67			node_id=2,
68			node_type='value',
69			value="false",
70			),
71			]
72			)
73			return
74
75
76			def miss_value_argument():
77			tree = OvalNode(
78			node_id=1,
79			node_type='operator',
80			children=[
81			OvalNode(
82			node_id=2,
83			node_type='value',
84			value="false",
85			),
86			]
87			)
88			return
89
90
91			def bad_tree():
92			"""
93			t
94			\|
95			and
96			\|
97			t
98			"""
99			t = OvalNode(
100			node_id=1,
101			node_type="value",
102			value="true",
103			children=[
104			OvalNode(
105			node_id=2,
106			node_type="operator",
107			value="and",
108			children=[
109			OvalNode(
110			node_id=3,
111			node_type="value",
112			value="true",
113			),
114			]
115			),
116			]
117			)
118			return
119
120
121			def tree_only_or():
122			"""
123			or
124			"""
125			tree = OvalNode(
126			node_id=1,
127			node_type="operator",
128			value='or',
129			)
130			return
131
132
133			def tree_only_and():
134			"""
135			and
136			"""
137			tree = OvalNode(
138			node_id=1,
139			node_type="operator",
140			value='and',
141			)
142			return
143
144
145			def tree_with_bad_value_of_operator():
146			tree = OvalNode(
147			node_id=1,
148			node_type="operator",
149			value='nad',
150			)
151			return
152
153
154			def tree_with_bad_value_of_value():
155			tree = OvalNode(
156			node_id=1,
157			node_type="value",
158			value='and',
159			)
160			return
161
162
163			def tree_with_bad_type():
164			tree = OvalNode(
165			node_id=1,
166			node_type="car",
167			value='and',
168			)
169			return
170
171
172			def tree_with_bad_value_of_negation():
173			tree = OvalNode(
174			node_id=1,
175			node_type="operator",
176			value="true",
177			children=[
178			OvalNode(
179			node_id=2,
180			node_type="value",
181			value='true',
182			negation="random_string",
183			)
184			]
185			)
186			return
187
188			# normal trees
189
190
191			def test_UPPERCASETree():
192			t = OvalNode(
193			node_id=1,
194			node_type="OPERATOR",
195			value="AND",
196			children=[
197			OvalNode(
198			node_id=2,
199			node_type="VALUE",
200			value="TRUE",
201			),
202			OvalNode(
203			node_id=3,
204			node_type="VALUE",
205			value="NOTAPPL",
206			),
207			]
208			)
209			return
210
211
212			def test_bigOvalTree():
213			tree = OvalNode(
214			node_id=1,
215			node_type='operator',
216			value='and',
217			children=[
218			OvalNode(
219			node_id=2,
220			node_type='value',
221			value="false",
222			),
223			OvalNode(
224			node_id=3,
225			node_type='operator',
226			value="xor",
227			children=[
228			OvalNode(
229			node_id=4,
230			node_type='value',
231			value='true',
232			),
233			OvalNode(
234			node_id=5,
235			node_type='operator',
236			value='one',
237			children=[
238			OvalNode(
239			node_id=6,
240			node_type='value',
241			value='noteval',
242			),
243			OvalNode(
244			node_id=7,
245			node_type='value',
246			value='true',
247			),
248			OvalNode(
249			node_id=8,
250			node_type='value',
251			value='notappl',
252			),
253			]
254			),
255			OvalNode(
256			node_id=9,
257			node_type='value',
258			value='error',
259			),
260			]
261			),
262			OvalNode(
263			node_id=10,
264			node_type='operator',
265			value='or',
266			children=[
267			OvalNode(
268			node_id=11,
269			node_type='value',
270			value="unknown",
271			),
272			OvalNode(
273			node_id=12,
274			node_type='value',
275			value="true",
276			),
277			]
278			),
279			]
280			)
281
282			test_data_src = 'test_data/bigOvalTree.json'
283			dict_of_tree = tests.any_test_help.any_get_test_data_json(test_data_src)
284			tests.any_test_help.any_test_treeEvaluation_with_tree(tree, "false")
285			tests.any_test_help.any_test_tree_to_dict_of_tree(tree, dict_of_tree)
286			tests.any_test_help.find_any_node(tree, 5)
287			tests.any_test_help.any_test_dict_to_tree(dict_of_tree)
288
289			###################################################
290
291
292			def get_and_false_tree():
293			"""
294			and
295			\|
296			f
297			"""
298			return OvalNode(
299			node_id=1,
300			node_type='operator',
301			value='and',
302			children=[
303			OvalNode(
304			node_id=2,
305			node_type='value',
306			value="false",
307			),
308			]
309			)
310
311
312			def test_treeRepr():
313			assert str(get_and_false_tree()) == "and"
314
315
316			def test_add_to_tree():
317			test_data_src = 'test_data/add_to_tree.json'
318			dict_of_tree = tests.any_test_help.any_get_test_data_json(test_data_src)
319
320			tree = get_and_false_tree()
321			tree1 = OvalNode(
322			node_id=3,
323			node_type='value',
324			value="true",
325			)
326			tree.add_to_tree(1, tree1)
327			assert tree.save_tree_to_dict() == dict_of_tree
328
329
330			def test_ChangeValueTree():
331			"""
332			and
333			/\|\
334			t t or
335			/ \
336			f t
337			"""
338			Tree = OvalNode(
339			node_id=1,
340			node_type='operator',
341			value='and',
342			children=[
343			OvalNode(
344			node_id=2,
345			node_type='value',
346			value="true",
347			),
348			OvalNode(
349			node_id=3,
350			node_type='value',
351			value="false",
352			),
353			OvalNode(
354			node_id=4,
355			node_type='operator',
356			value='or',
357			children=[
358			OvalNode(
359			node_id=5,
360			node_type='value',
361			value="false",
362			),
363			OvalNode(
364			node_id=6,
365			node_type='value',
366			value="true",
367			),
368			]
369			),
370			]
371			)
372
373			Tree.change_tree_value(3, "true")
374			tests.any_test_help.any_test_treeEvaluation_with_tree(Tree, "true")
375
376
377			def test_node_operator_negate():
378			"""
379			!and
380			\|
381			f
382			"""
383			tree = OvalNode(
384			node_id=1,
385			node_type='operator',
386			value='and',
387			negation=True,
388			children=[
389			OvalNode(
390			node_id=2,
391			node_type='value',
392			value="false",
393			),
394			]
395			)
396			tests.any_test_help.any_test_treeEvaluation_with_tree(tree, "true")
397
398
399			def test_node_value_negate():
400			"""
401			and
402			\|
403			!f
404			"""
405			tree = OvalNode(
406			node_id=1,
407			node_type='operator',
408			value='and',
409			children=[
410			OvalNode(
411			node_id=2,
412			node_type='value',
413			value="false",
414			negation=True,
415			),
416			]
417			)
418			tests.any_test_help.any_test_treeEvaluation_with_tree(tree, "true")
419
420
421			def test_node_value_negate1():
422			"""
423			and
424			\|
425			!t
426			"""
427
428			tree = OvalNode(
429			node_id=1,
430			node_type='operator',
431			value='and',
432			children=[
433			OvalNode(
434			node_id=2,
435			node_type='value',
436			value="true",
437			negation=True,
438			),
439			]
440			)
441			tests.any_test_help.any_test_treeEvaluation_with_tree(tree, "false")
442

OpenSCAP / oval-graph

Push — master ( ee9159...d47bb7 )

test_graph.test_node_operator_negate1() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like