test_oval_node.test_bad_tree() - Code Metrics - Inspection of "[WIP] Rework tests for command line client" - OpenSCAP/oval-graph - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#203)

by Jan

created 2021-06-25 19:13 UTC

test_oval_node.test_bad_tree() A

↳ Parent: test_oval_node

Complexity

Conditions

Size

Total Lines	3
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	3
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

import json
import os

import pytest

from oval_graph.oval_tree.builder import Builder
from oval_graph.oval_tree.converter import Converter
from oval_graph.oval_tree.oval_node import OvalNode

BAD_VALUE_ERROR_PATTERN = (
    r'Wrong value of (negation|node_type|argument) (argument|value)(!| for (value|operator) node!)'
)


def test_bad_tree():
    with pytest.raises(Exception, match="cannot contain any child"):
        assert get_bad_tree()


def test_bad_tree_only_and_no_child():
    with pytest.raises(Exception, match="must have a child"):
        assert get_tree_only_and()


def test_bad_tree_only_or_no_child():
    with pytest.raises(Exception, match="must have a child"):
        assert get_tree_only_or()


def test_bad_tree_with_bad_type_of_node():
    with pytest.raises(Exception, match=BAD_VALUE_ERROR_PATTERN):
        assert get_tree_with_bad_type()


def test_bad_tree_with_bad_value_of_operator():
    with pytest.raises(Exception, match=BAD_VALUE_ERROR_PATTERN):
        assert get_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 get_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 get_tree_with_bad_value_of_negation()


# Degenered trees

def get_bad_tree():
    """
         t
         |
        and
         |
         t
    """
    return 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",
                    ),
                ]
            ),
        ]
    )


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


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


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


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


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


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


# normal trees


def test_uppercase_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="NOTAPPL",
            ),
        ]
    )


def get_big_oval_tree():
    return 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",
                    ),
                ]
            ),
        ]
    )


def test_eval_big_tree():
    assert get_big_oval_tree().evaluate_tree() == 'false'


# fix 11, 12 ids
@pytest.mark.parametrize("node_id", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
def test_find_node_with_id(node_id):
    assert get_big_oval_tree().find_node_with_id(node_id).node_id == node_id


@pytest.mark.parametrize("node_id", [0, 111, 212, 432, 342, -1])
def test_bad_find_node_with_id(node_id):
    assert get_big_oval_tree().find_node_with_id(node_id) is None


def test_build_and_convert_json_tree():
    test_data_src = 'test_data/bigOvalTree.json'
    dict_of_tree = get_test_data_json(test_data_src)
    treedict_of_tree = Builder.dict_to_oval_tree(dict_of_tree)
    assert Converter(treedict_of_tree).to_dict() == 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_tree_repr():
    assert str(get_and_false_tree()) == "and"


def get_test_data_json(src):
    top_patch = os.path.dirname(os.path.realpath(__file__))
    patch = os.path.join(top_patch, src)
    with open(patch, 'r') as f:
        return json.load(f)


def test_add_to_tree():
    test_data_src = 'test_data/add_to_tree.json'
    dict_of_tree = get_test_data_json(test_data_src)

    tree = get_and_false_tree()
    tree_node = OvalNode(
        node_id=3,
        node_type='value',
        value="true",
    )
    tree.add_child_to_node(1, tree_node)
    assert Converter(tree).to_dict() == dict_of_tree


def test_change_value_tree():
    """ Created tree
        and
        /|\
       t f 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",
                    ),
                ]
            ),
        ]
    )

    assert tree.evaluate_tree() == 'false'
    tree.change_value_of_node(3, "true")
    assert tree.evaluate_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",
            ),
        ]
    )
    assert tree.evaluate_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,
            ),
        ]
    )
    assert tree.evaluate_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,
            ),
        ]
    )
    assert tree.evaluate_tree() == "false"


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

OpenSCAP / oval-graph

Pull Request — master (#203)

test_oval_node.test_bad_tree() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like