443 lines
19 KiB
Python
443 lines
19 KiB
Python
# Copyright 2023 (c) Anna Schumaker.
|
|
"""Tests our row widgets and factories."""
|
|
import datetime
|
|
import unittest
|
|
import xfstestsdb.gtk.row
|
|
import tests.xunit
|
|
from gi.repository import Gtk
|
|
from gi.repository import Adw
|
|
|
|
|
|
class TestFactory(unittest.TestCase):
|
|
"""Tests our base Gtk.Factory to make Gtk.Inscriptions."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.xunitrow = xfstestsdb.gtk.model.XunitRow("xunit/row")
|
|
self.listitem = Gtk.ListItem()
|
|
self.listitem.get_item = unittest.mock.Mock(return_value=self.xunitrow)
|
|
|
|
self.factory = xfstestsdb.gtk.row.Factory()
|
|
|
|
def test_init(self):
|
|
"""Test that the Factory was initialized correctly."""
|
|
self.assertIsInstance(self.factory, Gtk.SignalListItemFactory)
|
|
|
|
def test_setup(self):
|
|
"""Test that the factory implements the 'setup' signal."""
|
|
with unittest.mock.patch.object(self.factory,
|
|
"do_setup") as mock_setup:
|
|
self.factory.emit("setup", self.listitem)
|
|
self.assertIsInstance(self.listitem.get_child(), Gtk.Inscription)
|
|
self.assertEqual(self.listitem.get_child().props.xalign, 0.5)
|
|
self.assertEqual(self.listitem.get_child().props.nat_chars, 18)
|
|
self.assertEqual(self.listitem.get_child().props.text_overflow,
|
|
Gtk.InscriptionOverflow.ELLIPSIZE_END)
|
|
self.assertTrue(self.listitem.get_child().has_css_class("numeric"))
|
|
mock_setup.assert_called_with(self.listitem.get_child())
|
|
|
|
def test_bind(self):
|
|
"""Test that the factory implements the 'bind' signal."""
|
|
with unittest.mock.patch.object(self.factory, "do_bind") as mock_bind:
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
mock_bind.assert_called_with(self.xunitrow,
|
|
self.listitem.get_child())
|
|
|
|
def test_unbind(self):
|
|
"""Test that the factory implements the 'unbind' signal."""
|
|
with unittest.mock.patch.object(self.factory,
|
|
"do_unbind") as mock_unbind:
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
self.listitem.get_child().set_text("text")
|
|
|
|
self.factory.emit("unbind", self.listitem)
|
|
self.assertIsNone(self.listitem.get_child().get_text())
|
|
mock_unbind.assert_called_with(self.xunitrow,
|
|
self.listitem.get_child())
|
|
|
|
def test_teardown(self):
|
|
"""Test that the factory implements the 'teardown' signal."""
|
|
with unittest.mock.patch.object(self.factory,
|
|
"do_teardown") as mock_teardown:
|
|
self.factory.emit("setup", self.listitem)
|
|
child = self.listitem.get_child()
|
|
self.factory.emit("teardown", self.listitem)
|
|
self.assertIsNone(self.listitem.get_child())
|
|
mock_teardown.assert_called_with(child)
|
|
|
|
|
|
class TestLabelFactory(unittest.TestCase):
|
|
"""Tests our Gtk.Factory to make Gtk.Labels."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.testcase = xfstestsdb.gtk.model.TestCase("test/case")
|
|
self.listitem = Gtk.ListItem()
|
|
self.listitem.get_item = unittest.mock.Mock(return_value=self.testcase)
|
|
|
|
self.factory = xfstestsdb.gtk.row.LabelFactory(property="name")
|
|
self.group = xfstestsdb.gtk.row.LabelFactory.group
|
|
|
|
def test_init(self):
|
|
"""Test that the factory was initialized correctly."""
|
|
self.assertIsInstance(self.factory, xfstestsdb.gtk.row.Factory)
|
|
self.assertEqual(self.factory.property, "name")
|
|
|
|
def test_size_group(self):
|
|
"""Test the label factory global size group."""
|
|
self.assertIsInstance(xfstestsdb.gtk.row.LabelFactory.group,
|
|
Gtk.SizeGroup)
|
|
self.assertEqual(xfstestsdb.gtk.row.LabelFactory.group.props.mode,
|
|
Gtk.SizeGroupMode.HORIZONTAL)
|
|
|
|
def test_setup(self):
|
|
"""Test that the factory implements the 'setup' signal."""
|
|
self.factory.emit("setup", self.listitem)
|
|
self.assertIn(self.listitem.get_child(), self.group.get_widgets())
|
|
|
|
def test_bind(self):
|
|
"""Test that the factory implements the 'bind' signal."""
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
self.assertEqual(self.listitem.get_child().get_text(), "test/case")
|
|
for style in xfstestsdb.gtk.row.STYLES.keys():
|
|
self.assertFalse(self.listitem.get_child().has_css_class(style))
|
|
|
|
def test_unbind(self):
|
|
"""Test that the factory implements the 'unbind' signal."""
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
self.factory.emit("unbind", self.listitem)
|
|
self.assertIsNone(self.listitem.get_child().get_text())
|
|
|
|
def test_teardown(self):
|
|
"""Test that the factory implements the 'teardown' signal."""
|
|
self.factory.emit("setup", self.listitem)
|
|
child = self.listitem.get_child()
|
|
self.factory.emit("teardown", self.listitem)
|
|
self.assertNotIn(child, self.group.get_widgets())
|
|
|
|
def test_styles(self):
|
|
"""Test the column text styles."""
|
|
self.assertDictEqual(xfstestsdb.gtk.row.STYLES,
|
|
{"passed": "success", "failed": "error",
|
|
"skipped": "warning", "time": "accent"})
|
|
for style in ["passed", "failed", "skipped", "time"]:
|
|
with self.subTest(style=style):
|
|
self.testcase.name = style
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
|
|
child = self.listitem.get_child()
|
|
expected = xfstestsdb.gtk.row.STYLES[style]
|
|
self.assertTrue(child.has_css_class(expected))
|
|
|
|
self.factory.emit("unbind", self.listitem)
|
|
self.assertFalse(child.has_css_class(expected))
|
|
|
|
|
|
class TestEnvironmentFactory(unittest.TestCase):
|
|
"""Tests our Gtk.Factory to show environment properties."""
|
|
|
|
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.props = xfstestsdb.gtk.model.PropertyList(self.xfstestsdb.sql, 1)
|
|
self.listitem = Gtk.ListItem()
|
|
self.listitem.get_item = unittest.mock.Mock(return_value=self.props)
|
|
|
|
self.factory = xfstestsdb.gtk.row.EnvironmentFactory(property="FSTYP")
|
|
|
|
def test_init(self):
|
|
"""Test that the factory was initialized correctly."""
|
|
self.assertIsInstance(self.factory, xfstestsdb.gtk.row.Factory)
|
|
self.assertEqual(self.factory.property, "FSTYP")
|
|
|
|
def test_bind(self):
|
|
"""Test binding to a property."""
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
self.assertEqual(self.listitem.get_child().get_xalign(), 0)
|
|
self.assertEqual(self.listitem.get_child().get_text(), "myfs")
|
|
self.assertEqual(self.listitem.get_child().get_tooltip_text(), "myfs")
|
|
|
|
|
|
class TestXunitFactory(unittest.TestCase):
|
|
"""Tests our XunitFactory base class."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.factory = xfstestsdb.gtk.row.XunitFactory(xunit="xunit-1")
|
|
|
|
def test_init(self):
|
|
"""Test that the factory was initialized correctly."""
|
|
self.assertIsInstance(self.factory, xfstestsdb.gtk.row.Factory)
|
|
self.assertEqual(self.factory.xunit, "xunit-1")
|
|
|
|
|
|
class TestPropertyFactory(unittest.TestCase):
|
|
"""Tests our Gtk.Factory to show xunit properties."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.property = xfstestsdb.gtk.model.Property("property")
|
|
self.listitem = Gtk.ListItem()
|
|
self.listitem.get_item = unittest.mock.Mock(return_value=self.property)
|
|
|
|
self.factory = xfstestsdb.gtk.row.PropertyFactory(xunit="xunit-1")
|
|
|
|
def test_init(self):
|
|
"""Test that the factory was initialized correctly."""
|
|
self.assertIsInstance(self.factory, xfstestsdb.gtk.row.XunitFactory)
|
|
|
|
def test_bind(self):
|
|
"""Test binding to a property."""
|
|
self.property.add_xunit("xunit-1", "property", "value")
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
self.assertEqual(self.listitem.get_child().get_text(), "value")
|
|
self.assertEqual(self.listitem.get_child().get_tooltip_text(), "value")
|
|
|
|
|
|
class TestResultFactory(unittest.TestCase):
|
|
"""Tests our Gtk.Factory to show test results."""
|
|
|
|
def setup_parent(self, factory: xfstestsdb.gtk.row.ResultFactory,
|
|
listitem: Gtk.ListItem) -> None:
|
|
"""Set the child widget's parent for custom styling."""
|
|
self.parent.set_child(listitem.get_child())
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.testcase = xfstestsdb.gtk.model.TestCase("test/case")
|
|
self.parent = Adw.Bin()
|
|
self.listitem = Gtk.ListItem()
|
|
self.listitem.get_item = unittest.mock.Mock(return_value=self.testcase)
|
|
|
|
self.factory = xfstestsdb.gtk.row.ResultFactory(xunit="xunit-1")
|
|
self.factory.connect("setup", self.setup_parent)
|
|
|
|
def test_init(self):
|
|
"""Test that the factory was initialized correctly."""
|
|
self.assertIsInstance(self.factory, xfstestsdb.gtk.row.XunitFactory)
|
|
|
|
def test_setup_click(self):
|
|
"""Test that we setup a GestureClick on the child widget."""
|
|
self.factory.emit("setup", self.listitem)
|
|
child = self.listitem.get_child()
|
|
click = getattr(child, "click")
|
|
self.assertIsInstance(click, Gtk.GestureClick)
|
|
self.assertIn(click, child.observe_controllers())
|
|
|
|
self.factory.emit("teardown", self.listitem)
|
|
self.assertIsNone(getattr(child, "click"))
|
|
self.assertNotIn(click, child.observe_controllers())
|
|
|
|
def test_bind_passed(self):
|
|
"""Test binding to a passing test."""
|
|
show_messages = unittest.mock.Mock()
|
|
self.testcase.add_xunit("xunit-1", "passed", 3, "", None, None)
|
|
self.factory.connect("show-messages", show_messages)
|
|
self.factory.emit("setup", self.listitem)
|
|
child = self.listitem.get_child()
|
|
|
|
self.factory.emit("bind", self.listitem)
|
|
self.assertEqual(child.get_text(), "3 seconds")
|
|
self.assertIsNone(child.get_tooltip_text())
|
|
self.assertTrue(self.parent.has_css_class("passed"))
|
|
|
|
child.click.emit("released", 1, 0, 0)
|
|
show_messages.assert_not_called()
|
|
|
|
self.factory.emit("unbind", self.listitem)
|
|
self.assertFalse(self.parent.has_css_class("passed"))
|
|
|
|
def test_bind_skipped(self):
|
|
"""Test binding to a skipped test."""
|
|
show_messages = unittest.mock.Mock()
|
|
self.testcase.add_xunit("xunit-1", "skipped", 0,
|
|
"test skipped for ... reasons", None, None)
|
|
self.factory.connect("show-messages", show_messages)
|
|
self.factory.emit("setup", self.listitem)
|
|
child = self.listitem.get_child()
|
|
|
|
self.factory.emit("bind", self.listitem)
|
|
self.assertEqual(child.get_text(), "skipped")
|
|
self.assertEqual(child.get_tooltip_text(),
|
|
"test skipped for ... reasons")
|
|
self.assertTrue(self.parent.has_css_class("skipped"))
|
|
|
|
child.click.emit("released", 1, 0, 0)
|
|
show_messages.assert_not_called()
|
|
|
|
self.factory.emit("unbind", self.listitem)
|
|
self.assertFalse(self.parent.has_css_class("skipped"))
|
|
|
|
def test_bind_failed(self):
|
|
"""Test binding to a failed test."""
|
|
show_messages = unittest.mock.Mock()
|
|
self.testcase.add_xunit("xunit-1", "failure", 8,
|
|
"- failed. see output", "stdout message",
|
|
"stderr message")
|
|
self.factory.connect("show-messages", show_messages)
|
|
self.factory.emit("setup", self.listitem)
|
|
child = self.listitem.get_child()
|
|
|
|
self.factory.emit("bind", self.listitem)
|
|
self.assertEqual(child.get_text(), "failure")
|
|
self.assertEqual(child.get_tooltip_text(), "failed. see output")
|
|
self.assertTrue(self.parent.has_css_class("failure"))
|
|
|
|
child.click.emit("released", 1, 0, 0)
|
|
show_messages.assert_called_with(self.factory, "test/case", "xunit-1",
|
|
"stdout message", "stderr message")
|
|
|
|
self.factory.emit("unbind", self.listitem)
|
|
self.assertFalse(self.parent.has_css_class("failure"))
|
|
child.click.emit("released", 1, 0, 0)
|
|
show_messages.assert_called_once()
|
|
|
|
def test_bind_missing(self):
|
|
"""Test binding to a missing test."""
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
self.assertIsNone(self.listitem.get_child().get_text())
|
|
|
|
self.factory.emit("unbind", self.listitem)
|
|
|
|
|
|
class TestSummaryFactory(unittest.TestCase):
|
|
"""Tests our Gtk.Factory to show Xfstests results summaries."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.summary = xfstestsdb.gtk.model.Summary("passed")
|
|
self.listitem = Gtk.ListItem()
|
|
self.listitem.get_item = unittest.mock.Mock(return_value=self.summary)
|
|
|
|
self.factory = xfstestsdb.gtk.row.SummaryFactory(xunit="xunit-1")
|
|
|
|
def test_init(self):
|
|
"""Test that the factory was initialized correctly."""
|
|
self.assertIsInstance(self.factory, xfstestsdb.gtk.row.XunitFactory)
|
|
|
|
def test_bind_passed(self):
|
|
"""Test binding to the passed tests summary."""
|
|
self.summary.add_xunit("xunit-1", 1, "testcase")
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
self.assertEqual(self.listitem.get_child().get_text(), "1 testcase")
|
|
self.assertTrue(self.listitem.get_child().has_css_class("success"))
|
|
|
|
self.factory.emit("unbind", self.listitem)
|
|
self.assertFalse(self.listitem.get_child().has_css_class("success"))
|
|
|
|
def test_bind_failed(self):
|
|
"""Test binding to the failed tests summary."""
|
|
self.summary.name = "failed"
|
|
self.summary.add_xunit("xunit-1", 1, "testcase")
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
self.assertEqual(self.listitem.get_child().get_text(), "1 testcase")
|
|
self.assertTrue(self.listitem.get_child().has_css_class("error"))
|
|
|
|
self.factory.emit("unbind", self.listitem)
|
|
self.assertFalse(self.listitem.get_child().has_css_class("error"))
|
|
|
|
def test_bind_skipped(self):
|
|
"""Test binding to the skipped tests summary."""
|
|
self.summary.name = "skipped"
|
|
self.summary.add_xunit("xunit-1", 1, "testcase")
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
self.assertEqual(self.listitem.get_child().get_text(), "1 testcase")
|
|
self.assertTrue(self.listitem.get_child().has_css_class("warning"))
|
|
|
|
self.factory.emit("unbind", self.listitem)
|
|
self.assertFalse(self.listitem.get_child().has_css_class("warning"))
|
|
|
|
def test_bind_time(self):
|
|
"""Test binding to the time summary."""
|
|
self.summary.name = "time"
|
|
self.summary.add_xunit("xunit-1", 1, "second")
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
self.assertEqual(self.listitem.get_child().get_text(), "1 second")
|
|
self.assertTrue(self.listitem.get_child().has_css_class("accent"))
|
|
|
|
self.factory.emit("unbind", self.listitem)
|
|
self.assertFalse(self.listitem.get_child().has_css_class("accent"))
|
|
|
|
|
|
class TestSidebarFactory(unittest.TestCase):
|
|
"""Tests our Gtk.Factory to show Xfstsets runs in the sidebar."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.devlist = xfstestsdb.gtk.tree.DeviceRunsList("/dev/vda1")
|
|
self.treeitem = Gtk.TreeListRow()
|
|
self.treeitem.get_item = unittest.mock.Mock(return_value=self.devlist)
|
|
self.listitem = Gtk.ListItem()
|
|
self.listitem.get_item = unittest.mock.Mock(return_value=self.treeitem)
|
|
|
|
self.factory = xfstestsdb.gtk.row.SidebarFactory()
|
|
|
|
def test_init(self):
|
|
"""Test that the factory was initialized correctly."""
|
|
self.assertIsInstance(self.factory, Gtk.SignalListItemFactory)
|
|
|
|
def test_setup(self):
|
|
"""Test that thefactory implements the 'setup' signal."""
|
|
self.factory.emit("setup", self.listitem)
|
|
expander = self.listitem.get_child()
|
|
self.assertIsInstance(expander, Gtk.TreeExpander)
|
|
self.assertIsInstance(expander.get_child(), Gtk.Label)
|
|
self.assertEqual(expander.get_child().props.yalign, 0.75)
|
|
self.assertTrue(expander.get_child().has_css_class("numeric"))
|
|
|
|
def test_bind_device_list(self):
|
|
"""Test binding to a DeviceRunsList object."""
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
self.assertEqual(self.listitem.get_child().get_child().get_text(),
|
|
"/dev/vda1")
|
|
self.assertEqual(self.listitem.get_child().get_list_row(),
|
|
self.treeitem)
|
|
self.assertFalse(self.listitem.props.selectable)
|
|
|
|
def test_bind_xfstests_run(self):
|
|
"""Test binding to an XfstestsRun object."""
|
|
now = datetime.datetime.now()
|
|
self.devlist.add_run(1, now)
|
|
self.treeitem.get_item.return_value = self.devlist[0]
|
|
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
self.assertEqual(self.listitem.get_child().get_child().get_text(),
|
|
f"#1: {now.strftime('%T')}")
|
|
self.assertEqual(self.listitem.get_child().get_list_row(),
|
|
self.treeitem)
|
|
self.assertTrue(self.listitem.props.selectable)
|
|
|
|
def test_unbind(self):
|
|
"""Test that the factory implements the 'unbind' signal."""
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("bind", self.listitem)
|
|
self.factory.emit("unbind", self.listitem)
|
|
self.assertEqual(self.listitem.get_child().get_child().get_text(), "")
|
|
|
|
def test_teardown(self):
|
|
"""Test that the factory implements the 'teardown' signal."""
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("teardown", self.listitem)
|
|
self.assertIsNone(self.listitem.get_child())
|