265 lines
10 KiB
Python
265 lines
10 KiB
Python
# Copyright 2022 (c) Anna Schumaker.
|
|
"""Tests our Factory implementation."""
|
|
import unittest
|
|
import unittest.mock
|
|
import emmental.factory
|
|
from gi.repository import Gio
|
|
from gi.repository import Gtk
|
|
from gi.repository import GObject
|
|
|
|
|
|
class TestListRow(unittest.TestCase):
|
|
"""Test the ListRow object."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.item = Gtk.Label(label="Test")
|
|
self.listitem = Gtk.ListItem()
|
|
self.listitem.get_item = unittest.mock.Mock(return_value=self.item)
|
|
|
|
self.row = emmental.factory.ListRow(self.listitem, child=Gtk.Label())
|
|
self.row.do_bind = unittest.mock.Mock(wraps=self.row.do_bind)
|
|
self.row.do_unbind = unittest.mock.Mock(wraps=self.row.do_unbind)
|
|
|
|
def test_init(self):
|
|
"""Test that the ListRow is set up properly."""
|
|
self.assertIsInstance(self.row, GObject.GObject)
|
|
self.assertIsInstance(self.listitem.get_child(), Gtk.Label)
|
|
|
|
self.assertListEqual(self.row.bindings, [])
|
|
self.assertEqual(self.row.listitem, self.listitem)
|
|
self.assertEqual(self.row.child, self.listitem.get_child())
|
|
self.assertEqual(self.row.item, self.item)
|
|
self.assertFalse(self.row.active)
|
|
|
|
def test_bind(self):
|
|
"""Test calling bind() on the ListRow."""
|
|
self.row.bind()
|
|
self.row.do_bind.assert_called()
|
|
|
|
def test_bind_active(self):
|
|
"""Test binding a property to the Row's active property."""
|
|
self.assertIsNone(self.row.listrow)
|
|
self.row.active = True
|
|
self.assertFalse(self.row.active)
|
|
|
|
parent = Gtk.Box()
|
|
parent.append(self.row.child)
|
|
self.assertEqual(self.row.listrow, parent)
|
|
|
|
self.row.bind_active("sensitive")
|
|
self.assertEqual(len(self.row.bindings), 1)
|
|
self.assertTrue(parent.has_css_class("emmental-active-row"))
|
|
self.assertTrue(self.row.active)
|
|
|
|
self.item.set_sensitive(False)
|
|
self.assertFalse(parent.has_css_class("emmental-active-row"))
|
|
self.assertFalse(self.row.active)
|
|
|
|
def test_bind_and_set_property(self):
|
|
"""Test the ListRow bind_property() function."""
|
|
self.row.bind_and_set_property("label", "label")
|
|
self.assertEqual(self.row.child.get_text(), "Test")
|
|
self.assertEqual(len(self.row.bindings), 1)
|
|
self.assertIsInstance(self.row.bindings[0], GObject.Binding)
|
|
|
|
self.item.set_text("Text 2")
|
|
self.assertEqual(self.row.child.get_text(), "Text 2")
|
|
|
|
self.row.child.set_text("Other Text")
|
|
self.assertEqual(self.item.get_text(), "Text 2")
|
|
|
|
def test_bind_bidirectional(self):
|
|
"""Test bidirectional bindings."""
|
|
self.row.bind_and_set_property("label", "label", bidirectional=True)
|
|
self.assertEqual(self.row.child.get_text(), "Test")
|
|
self.row.child.set_text("Other Text")
|
|
self.assertEqual(self.item.get_text(), "Other Text")
|
|
|
|
def test_bind_invert_boolean(self):
|
|
"""Test invert boolean bindings."""
|
|
self.row.bind_and_set_property("sensitive", "sensitive",
|
|
invert_boolean=True)
|
|
self.assertFalse(self.row.child.get_sensitive())
|
|
self.item.set_sensitive(False)
|
|
self.assertTrue(self.row.child.get_sensitive())
|
|
|
|
def test_unbind(self):
|
|
"""Test unbinding a ListRow."""
|
|
self.row.unbind()
|
|
self.row.do_unbind.assert_called()
|
|
self.assertEqual(len(self.row.bindings), 0)
|
|
|
|
|
|
class TestInscriptionRow(unittest.TestCase):
|
|
"""Test our pre-configured InscriptionRow."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.item = Gtk.Inscription(text="Test")
|
|
self.listitem = Gtk.ListItem()
|
|
self.listitem.get_item = unittest.mock.Mock(return_value=self.item)
|
|
|
|
def test_inscription_row(self):
|
|
"""Test that the LabelRow works as expected."""
|
|
row = emmental.factory.InscriptionRow(self.listitem,
|
|
item_property="text")
|
|
self.assertIsInstance(row, emmental.factory.ListRow)
|
|
self.assertIsInstance(row.child, Gtk.Inscription)
|
|
|
|
self.assertEqual(row.item_property, "text")
|
|
self.assertEqual(row.child.get_xalign(), 0.0)
|
|
self.assertFalse(row.child.has_css_class("numeric"))
|
|
|
|
row.bind()
|
|
self.assertEqual(row.child.get_text(), "Test")
|
|
|
|
def test_numeric_inscription(self):
|
|
"""Test that we can create numeric Labels."""
|
|
row = emmental.factory.InscriptionRow(self.listitem,
|
|
item_property="text",
|
|
xalign=1.0, numeric=True)
|
|
self.assertEqual(row.child.get_xalign(), 1.0)
|
|
self.assertTrue(row.child.has_css_class("numeric"))
|
|
|
|
|
|
class TestTreeRow(unittest.TestCase):
|
|
"""Test our pre-configured TreeRow."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.item = Gtk.Label(label="Test")
|
|
self.child = Gtk.Label()
|
|
|
|
self.treerow = Gtk.TreeListRow()
|
|
self.treerow.get_item = unittest.mock.Mock(return_value=self.item)
|
|
|
|
self.listitem = Gtk.ListItem()
|
|
self.listitem.get_item = unittest.mock.Mock(return_value=self.treerow)
|
|
self.row = emmental.factory.TreeRow(self.listitem)
|
|
|
|
def test_tree_row(self):
|
|
"""Test that the TreeRow works as expected."""
|
|
self.assertIsInstance(self.row, emmental.factory.ListRow)
|
|
self.assertIsInstance(self.listitem.get_child(), Gtk.TreeExpander)
|
|
self.assertEqual(self.row.item, self.item)
|
|
|
|
self.row.child = self.child
|
|
self.assertEqual(self.listitem.get_child().get_child(), self.child)
|
|
self.assertEqual(self.row.child, self.child)
|
|
|
|
self.row.bind()
|
|
self.assertEqual(self.listitem.get_child().get_list_row(),
|
|
self.treerow)
|
|
self.row.unbind()
|
|
self.assertIsNone(self.listitem.get_child().get_list_row())
|
|
|
|
def test_indented(self):
|
|
"""Test the indended property."""
|
|
self.assertTrue(self.row.indented)
|
|
self.assertTrue(self.listitem.get_child().get_indent_for_icon())
|
|
|
|
self.row.indented = False
|
|
self.assertFalse(self.listitem.get_child().get_indent_for_icon())
|
|
|
|
row2 = emmental.factory.TreeRow(self.listitem, indented=False)
|
|
self.assertFalse(row2.indented)
|
|
self.assertFalse(self.listitem.get_child().get_indent_for_icon())
|
|
|
|
def test_bind_n_children(self):
|
|
"""Test binding to the n_children property."""
|
|
expander = self.listitem.get_child()
|
|
liststore = Gio.ListStore()
|
|
|
|
self.assertEqual(self.row.n_children, 0)
|
|
self.assertFalse(self.row.have_children)
|
|
self.assertTrue(expander.get_hide_expander())
|
|
|
|
self.row.n_children = 1
|
|
self.assertTrue(self.row.have_children)
|
|
self.assertFalse(expander.get_hide_expander())
|
|
|
|
self.row.bind_n_children(None)
|
|
self.assertEqual(len(self.row.bindings), 0)
|
|
|
|
self.row.bind_n_children(liststore)
|
|
self.assertEqual(self.row.n_children, 0)
|
|
self.assertTrue(expander.get_hide_expander())
|
|
|
|
liststore.append(Gtk.Label())
|
|
self.assertEqual(self.row.n_children, 1)
|
|
self.assertFalse(expander.get_hide_expander())
|
|
|
|
|
|
class TestFactory(unittest.TestCase):
|
|
"""Test a Factory."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.item = Gtk.Label(label="Text")
|
|
self.listitem = Gtk.ListItem()
|
|
self.listitem.get_item = unittest.mock.Mock(return_value=self.item)
|
|
self.factory = emmental.factory.Factory(
|
|
row_type=emmental.factory.ListRow)
|
|
|
|
def test_init(self):
|
|
"""Test that the ListFactory is set up properly."""
|
|
self.assertIsInstance(self.factory, Gtk.SignalListItemFactory)
|
|
self.assertEqual(self.factory.row_type, emmental.factory.ListRow)
|
|
|
|
def test_setup(self):
|
|
"""Test the setup signal."""
|
|
self.factory.emit("setup", self.listitem)
|
|
self.assertIsInstance(self.listitem.listrow,
|
|
emmental.factory.ListRow)
|
|
|
|
def test_bind(self):
|
|
"""Test the bind signal."""
|
|
self.factory.emit("setup", self.listitem)
|
|
self.listitem.listrow.bind = unittest.mock.Mock()
|
|
self.factory.emit("bind", self.listitem)
|
|
self.listitem.listrow.bind.assert_called()
|
|
|
|
def test_unbind(self):
|
|
"""Test the unbind signal."""
|
|
self.factory.emit("setup", self.listitem)
|
|
self.listitem.listrow.unbind = unittest.mock.Mock()
|
|
self.factory.emit("unbind", self.listitem)
|
|
self.listitem.listrow.unbind.assert_called()
|
|
|
|
def test_teardown(self):
|
|
"""Test the teardown signal."""
|
|
self.factory.emit("setup", self.listitem)
|
|
self.factory.emit("teardown", self.listitem)
|
|
self.assertIsNone(self.listitem.get_child())
|
|
self.assertIsNone(self.listitem.listrow)
|
|
|
|
|
|
class TestInscriptionFactory(unittest.TestCase):
|
|
"""Test an Inscription Factory."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
self.item = Gtk.Inscription(text="Text")
|
|
self.listitem = Gtk.ListItem()
|
|
self.listitem.get_item = unittest.mock.Mock(return_value=self.item)
|
|
|
|
def test_init(self):
|
|
"""Test a basic LabelFactory."""
|
|
factory = emmental.factory.InscriptionFactory(item_property="text",
|
|
xalign=1.0, numeric=True)
|
|
self.assertIsInstance(factory, emmental.factory.Factory)
|
|
self.assertEqual(factory.row_type, emmental.factory.InscriptionRow)
|
|
|
|
factory.emit("setup", self.listitem)
|
|
self.assertIsInstance(self.listitem.listrow,
|
|
emmental.factory.InscriptionRow)
|
|
self.assertEqual(self.listitem.get_child().get_xalign(), 1.0)
|
|
self.assertTrue(self.listitem.get_child().has_css_class("numeric"))
|
|
|
|
def test_script_type(self):
|
|
"""Test a LabelFactory that makes other types of LabelRows."""
|
|
factory = emmental.factory.InscriptionFactory(
|
|
script_type=Gtk.EditableLabel, item_property="label")
|
|
self.assertEqual(factory.row_type, Gtk.EditableLabel)
|