test_oval_node.get_big_oval_tree() - Code Metrics - Inspection of "[WIP] Rework test suite" - OpenSCAP/oval-graph - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#200)

by Jan

created 2021-06-16 14:09 UTC

test_oval_node.get_big_oval_tree() B

↳ Parent: test_oval_node

Complexity

Conditions

Size

Total Lines	64
Code Lines	53

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	53
nop	0
dl	0
loc	64
rs	8.5381
c	0
b	0
f	0

How to fix Long Method

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'


def test_find_node_with_id():
    assert get_big_oval_tree().find_node_with_id(5).node_id == 5


def test_badfind_node_with_id():
    assert get_big_oval_tree().find_node_with_id(100) 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			def test_find_node_with_id():
242			assert get_big_oval_tree().find_node_with_id(5).node_id == 5
243
244
245			def test_badfind_node_with_id():
246			assert get_big_oval_tree().find_node_with_id(100) is None
247
248
249			def test_build_and_convert_json_tree():
250			test_data_src = 'test_data/bigOvalTree.json'
251			dict_of_tree = get_test_data_json(test_data_src)
252			treedict_of_tree = Builder.dict_to_oval_tree(dict_of_tree)
253			assert Converter(treedict_of_tree).to_dict() == dict_of_tree
254
255
256			def get_and_false_tree():
257			"""
258			and
259			\|
260			f
261			"""
262			return OvalNode(
263			node_id=1,
264			node_type='operator',
265			value='and',
266			children=[
267			OvalNode(
268			node_id=2,
269			node_type='value',
270			value="false",
271			),
272			]
273			)
274
275
276			def test_tree_repr():
277			assert str(get_and_false_tree()) == "and"
278
279
280			def get_test_data_json(src):
281			top_patch = os.path.dirname(os.path.realpath(__file__))
282			patch = os.path.join(top_patch, src)
283			with open(patch, 'r') as f:
284			return json.load(f)
285
286
287			def test_add_to_tree():
288			test_data_src = 'test_data/add_to_tree.json'
289			dict_of_tree = get_test_data_json(test_data_src)
290
291			tree = get_and_false_tree()
292			tree_node = OvalNode(
293			node_id=3,
294			node_type='value',
295			value="true",
296			)
297			tree.add_child_to_node(1, tree_node)
298			assert Converter(tree).to_dict() == dict_of_tree
299
300
301			def test_change_value_tree():
302			""" Created tree
303			and
304			/\|\
305			t f or
306			/ \
307			f t
308			"""
309			tree = OvalNode(
310			node_id=1,
311			node_type='operator',
312			value='and',
313			children=[
314			OvalNode(
315			node_id=2,
316			node_type='value',
317			value="true",
318			),
319			OvalNode(
320			node_id=3,
321			node_type='value',
322			value="false",
323			),
324			OvalNode(
325			node_id=4,
326			node_type='operator',
327			value='or',
328			children=[
329			OvalNode(
330			node_id=5,
331			node_type='value',
332			value="false",
333			),
334			OvalNode(
335			node_id=6,
336			node_type='value',
337			value="true",
338			),
339			]
340			),
341			]
342			)
343
344			assert tree.evaluate_tree() == 'false'
345			tree.change_value_of_node(3, "true")
346			assert tree.evaluate_tree() == "true"
347
348
349			def test_node_operator_negate():
350			"""
351			!and
352			\|
353			f
354			"""
355			tree = OvalNode(
356			node_id=1,
357			node_type='operator',
358			value='and',
359			negation=True,
360			children=[
361			OvalNode(
362			node_id=2,
363			node_type='value',
364			value="false",
365			),
366			]
367			)
368			assert tree.evaluate_tree() == "true"
369
370
371			def test_node_value_negate():
372			"""
373			and
374			\|
375			!f
376			"""
377			tree = OvalNode(
378			node_id=1,
379			node_type='operator',
380			value='and',
381			children=[
382			OvalNode(
383			node_id=2,
384			node_type='value',
385			value="false",
386			negation=True,
387			),
388			]
389			)
390			assert tree.evaluate_tree() == "true"
391
392
393			def test_node_value_negate1():
394			"""
395			and
396			\|
397			!t
398			"""
399			tree = OvalNode(
400			node_id=1,
401			node_type='operator',
402			value='and',
403			children=[
404			OvalNode(
405			node_id=2,
406			node_type='value',
407			value="true",
408			negation=True,
409			),
410			]
411			)
412			assert tree.evaluate_tree() == "false"
413

OpenSCAP / oval-graph

Pull Request — master (#200)

test_oval_node.get_big_oval_tree() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like