File: asserts.py

package info (click to toggle)
python-junit-xml 1.9-6
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 160 kB
  • sloc: python: 892; makefile: 21
file content (83 lines) | stat: -rw-r--r-- 3,137 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def verify_test_case(  # noqa: E302
    test_case_element,
    expected_attributes,
    error_message=None,
    error_output=None,
    error_type=None,
    failure_message=None,
    failure_output=None,
    failure_type=None,
    skipped_message=None,
    skipped_output=None,
    stdout=None,
    stderr=None,
    errors=None,
    failures=None,
    skipped=None,
):
    for k, v in expected_attributes.items():
        assert test_case_element.attributes[k].value == v

    for k in test_case_element.attributes.keys():
        assert k in expected_attributes.keys()

        if stderr:
            assert test_case_element.getElementsByTagName("system-err")[0].firstChild.nodeValue.strip() == stderr
        if stdout:
            assert test_case_element.getElementsByTagName("system-out")[0].firstChild.nodeValue.strip() == stdout

        _errors = test_case_element.getElementsByTagName("error")
        if error_message or error_output:
            assert len(_errors) > 0
        elif errors:
            assert len(errors) == len(_errors)
        else:
            assert len(_errors) == 0

        if error_message:
            assert _errors[0].attributes["message"].value == error_message

        if error_type and _errors:
            assert _errors[0].attributes["type"].value == error_type

        if error_output:
            assert _errors[0].firstChild.nodeValue.strip() == error_output

        for error_exp, error_r in zip(errors or [], _errors):
            assert error_r.attributes["message"].value == error_exp["message"]
            assert error_r.firstChild.nodeValue.strip() == error_exp["output"]
            assert error_r.attributes["type"].value == error_exp["type"]

        _failures = test_case_element.getElementsByTagName("failure")
        if failure_message or failure_output:
            assert len(_failures) > 0
        elif failures:
            assert len(failures) == len(_failures)
        else:
            assert len(_failures) == 0

        if failure_message:
            assert _failures[0].attributes["message"].value == failure_message

        if failure_type and _failures:
            assert _failures[0].attributes["type"].value == failure_type

        if failure_output:
            assert _failures[0].firstChild.nodeValue.strip() == failure_output

        for failure_exp, failure_r in zip(failures or [], _failures):
            assert failure_r.attributes["message"].value == failure_exp["message"]
            assert failure_r.firstChild.nodeValue.strip() == failure_exp["output"]
            assert failure_r.attributes["type"].value == failure_exp["type"]

        _skipped = test_case_element.getElementsByTagName("skipped")
        if skipped_message or skipped_output:
            assert len(_skipped) > 0
        elif skipped:
            assert len(skipped) == len(_skipped)
        else:
            assert len(_skipped) == 0

        for skipped_exp, skipped_r in zip(skipped or [], _skipped):
            assert skipped_r.attributes["message"].value == skipped_exp["message"]
            assert skipped_r.firstChild.nodeValue.strip() == skipped_exp["output"]