270 lines
10 KiB
Python
270 lines
10 KiB
Python
# Copyright 2023 (c) Anna Schumaker.
|
|
"""Tests our xfstests run selector tree."""
|
|
import datetime
|
|
import unittest
|
|
import xfstestsdb.gtk.tree
|
|
import tests.xunit
|
|
from gi.repository import GObject
|
|
from gi.repository import Gio
|
|
from gi.repository import Gtk
|
|
|
|
|
|
class TestXfstestsRun(unittest.TestCase):
|
|
"""Test case for our XfstestsRun GObject."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.now = datetime.datetime.now()
|
|
self.run = xfstestsdb.gtk.tree.XfstestsRun(1, self.now)
|
|
|
|
def test_run(self):
|
|
"""Test the XfsetstsRun object."""
|
|
self.assertIsInstance(self.run, GObject.GObject)
|
|
self.assertEqual(self.run.runid, 1)
|
|
self.assertEqual(self.run.timestamp, self.now)
|
|
|
|
def test_gt(self):
|
|
"""Test the XfstestsRun Greater-Than operator."""
|
|
soon = self.now + datetime.timedelta(seconds=5)
|
|
run2 = xfstestsdb.gtk.tree.XfstestsRun(2, soon)
|
|
run3 = xfstestsdb.gtk.tree.XfstestsRun(3, soon)
|
|
|
|
self.assertTrue(run2 > self.run)
|
|
self.assertFalse(self.run > run2)
|
|
self.assertFalse(self.run > self.run)
|
|
|
|
self.assertTrue(run3 > run2)
|
|
self.assertFalse(run2 > run3)
|
|
|
|
def test_lt(self):
|
|
"""Test the XfstestsRun Less-Than operator."""
|
|
soon = self.now + datetime.timedelta(seconds=5)
|
|
run2 = xfstestsdb.gtk.tree.XfstestsRun(2, soon)
|
|
run3 = xfstestsdb.gtk.tree.XfstestsRun(3, soon)
|
|
|
|
self.assertTrue(self.run < run2)
|
|
self.assertFalse(run2 < self.run)
|
|
self.assertFalse(self.run < self.run)
|
|
|
|
self.assertTrue(run2 < run3)
|
|
self.assertFalse(run3 < run2)
|
|
|
|
def test_str(self):
|
|
"""Test converting an XfstestsRun to a string."""
|
|
self.assertEqual(self.run.ftime, "%T")
|
|
self.assertEqual(str(self.run), f"#1: {self.now.strftime('%T')}")
|
|
|
|
self.run.ftime = "%c"
|
|
self.assertEqual(str(self.run), f"#1: {self.now.strftime('%c')}")
|
|
|
|
|
|
class TestDeviceRunModel(unittest.TestCase):
|
|
"""Test case for our DeviceRow GObject."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.device = xfstestsdb.gtk.tree.DeviceRunsList(name="/dev/vda1")
|
|
|
|
def test_init(self):
|
|
"""Test creating a DeviceRow instance."""
|
|
self.assertIsInstance(self.device, GObject.GObject)
|
|
self.assertIsInstance(self.device, Gio.ListModel)
|
|
self.assertEqual(self.device.name, "/dev/vda1")
|
|
self.assertEqual(str(self.device), "/dev/vda1")
|
|
|
|
def test_lt(self):
|
|
"""Test comparing DeviceRow instances."""
|
|
dev_a = xfstestsdb.gtk.tree.DeviceRunsList(name="a")
|
|
dev_b = xfstestsdb.gtk.tree.DeviceRunsList(name="b")
|
|
self.assertTrue(dev_a < dev_b)
|
|
self.assertFalse(dev_b < dev_a)
|
|
self.assertFalse(dev_a < dev_a)
|
|
|
|
def test_get_item_type(self):
|
|
"""Test the get_item_type() function."""
|
|
self.assertEqual(self.device.get_item_type(),
|
|
xfstestsdb.gtk.tree.XfstestsRun.__gtype__)
|
|
|
|
def test_get_n_items(self):
|
|
"""Test the get_n_items() function."""
|
|
self.assertEqual(self.device.get_n_items(), 0)
|
|
self.assertEqual(self.device.n_items, 0)
|
|
|
|
self.device.add_run(1, datetime.datetime.now())
|
|
self.assertEqual(self.device.get_n_items(), 1)
|
|
self.assertEqual(self.device.n_items, 1)
|
|
|
|
def test_get_item(self):
|
|
"""Test the get_item() function."""
|
|
now = datetime.datetime.now()
|
|
then = now - datetime.timedelta(seconds=42)
|
|
|
|
self.device.add_run(1, now)
|
|
self.assertIsInstance(self.device[0], xfstestsdb.gtk.tree.XfstestsRun)
|
|
self.assertEqual(self.device[0].runid, 1)
|
|
self.assertEqual(self.device[0].timestamp, now)
|
|
|
|
self.device.add_run(2, then, "%c")
|
|
self.assertEqual(self.device[0].runid, 2)
|
|
self.assertEqual(self.device[0].ftime, "%c")
|
|
self.assertEqual(self.device[1].runid, 1)
|
|
|
|
def test_get_earliest_run(self):
|
|
"""Test the get_earliest_run() function."""
|
|
self.assertIsNone(self.device.get_earliest_run())
|
|
|
|
now = datetime.datetime.now()
|
|
self.device.add_run(1, now)
|
|
self.assertEqual(self.device.get_earliest_run().runid, 1)
|
|
|
|
then = now - datetime.timedelta(seconds=42)
|
|
self.device.add_run(2, then)
|
|
self.assertEqual(self.device.get_earliest_run().runid, 2)
|
|
|
|
|
|
class TestDateDeviceList(unittest.TestCase):
|
|
"""Test case for our listmodel of test devices on a specific day."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.xfstestsdb = xfstestsdb.Command()
|
|
with unittest.mock.patch("sys.stdout"):
|
|
self.xfstestsdb.run(["new", "/dev/vda2"])
|
|
self.xfstestsdb.run(["new", "/dev/vda1"])
|
|
self.xfstestsdb.run(["new", "/dev/vda1"])
|
|
self.xfstestsdb.run(["new", "/dev/vda3"])
|
|
|
|
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)])
|
|
|
|
yesterday = datetime.datetime.now() - datetime.timedelta(days=1)
|
|
self.xfstestsdb.sql("""UPDATE xfstests_runs SET timestamp=?
|
|
WHERE device=?""", yesterday, "/dev/vda3")
|
|
|
|
self.today = datetime.date.today()
|
|
self.devlist = xfstestsdb.gtk.tree.DateDeviceList(self.xfstestsdb.sql,
|
|
self.today)
|
|
|
|
def test_init(self):
|
|
"""Test that the DateDeviceList was set up properly."""
|
|
self.assertIsInstance(self.devlist, GObject.GObject)
|
|
self.assertIsInstance(self.devlist, Gio.ListModel)
|
|
self.assertEqual(self.devlist.date, datetime.date.today())
|
|
|
|
def test_get_range(self):
|
|
"""Test finding the date range for the displayed entries."""
|
|
min = datetime.datetime.combine(self.today, datetime.time())
|
|
max = min + datetime.timedelta(days=1)
|
|
self.assertTupleEqual(self.devlist.get_range(self.today), (min, max))
|
|
|
|
def test_get_item_type(self):
|
|
"""Test the get_item_type() function."""
|
|
self.assertEqual(self.devlist.get_item_type(),
|
|
xfstestsdb.gtk.tree.DeviceRunsList.__gtype__)
|
|
|
|
def test_get_n_items(self):
|
|
"""Test the get_n_items() function."""
|
|
self.assertEqual(self.devlist.get_n_items(), 2)
|
|
self.assertEqual(self.devlist.n_items, 2)
|
|
|
|
def test_get_item(self):
|
|
"""Test the get_item() function."""
|
|
self.assertIsInstance(self.devlist.get_item(0),
|
|
xfstestsdb.gtk.tree.DeviceRunsList)
|
|
self.assertIsInstance(self.devlist.get_item(0).get_item(0).timestamp,
|
|
datetime.datetime)
|
|
self.assertEqual(self.devlist.get_item(0).name, "/dev/vda1")
|
|
self.assertEqual(self.devlist.get_item(1).name, "/dev/vda2")
|
|
|
|
def test_treemodel(self):
|
|
"""Test the treemodel property."""
|
|
self.assertIsInstance(self.devlist.treemodel, Gtk.TreeListModel)
|
|
self.assertFalse(self.devlist.treemodel.props.passthrough)
|
|
self.assertTrue(self.devlist.treemodel.props.autoexpand)
|
|
|
|
tree = self.devlist.treemodel
|
|
self.assertEqual(tree[0].get_item().name, "/dev/vda1")
|
|
self.assertEqual(tree[1].get_item().runid, 2)
|
|
self.assertEqual(tree[2].get_item().runid, 3)
|
|
self.assertEqual(tree[3].get_item().name, "/dev/vda2")
|
|
self.assertEqual(tree[4].get_item().runid, 1)
|
|
|
|
with self.assertRaises(IndexError):
|
|
self.assertIsNone(tree[5])
|
|
|
|
|
|
class TestTagDeviceList(unittest.TestCase):
|
|
"""Test case for our TagDeviceList GObject."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.tag = xfstestsdb.gtk.tree.TagDeviceList(name="mytag")
|
|
|
|
def test_init(self):
|
|
"""Test creating a TagDeviceList instance."""
|
|
self.assertIsInstance(self.tag, GObject.GObject)
|
|
self.assertIsInstance(self.tag, Gio.ListModel)
|
|
self.assertEqual(self.tag.name, "mytag")
|
|
self.assertEqual(str(self.tag), "mytag")
|
|
|
|
def test_lt(self):
|
|
"""Test comparing TagDeviceList instances."""
|
|
tag_a = xfstestsdb.gtk.tree.TagDeviceList(name="a")
|
|
tag_b = xfstestsdb.gtk.tree.TagDeviceList(name="b")
|
|
|
|
now = datetime.datetime.now()
|
|
then = now - datetime.timedelta(seconds=42)
|
|
tag_a.add_run(1, "/dev/vda1", now)
|
|
tag_b.add_run(2, "/dev/vda2", then)
|
|
|
|
self.assertTrue(tag_a < tag_b)
|
|
self.assertFalse(tag_b < tag_a)
|
|
self.assertFalse(tag_a < tag_a)
|
|
|
|
tag_a.add_run(2, "/dev/vda2", then)
|
|
self.assertTrue(tag_b < tag_a)
|
|
|
|
def test_get_item_type(self):
|
|
"""Test the get_item_type() function."""
|
|
self.assertEqual(self.tag.get_item_type(),
|
|
xfstestsdb.gtk.tree.DeviceRunsList.__gtype__)
|
|
|
|
def test_get_n_items(self):
|
|
"""Test the get_n_items() function."""
|
|
self.assertEqual(self.tag.get_n_items(), 0)
|
|
self.assertEqual(self.tag.n_items, 0)
|
|
|
|
self.tag.add_run(1, "/dev/vda1", datetime.datetime.now())
|
|
self.assertEqual(self.tag.get_n_items(), 1)
|
|
self.assertEqual(self.tag.n_items, 1)
|
|
|
|
def test_get_item(self):
|
|
"""Test the get_item() function."""
|
|
now = datetime.datetime.now()
|
|
then = now - datetime.timedelta(seconds=42)
|
|
|
|
self.tag.add_run(1, "/dev/vda2", now)
|
|
self.assertIsInstance(self.tag[0], xfstestsdb.gtk.tree.DeviceRunsList)
|
|
self.assertEqual(self.tag[0].name, "/dev/vda2")
|
|
self.assertEqual(self.tag[0][0].runid, 1)
|
|
self.assertEqual(self.tag[0][0].timestamp, now)
|
|
self.assertEqual(self.tag[0][0].ftime, "%c")
|
|
|
|
self.tag.add_run(2, "/dev/vda1", then)
|
|
self.assertEqual(self.tag[0].name, "/dev/vda1")
|
|
self.assertEqual(self.tag[1].name, "/dev/vda2")
|
|
|
|
def test_get_earliest_run(self):
|
|
"""Test the get_earliest_run() function."""
|
|
self.assertIsNone(self.tag.get_earliest_run())
|
|
|
|
now = datetime.datetime.now()
|
|
self.tag.add_run(1, "/dev/vda1", now)
|
|
self.assertEqual(self.tag.get_earliest_run().runid, 1)
|
|
|
|
then = now - datetime.timedelta(seconds=42)
|
|
self.tag.add_run(2, "/dev/vda2", then)
|
|
self.assertEqual(self.tag.get_earliest_run().runid, 2)
|