test_oval_node

Complexity

Total Complexity

36

Size/Duplication

Total Lines	416
Duplicated Lines	0 %

Importance

Changes

0

28 Functions

Rating	Name	Duplication	Size	Complexity
A	test_eval_big_tree()	0	2	1
A	get_tree_only_or()	0	8	1
A	get_tree_with_bad_type()	0	5	1
A	test_bad_tree_with_bad_value_of_negation()	0	3	2
B	get_big_oval_tree()	0	64	1
A	test_bad_tree_with_bad_value_of_value()	0	3	2
A	test_bad_tree_only_and_no_child()	0	3	2
A	get_tree_with_bad_value_of_negation()	0	11	1
A	get_tree_only_and()	0	8	1
A	test_bad_tree_with_bad_type_of_node()	0	3	2
A	test_bad_tree_with_bad_value_of_operator()	0	3	2
A	test_bad_tree_only_or_no_child()	0	3	2
A	test_bad_tree()	0	3	2
A	get_bad_tree()	0	22	1
A	get_tree_with_bad_value_of_value()	0	5	1
A	test_uppercase_tree()	0	15	1
A	get_tree_with_bad_value_of_operator()	0	5	1
A	test_add_to_tree()	0	12	1
A	test_tree_repr()	0	2	1
A	test_bad_find_node_with_id()	0	3	1
A	test_node_operator_negate()	0	20	1
A	get_test_data_json()	0	5	2
A	test_node_value_negate1()	0	20	1
A	test_build_and_convert_json_tree()	0	5	1
A	get_and_false_tree()	0	15	1
A	test_change_value_tree()	0	46	1
A	test_node_value_negate()	0	20	1
A	test_find_node_with_id()	0	3	1

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"