491 lines
19 KiB
Python
491 lines
19 KiB
Python
# Copyright 2023 (c) Anna Schumaker.
|
|
"""Tests our Testcase Gio.ListModel."""
|
|
import random
|
|
import unittest
|
|
import tests.xunit
|
|
import xfstestsdb.gtk.model
|
|
from gi.repository import GObject
|
|
from gi.repository import Gio
|
|
from gi.repository import Gtk
|
|
|
|
|
|
class TestXunitCell(unittest.TestCase):
|
|
"""Test case for our base XunitCell object."""
|
|
|
|
def test_cell(self):
|
|
"""Test creating a Cell instance."""
|
|
cell = xfstestsdb.gtk.model.XunitCell(name="my xunit name")
|
|
self.assertIsInstance(cell, GObject.GObject)
|
|
self.assertEqual(cell.name, "my xunit name")
|
|
self.assertEqual(str(cell), "my xunit name")
|
|
|
|
|
|
class TestXunitRow(unittest.TestCase):
|
|
"""Test case for our base XunitRow object."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.row = xfstestsdb.gtk.model.XunitRow(name="row-name")
|
|
|
|
def test_init(self):
|
|
"""Test that the XunitRow is set up properly."""
|
|
self.assertIsInstance(self.row, GObject.GObject)
|
|
self.assertEqual(self.row.name, "row-name")
|
|
|
|
def test_compare(self):
|
|
"""Test the less-than operator on XunitRows."""
|
|
row2 = xfstestsdb.gtk.model.XunitRow(name="row-name-2")
|
|
self.assertTrue(self.row < row2)
|
|
self.assertFalse(row2 < self.row)
|
|
self.assertFalse(self.row < self.row)
|
|
|
|
def test_xunits(self):
|
|
"""Test adding xunits to a XunitRow."""
|
|
self.assertIsNone(self.row["xunit-1"])
|
|
|
|
self.row.add_xunit("xunit-1")
|
|
self.assertSetEqual(self.row.get_results(), {"xunit-1"})
|
|
self.assertListEqual(self.row.get_xunits(), ["xunit-1"])
|
|
|
|
xunit = self.row["xunit-1"]
|
|
self.assertIsInstance(xunit, xfstestsdb.gtk.model.XunitCell)
|
|
self.assertEqual(xunit.name, "xunit-1")
|
|
|
|
self.row.add_xunit("xunit-2")
|
|
self.assertSetEqual(self.row.get_results(), {"xunit-1", "xunit-2"})
|
|
self.assertListEqual(self.row.get_xunits(), ["xunit-1", "xunit-2"])
|
|
|
|
xunit = self.row["xunit-2"]
|
|
self.assertIsInstance(xunit, xfstestsdb.gtk.model.XunitCell)
|
|
self.assertEqual(xunit.name, "xunit-2")
|
|
|
|
|
|
class TestXunitList(unittest.TestCase):
|
|
"""Test case for our base XunitList object."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.xfstestsdb = xfstestsdb.Command()
|
|
with unittest.mock.patch("sys.stdout"):
|
|
self.xfstestsdb.run(["new", "/dev/vda1"])
|
|
self.xfstestsdb.run(["xunit", "read", "--name", "xunit-1",
|
|
"1", str(tests.xunit.XUNIT_1)])
|
|
self.xfstestsdb.run(["xunit", "read", "--name", "xunit-2",
|
|
"1", str(tests.xunit.XUNIT_1)])
|
|
|
|
self.xulist = xfstestsdb.gtk.model.XunitList(self.xfstestsdb.sql, 1)
|
|
|
|
def test_init(self):
|
|
"""Test that the XunitList was set up properly."""
|
|
self.assertIsInstance(self.xulist, GObject.GObject)
|
|
self.assertIsInstance(self.xulist, Gio.ListModel)
|
|
self.assertEqual(self.xulist.runid, 1)
|
|
|
|
def test_get_item_type(self):
|
|
"""Test the get_item_type() function."""
|
|
self.assertEqual(self.xulist.get_item_type(),
|
|
xfstestsdb.gtk.model.XunitRow.__gtype__)
|
|
|
|
def test_get_n_items(self):
|
|
"""Test the get_n_items() function."""
|
|
self.assertEqual(self.xulist.get_n_items(), 0)
|
|
self.assertEqual(self.xulist.n_items, 0)
|
|
|
|
self.xulist.n_items = 2
|
|
self.assertEqual(self.xulist.get_n_items(), 2)
|
|
|
|
def test_get_item(self):
|
|
"""Test the get_item() function."""
|
|
self.assertIsNone(self.xulist.get_item(0))
|
|
|
|
def test_get_xunits(self):
|
|
"""Test the get_xunits() function."""
|
|
self.assertListEqual(self.xulist.get_xunits(), ["xunit-1", "xunit-2"])
|
|
|
|
|
|
class TestPropertyValue(unittest.TestCase):
|
|
"""Tests a single Xunit Property instance."""
|
|
|
|
def test_xunit_property(self):
|
|
"""Test creating an xunit property instance."""
|
|
property = xfstestsdb.gtk.model.PropertyValue(name="my xunit name",
|
|
key="key", value="123")
|
|
self.assertIsInstance(property, xfstestsdb.gtk.model.XunitCell)
|
|
self.assertEqual(property.name, "my xunit name")
|
|
self.assertEqual(property.key, "key")
|
|
self.assertEqual(property.value, "123")
|
|
self.assertEqual(str(property), "key = 123")
|
|
|
|
|
|
class TestProperty(unittest.TestCase):
|
|
"""Tests our Property GObject."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.property = xfstestsdb.gtk.model.Property(name="property")
|
|
|
|
def test_init(self):
|
|
"""Check that the Property is set up properly."""
|
|
self.assertIsInstance(self.property, xfstestsdb.gtk.model.XunitRow)
|
|
self.assertEqual(self.property.name, "property")
|
|
|
|
def test_xunits(self):
|
|
"""Test adding xunits to a Property."""
|
|
self.assertIsNone(self.property["xunit-1"])
|
|
self.assertIsNone(self.property.get_value())
|
|
self.assertFalse(self.property.all_same_value())
|
|
|
|
self.property.add_xunit("xunit-1", "PLATFORM", "linux-123")
|
|
property = self.property["xunit-1"]
|
|
self.assertIsInstance(property, xfstestsdb.gtk.model.PropertyValue)
|
|
self.assertEqual(property.name, "xunit-1")
|
|
self.assertEqual(property.key, "PLATFORM")
|
|
self.assertEqual(property.value, "linux-123")
|
|
self.assertFalse(self.property.all_same_value())
|
|
self.assertIsNone(self.property.get_value())
|
|
|
|
self.property.add_xunit("xunit-2", "PLATFORM", "linux-123")
|
|
property = self.property["xunit-2"]
|
|
self.assertIsInstance(property, xfstestsdb.gtk.model.PropertyValue)
|
|
self.assertEqual(property.name, "xunit-2")
|
|
self.assertEqual(property.key, "PLATFORM")
|
|
self.assertEqual(property.value, "linux-123")
|
|
self.assertTrue(self.property.all_same_value())
|
|
self.assertEqual(self.property.get_value(), "linux-123")
|
|
|
|
self.property.add_xunit("xunit-3", "PLATFORM", "linux-456")
|
|
self.assertFalse(self.property.all_same_value())
|
|
self.assertIsNone(self.property.get_value())
|
|
|
|
|
|
class TestPropertyList(unittest.TestCase):
|
|
"""Tests our PropertyList GObject."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.xfstestsdb = xfstestsdb.Command()
|
|
with unittest.mock.patch("sys.stdout"):
|
|
self.xfstestsdb.run(["new", "/dev/vda1"])
|
|
self.xfstestsdb.run(["xunit", "read", "--name", "xunit-1",
|
|
"1", str(tests.xunit.XUNIT_1)])
|
|
self.xfstestsdb.run(["xunit", "read", "--name", "xunit-2",
|
|
"1", str(tests.xunit.XUNIT_2)])
|
|
|
|
self.prlist = xfstestsdb.gtk.model.PropertyList(self.xfstestsdb.sql, 1)
|
|
|
|
def test_init(self):
|
|
"""Test that the PropertyList was set up properly."""
|
|
self.assertIsInstance(self.prlist, xfstestsdb.gtk.model.XunitList)
|
|
self.assertEqual(self.prlist.runid, 1)
|
|
self.assertEqual(self.prlist.n_items, 15)
|
|
|
|
def test_environment(self):
|
|
"""Test environment handling."""
|
|
self.assertIsInstance(self.prlist.environment, Gio.ListStore)
|
|
self.assertEqual(len(self.prlist.environment), 1)
|
|
self.assertEqual(self.prlist.environment[0], self.prlist)
|
|
|
|
env = self.prlist.get_environment()
|
|
self.assertDictEqual(env, {"FSTYP": "myfs",
|
|
"CHECK_OPTIONS": "-r -R xunit -g quick"})
|
|
|
|
|
|
class TestPropertyFilter(unittest.TestCase):
|
|
"""Tests our Gtk.Filter customized for filtering Properties."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.filter = xfstestsdb.gtk.model.PropertyFilter()
|
|
|
|
def test_init(self):
|
|
"""Test that the TestCaseFilter is set up properly."""
|
|
self.assertIsInstance(self.filter, Gtk.Filter)
|
|
self.assertEqual(self.filter.get_strictness(), Gtk.FilterMatch.SOME)
|
|
|
|
def test_hidden_properties(self):
|
|
"""Test the hidden properties global variable."""
|
|
self.assertSetEqual(xfstestsdb.gtk.model.HIDDEN_PROPERTIES,
|
|
{"CPUS", "HOST_OPTIONS", "LOAD_FACTOR",
|
|
"MEM_KB", "NUMA_NODES", "OVL_LOWER",
|
|
"OVL_UPPER", "OVL_WORK", "PLATFORM",
|
|
"SECTION", "SWAP_KB", "TIME_FACTOR"})
|
|
|
|
def test_match(self):
|
|
"""Test matching Properties with the Filter."""
|
|
property = xfstestsdb.gtk.model.Property("name")
|
|
self.assertTrue(self.filter.match(property))
|
|
|
|
property.add_xunit("xunit-1", "name", "my name")
|
|
self.assertTrue(self.filter.match(property))
|
|
property.add_xunit("xunit-2", "name", "my name")
|
|
self.assertFalse(self.filter.match(property))
|
|
property.add_xunit("xunit-3", "name", "my other name")
|
|
self.assertTrue(self.filter.match(property))
|
|
|
|
for prop in xfstestsdb.gtk.model.HIDDEN_PROPERTIES:
|
|
with self.subTest(property=prop):
|
|
property.name = prop
|
|
self.assertFalse(self.filter.match(property))
|
|
|
|
|
|
class TestTestResult(unittest.TestCase):
|
|
"""Tests a single TestCase Xunit instance."""
|
|
|
|
def test_xunit_result(self):
|
|
"""Test creating an xunit instance."""
|
|
xunit = xfstestsdb.gtk.model.TestResult(name="my xunit name",
|
|
status="passed", time=123,
|
|
message="my message",
|
|
stdout="my stdout",
|
|
stderr="my stderr")
|
|
self.assertIsInstance(xunit, xfstestsdb.gtk.model.XunitCell)
|
|
self.assertEqual(xunit.name, "my xunit name")
|
|
self.assertEqual(xunit.status, "passed")
|
|
self.assertEqual(xunit.time, 123)
|
|
self.assertEqual(xunit.message, "my message")
|
|
self.assertEqual(xunit.stdout, "my stdout")
|
|
self.assertEqual(xunit.stderr, "my stderr")
|
|
self.assertEqual(str(xunit), "passed")
|
|
|
|
|
|
class TestTestCase(unittest.TestCase):
|
|
"""Tests our TestCase GObject."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.testcase = xfstestsdb.gtk.model.TestCase(name="test-case")
|
|
|
|
def test_init(self):
|
|
"""Check that the TestCase is set up properly."""
|
|
self.assertIsInstance(self.testcase, xfstestsdb.gtk.model.XunitRow)
|
|
self.assertEqual(self.testcase.name, "test-case")
|
|
|
|
def test_xunits(self):
|
|
"""Test adding xunits to a TestCase."""
|
|
self.assertIsNone(self.testcase["xunit-1"])
|
|
|
|
self.testcase.add_xunit("xunit-1", "passed", 123, "message",
|
|
"stdout", "stderr")
|
|
xunit = self.testcase["xunit-1"]
|
|
self.assertIsInstance(xunit, xfstestsdb.gtk.model.TestResult)
|
|
self.assertEqual(xunit.name, "xunit-1")
|
|
self.assertEqual(xunit.status, "passed")
|
|
self.assertEqual(xunit.time, 123)
|
|
self.assertEqual(xunit.message, "message")
|
|
self.assertEqual(xunit.stdout, "stdout")
|
|
self.assertEqual(xunit.stderr, "stderr")
|
|
|
|
self.testcase.add_xunit("xunit-2", "failed", 456, None, None, None)
|
|
xunit = self.testcase["xunit-2"]
|
|
self.assertIsInstance(xunit, xfstestsdb.gtk.model.TestResult)
|
|
self.assertEqual(xunit.name, "xunit-2")
|
|
self.assertEqual(xunit.status, "failed")
|
|
self.assertEqual(xunit.time, 456)
|
|
self.assertEqual(xunit.message, "")
|
|
self.assertEqual(xunit.stdout, "")
|
|
self.assertEqual(xunit.stderr, "")
|
|
|
|
|
|
class TestCaseList(unittest.TestCase):
|
|
"""Tests our TestCaseList Gio.ListModel."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.xfstestsdb = xfstestsdb.Command()
|
|
with unittest.mock.patch("sys.stdout"):
|
|
self.xfstestsdb.run(["new", "/dev/vda1"])
|
|
self.xfstestsdb.run(["xunit", "read", "--name", "xunit-1",
|
|
"1", str(tests.xunit.XUNIT_1)])
|
|
self.xfstestsdb.run(["xunit", "read", "--name", "xunit-2",
|
|
"1", str(tests.xunit.XUNIT_1)])
|
|
|
|
self.tclist = xfstestsdb.gtk.model.TestCaseList(self.xfstestsdb.sql, 1)
|
|
|
|
def test_init(self):
|
|
"""Test that the TestCaseList was set up properly."""
|
|
self.assertIsInstance(self.tclist, xfstestsdb.gtk.model.XunitList)
|
|
self.assertEqual(self.tclist.runid, 1)
|
|
self.assertEqual(self.tclist.n_items, 10)
|
|
|
|
def test_get_item(self):
|
|
"""Test the get_item() function."""
|
|
testcase = self.tclist.get_item(0)
|
|
self.assertIsInstance(testcase, xfstestsdb.gtk.model.TestCase)
|
|
self.assertEqual(testcase.name, "test/01")
|
|
for xunit in ["xunit-1", "xunit-2"]:
|
|
with self.subTest(xunit=xunit):
|
|
self.assertEqual(testcase[xunit].name, xunit)
|
|
self.assertEqual(testcase[xunit].status, "passed")
|
|
self.assertEqual(testcase[xunit].time, 1)
|
|
self.assertEqual(testcase[xunit].message, "")
|
|
self.assertEqual(testcase[xunit].stdout, "")
|
|
self.assertEqual(testcase[xunit].stderr, "")
|
|
|
|
self.assertIsNone(self.tclist.get_item(10))
|
|
|
|
|
|
class TestCaseFilter(unittest.TestCase):
|
|
"""Tests our Gtk.Filter customized for filtering TestCases."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.filter = xfstestsdb.gtk.model.TestCaseFilter()
|
|
|
|
def test_init(self):
|
|
"""Test that the TestCaseFilter is set up properly."""
|
|
self.assertIsInstance(self.filter, Gtk.Filter)
|
|
|
|
self.assertTrue(self.filter.failure)
|
|
self.assertFalse(self.filter.passed)
|
|
self.assertFalse(self.filter.skipped)
|
|
|
|
def test_strictness(self):
|
|
"""Test the TestCaseFilter strictness."""
|
|
self.assertEqual(self.filter.get_strictness(), Gtk.FilterMatch.SOME)
|
|
self.filter.passed = True
|
|
self.assertEqual(self.filter.get_strictness(), Gtk.FilterMatch.SOME)
|
|
|
|
self.filter.skipped = True
|
|
self.assertEqual(self.filter.get_strictness(), Gtk.FilterMatch.ALL)
|
|
|
|
self.filter.passed = False
|
|
self.filter.skipped = False
|
|
self.filter.failure = False
|
|
self.assertEqual(self.filter.get_strictness(), Gtk.FilterMatch.NONE)
|
|
|
|
def test_changed(self):
|
|
"""Test the TestCaseFilter 'changed' signal."""
|
|
changed = unittest.mock.Mock()
|
|
self.filter.connect("changed", changed)
|
|
|
|
self.filter.skipped = True
|
|
changed.assert_called_with(self.filter, Gtk.FilterChange.LESS_STRICT)
|
|
self.filter.passed = False
|
|
changed.assert_called_with(self.filter, Gtk.FilterChange.MORE_STRICT)
|
|
|
|
def test_match(self):
|
|
"""Test matching TestCases with the TestCaseFilter."""
|
|
testcase = xfstestsdb.gtk.model.TestCase(name="test-case")
|
|
self.assertFalse(self.filter.match(testcase))
|
|
|
|
self.filter.passed = False
|
|
self.filter.skipped = False
|
|
self.filter.failure = False
|
|
|
|
testcase.add_xunit("xunit-1", "skipped", 123, "", "", "")
|
|
self.assertFalse(self.filter.match(testcase))
|
|
|
|
self.filter.skipped = True
|
|
self.assertTrue(self.filter.match(testcase))
|
|
|
|
testcase.add_xunit("xunit-2", "passed", 123, "", "", "")
|
|
self.assertTrue(self.filter.match(testcase))
|
|
self.filter.skipped = False
|
|
self.assertFalse(self.filter.match(testcase))
|
|
self.filter.passed = True
|
|
self.assertTrue(self.filter.match(testcase))
|
|
|
|
testcase.add_xunit("xunit-3", "failure", 123, "", "", "")
|
|
self.assertTrue(self.filter.match(testcase))
|
|
self.filter.passed = False
|
|
self.assertFalse(self.filter.match(testcase))
|
|
self.filter.failure = True
|
|
self.assertTrue(self.filter.match(testcase))
|
|
|
|
|
|
class TestSummaryValue(unittest.TestCase):
|
|
"""Tests a single Summary Value object."""
|
|
|
|
def test_init(self):
|
|
"""Test creating a summary result instance."""
|
|
value = xfstestsdb.gtk.model.SummaryValue(name="my xunit name",
|
|
value=12345,
|
|
unit="testcase")
|
|
self.assertIsInstance(value, xfstestsdb.gtk.model.XunitCell)
|
|
self.assertEqual(value.name, "my xunit name")
|
|
self.assertEqual(value.unit, "testcase")
|
|
self.assertEqual(value.value, 12345)
|
|
|
|
def test_str(self):
|
|
"""Test converting a summary result to a string."""
|
|
value = xfstestsdb.gtk.model.SummaryValue(name="my xunit name",
|
|
value=1, unit="unit")
|
|
self.assertEqual(str(value), "1 unit")
|
|
|
|
value.value = 2
|
|
self.assertEqual(str(value), "2 units")
|
|
|
|
|
|
class TestSummary(unittest.TestCase):
|
|
"""Tests our Summary GObject."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.summary = xfstestsdb.gtk.model.Summary(name="passed")
|
|
|
|
def test_init(self):
|
|
"""Check that the Summary is set up properly."""
|
|
self.assertIsInstance(self.summary, xfstestsdb.gtk.model.XunitRow)
|
|
self.assertEqual(self.summary.name, "passed")
|
|
|
|
def test_compare(self):
|
|
"""Test the less-than operator on Summaries."""
|
|
failed = xfstestsdb.gtk.model.Summary(name="failed")
|
|
skipped = xfstestsdb.gtk.model.Summary(name="skipped")
|
|
time = xfstestsdb.gtk.model.Summary(name="time")
|
|
expected = [self.summary, failed, skipped, time]
|
|
|
|
for i in range(10):
|
|
with self.subTest(i=i):
|
|
shuffled = [time, skipped, failed, self.summary]
|
|
random.shuffle(shuffled)
|
|
self.assertListEqual(sorted(shuffled), expected)
|
|
|
|
def test_xunits(self):
|
|
"""Test adding xunits to a Summary."""
|
|
self.assertIsNone(self.summary["xunit-1"])
|
|
|
|
self.summary.add_xunit("xunit-1", 123, "unit")
|
|
xunit = self.summary["xunit-1"]
|
|
self.assertIsInstance(xunit, xfstestsdb.gtk.model.SummaryValue)
|
|
self.assertEqual(xunit.name, "xunit-1")
|
|
self.assertEqual(xunit.value, 123)
|
|
self.assertEqual(xunit.unit, "unit")
|
|
|
|
|
|
class TestSummaryList(unittest.TestCase):
|
|
"""Test case for our summary list."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.xfstestsdb = xfstestsdb.Command()
|
|
with unittest.mock.patch("sys.stdout"):
|
|
self.xfstestsdb.run(["new", "/dev/vda1"])
|
|
self.xfstestsdb.run(["xunit", "read", "--name", "xunit-1",
|
|
"1", str(tests.xunit.XUNIT_1)])
|
|
self.xfstestsdb.run(["xunit", "read", "--name", "xunit-2",
|
|
"1", str(tests.xunit.XUNIT_1)])
|
|
|
|
self.summary = xfstestsdb.gtk.model.SummaryList(self.xfstestsdb.sql, 1)
|
|
|
|
def test_init(self):
|
|
"""Test that the SummaryList was set up properly."""
|
|
self.assertIsInstance(self.summary, xfstestsdb.gtk.model.XunitList)
|
|
self.assertEqual(self.summary.runid, 1)
|
|
self.assertEqual(self.summary.n_items, 4)
|
|
|
|
def test_get_item(self):
|
|
"""Test the get_item() function."""
|
|
for i, field in enumerate(["passed", "failed", "skipped", "time"]):
|
|
with self.subTest(i=i, field=field):
|
|
summary = self.summary[i]
|
|
self.assertIsInstance(summary, xfstestsdb.gtk.model.Summary)
|
|
self.assertEqual(summary.name, field)
|
|
|
|
match field:
|
|
case "passed": expected = {"6 testcases"}
|
|
case "failed": expected = {"1 testcase"}
|
|
case "skipped": expected = {"3 testcases"}
|
|
case "time": expected = {"43 seconds"}
|
|
self.assertSetEqual(summary.get_results(), expected)
|