def test_multiple_skipped():
"""Tests multiple skipped messages in one test case"""
tc = Case("Multiple skipped", allow_multiple_subelements=True)
tc.add_skipped_info("First skipped", "First skipped message")
(_, tcs) = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(tcs[0], {"name": "Multiple skipped"},
skipped=[{
"message": "First skipped",
"output": "First skipped message"
}])
tc.add_skipped_info("Second skipped", "Second skipped message")
(_, tcs) = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(
tcs[0],
{"name": "Multiple skipped"},
skipped=[
{
"message": "First skipped",
"output": "First skipped message"
},
{
"message": "Second skipped",
"output": "Second skipped message"
},
],
)
def test_multiple_errors():
"""Tests multiple errors in one test case"""
tc = Case("Multiple error", allow_multiple_subelements=True)
tc.add_error_info("First error", "First error message")
(_, tcs) = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(
tcs[0],
{"name": "Multiple error"},
errors=[{
"message": "First error",
"output": "First error message",
"type": "error"
}],
)
tc.add_error_info("Second error", "Second error message")
(_, tcs) = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(
tcs[0],
{"name": "Multiple error"},
errors=[
{
"message": "First error",
"output": "First error message",
"type": "error"
},
{
"message": "Second error",
"output": "Second error message",
"type": "error"
},
],
)
def test_multiple_failures():
"""Tests multiple failures in one test case"""
tc = Case("Multiple failures", allow_multiple_subelements=True)
tc.add_failure_info("First failure", "First failure message")
(_, tcs) = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(
tcs[0],
{"name": "Multiple failures"},
failures=[{
"message": "First failure",
"output": "First failure message",
"type": "failure"
}],
)
tc.add_failure_info("Second failure", "Second failure message")
(_, tcs) = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(
tcs[0],
{"name": "Multiple failures"},
failures=[
{
"message": "First failure",
"output": "First failure message",
"type": "failure"
},
{
"message": "Second failure",
"output": "Second failure message",
"type": "failure"
},
],
)
def test_multiple_suites_to_string():
tss = [Suite("suite1", [Case("Test1")]), Suite("suite2", [Case("Test2")])]
suites = serialize_and_read(tss)
assert suites[0][0].attributes["name"].value == "suite1"
verify_test_case(suites[0][1][0], {"name": "Test1"})
assert suites[1][0].attributes["name"].value == "suite2"
verify_test_case(suites[1][1][0], {"name": "Test2"})
def test_init_failure_type():
tc = Case("Failure-Type")
tc.add_failure_info(failure_type="com.example.Error")
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(tcs[0], {"name": "Failure-Type"})
tc.add_failure_info("failure message")
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(tcs[0], {"name": "Failure-Type"},
failure_message="failure message",
failure_type="com.example.Error")
def test_init_error_type():
tc = Case("Error-Type")
tc.add_error_info(error_type="com.example.Error")
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(tcs[0], {"name": "Error-Type"})
tc.add_error_info("error message")
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(tcs[0], {"name": "Error-Type"},
error_message="error message",
error_type="com.example.Error")
def test_init_stdout_stderr():
#pylint: disable=unused-variable
ts, tcs = serialize_and_read(
Suite(
"test",
[
Case(
name="Test1",
classname="some.class.name",
elapsed_sec=123.345,
stdout="I am stdout!",
stderr="I am stderr!",
)
],
))[0]
verify_test_case(
tcs[0],
{
"name": "Test1",
"classname": "some.class.name",
"time": ("%f" % 123.345)
},
stdout="I am stdout!",
stderr="I am stderr!",
)
def test_init_utf8():
tc = Case(
name="Test äöü",
classname="some.class.name.äöü",
elapsed_sec=123.345,
stdout="I am stdöüt!",
stderr="I am stdärr!",
)
tc.add_skipped_info(message="Skipped äöü", output="I skippäd!")
tc.add_error_info(message="Skipped error äöü",
output="I skippäd with an error!")
test_suite = Suite("Test UTF-8", [tc])
#pylint: disable=unused-variable
ts, tcs = serialize_and_read(test_suite, encoding="utf-8")[0]
verify_test_case(
tcs[0],
{
"name": decode("Test äöü", "utf-8"),
"classname": decode("some.class.name.äöü", "utf-8"),
"time": ("%f" % 123.345),
},
stdout=decode("I am stdöüt!", "utf-8"),
stderr=decode("I am stdärr!", "utf-8"),
skipped_message=decode("Skipped äöü", "utf-8"),
skipped_output=decode("I skippäd!", "utf-8"),
error_message=decode("Skipped error äöü", "utf-8"),
error_output=decode("I skippäd with an error!", "utf-8"),
)
def test_init_skipped_output():
tc = Case("Skipped-Output")
tc.add_skipped_info(output="I skipped!")
#pylint: disable=unused-variable
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(tcs[0], {"name": "Skipped-Output"},
skipped_output="I skipped!")
def test_init_skipped_message():
tc = Case("Skipped-Message")
tc.add_skipped_info("skipped message")
#pylint: disable=unused-variable
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(tcs[0], {"name": "Skipped-Message"},
skipped_message="skipped message")
def test_init_error_output():
tc = Case("Error-Output")
tc.add_error_info(output="I errored!")
#pylint: disable=unused-variable
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(tcs[0], {"name": "Error-Output"},
error_output="I errored!")
def test_init_error_message():
tc = Case("Error-Message")
tc.add_error_info("error message")
#pylint: disable=unused-variable
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(tcs[0], {"name": "Error-Message"},
error_message="error message")
def test_stderr():
suites = serialize_and_read(
Suite(name="test",
stderr="I am stderr!",
test_cases=[Case(name="Test1")]))[0]
assert suites[0].getElementsByTagName(
"system-err")[0].firstChild.data == "I am stderr!"
def test_single_suite_no_test_cases_unicode():
properties = {decode("foö", "utf-8"): decode("bär", "utf-8")}
package = decode("mypäckage", "utf-8")
timestamp = 1398382805
#pylint: disable=unused-variable
ts, tcs = serialize_and_read(
Suite(
name=decode("äöü", "utf-8"),
test_cases=[],
hostname=decode("löcalhost", "utf-8"),
id=decode("äöü", "utf-8"),
properties=properties,
package=package,
timestamp=timestamp,
),
to_file=True,
prettyprint=True,
encoding="utf-8",
)[0]
assert ts.tagName == "testsuite"
assert ts.attributes["package"].value == package
assert ts.attributes["timestamp"].value, str(timestamp)
assert ts.childNodes[0].childNodes[0].attributes["name"].value == decode(
"foö", "utf-8")
assert ts.childNodes[0].childNodes[0].attributes["value"].value == decode(
"bär", "utf-8")
def test_init_illegal_unicode_char():
tc = Case("Failure-Message")
tc.add_failure_info(u("failure message with illegal unicode char: [\x02]"))
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(
tcs[0], {"name": "Failure-Message"},
failure_message=u("failure message with illegal unicode char: []"))
def test_init_skipped():
tc = Case("Skipped-Message-and-Output")
tc.add_skipped_info("skipped message", "I skipped!")
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(tcs[0], {"name": "Skipped-Message-and-Output"},
skipped_message="skipped message",
skipped_output="I skipped!")
def test_attribute_disable():
tc = Case("Disabled-Test")
tc.is_enabled = False
tss = [Suite("suite1", [tc])]
suites = serialize_and_read(tss)
assert suites[0][0].attributes["disabled"].value == "1"
def test_init_failure_output():
tc = Case("Failure-Output")
tc.add_failure_info(output="I failed!")
#pylint: disable=unused-variable
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(tcs[0], {"name": "Failure-Output"},
failure_output="I failed!")
def test_init_unicode():
tc = Case(
name=decode("Test äöü", "utf-8"),
classname=decode("some.class.name.äöü", "utf-8"),
elapsed_sec=123.345,
stdout=decode("I am stdöüt!", "utf-8"),
stderr=decode("I am stdärr!", "utf-8"),
)
tc.add_skipped_info(message=decode("Skipped äöü", "utf-8"),
output=decode("I skippäd!", "utf-8"))
tc.add_error_info(message=decode("Skipped error äöü", "utf-8"),
output=decode("I skippäd with an error!", "utf-8"))
ts, tcs = serialize_and_read(Suite("Test Unicode", [tc]))[0]
verify_test_case(
tcs[0],
{
"name": decode("Test äöü", "utf-8"),
"classname": decode("some.class.name.äöü", "utf-8"),
"time": ("%f" % 123.345),
},
stdout=decode("I am stdöüt!", "utf-8"),
stderr=decode("I am stdärr!", "utf-8"),
skipped_message=decode("Skipped äöü", "utf-8"),
skipped_output=decode("I skippäd!", "utf-8"),
error_message=decode("Skipped error äöü", "utf-8"),
error_output=decode("I skippäd with an error!", "utf-8"),
)
def test_init_failure_message():
tc = Case("Failure-Message")
tc.add_failure_info("failure message")
#pylint: disable=unused-variable
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(tcs[0], {"name": "Failure-Message"},
failure_message="failure message")
def test_init_skipped_err_output():
tc = Case("Skipped-Output")
tc.add_skipped_info(output="I skipped!")
tc.add_error_info(output="I skipped with an error!")
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(tcs[0], {"name": "Skipped-Output"},
skipped_output="I skipped!",
error_output="I skipped with an error!")
def test_init_legal_unicode_char():
tc = Case("Failure-Message")
tc.add_failure_info(u("failure message with legal unicode char: [\x22]"))
#pylint: disable=unused-variable
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(
tcs[0], {"name": "Failure-Message"},
failure_message=u("failure message with legal unicode char: [\x22]"))
def test_init_classname_time():
ts, tcs = serialize_and_read(
Suite("test", [
Case(
name="Test1", classname="some.class.name", elapsed_sec=123.345)
]))[0]
verify_test_case(tcs[0], {
"name": "Test1",
"classname": "some.class.name",
"time": ("%f" % 123.345)
})
def test_attribute_time():
tss = [
Suite(
"suite1",
[
Case(name="Test1", classname="some.class.name", elapsed_sec=123.345),
Case(name="Test2", classname="some2.class.name", elapsed_sec=123.345),
],
),
Suite("suite2", [Case("Test2")]),
]
suites = serialize_and_read(tss)
assert suites[0][0].attributes["name"].value == "suite1"
assert suites[0][0].attributes["time"].value == "246.69"
assert suites[1][0].attributes["name"].value == "suite2"
# here the time in testsuite is "0" even there is no attribute time for
# testcase
assert suites[1][0].attributes["time"].value == "0"
def test_init_failure():
tc = Case("Failure-Message-and-Output")
tc.add_failure_info("failure message", "I failed!")
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(
tcs[0],
{"name": "Failure-Message-and-Output"},
failure_message="failure message",
failure_output="I failed!",
failure_type="failure",
)
def test_to_xml_string():
test_suites = [
Suite(name="suite1", test_cases=[Case(name="Test1")]),
Suite(name="suite2", test_cases=[Case(name="Test2")]),
]
xml_string = to_xml_report_string(test_suites)
if PY2:
assert isinstance(xml_string, unicode) # pylint: disable=undefined-variable
expected_xml_string = textwrap.dedent("""
<?xml version="1.0" ?>
<testsuites disabled="0" errors="0" failures="0" tests="2" time="0.0">
\t<testsuite disabled="0" errors="0" failures="0" name="suite1" skipped="0" tests="1" time="0">
\t\t<testcase name="Test1"/>
\t</testsuite>
\t<testsuite disabled="0" errors="0" failures="0" name="suite2" skipped="0" tests="1" time="0">
\t\t<testcase name="Test2"/>
\t</testsuite>
</testsuites>
""".strip("\n"))
assert xml_string == expected_xml_string
def test_init_error():
tc = Case("Error-Message-and-Output")
tc.add_error_info("error message", "I errored!")
ts, tcs = serialize_and_read(Suite("test", [tc]))[0]
verify_test_case(
tcs[0],
{"name": "Error-Message-and-Output"},
error_message="error message",
error_output="I errored!",
error_type="error",
)
def test_init_classname_time_timestamp():
#pylint: disable=unused-variable
ts, tcs = serialize_and_read(
Suite("test", [
Case(name="Test1",
classname="some.class.name",
elapsed_sec=123.345,
timestamp=99999)
]))[0]
verify_test_case(
tcs[0], {
"name": "Test1",
"classname": "some.class.name",
"time": ("%f" % 123.345),
"timestamp": ("%s" % 99999)
})
def test_single_suite_no_test_cases_utf8():
properties = {"foö": "bär"}
package = "mypäckage"
timestamp = 1398382805
test_suite = Suite(
name="äöü",
test_cases=[],
hostname="löcalhost",
id="äöü",
properties=properties,
package=package,
timestamp=timestamp,
)
ts, tcs = serialize_and_read(test_suite, to_file=True, prettyprint=True, encoding="utf-8")[0]
assert ts.tagName == "testsuite"
assert ts.attributes["package"].value == decode(package, "utf-8")
assert ts.attributes["timestamp"].value == str(timestamp)
assert ts.childNodes[0].childNodes[0].attributes["name"].value == decode("foö", "utf-8")
assert ts.childNodes[0].childNodes[0].attributes["value"].value == decode("bär", "utf-8")
def test_single_suite_no_test_cases():
properties = {"foo": "bar"}
package = "mypackage"
timestamp = 1398382805
ts, tcs = serialize_and_read(
Suite(
name="test",
test_cases=[],
hostname="localhost",
id=1,
properties=properties,
package=package,
timestamp=timestamp,
),
to_file=True,
prettyprint=True,
)[0]
assert ts.tagName == "testsuite"
assert ts.attributes["package"].value == package
assert ts.attributes["timestamp"].value == str(timestamp)
assert ts.childNodes[0].childNodes[0].attributes["name"].value == "foo"
assert ts.childNodes[0].childNodes[0].attributes["value"].value == "bar"
