180 lines
7.9 KiB
Python
180 lines
7.9 KiB
Python
# Copyright 2022 (c) Anna Schumaker.
|
|
"""Test our Settings manager."""
|
|
import emmental.db
|
|
import tests.util
|
|
import unittest.mock
|
|
from gi.repository import GObject
|
|
|
|
|
|
class FakeObj(GObject.GObject):
|
|
"""A fake object used for testing."""
|
|
|
|
prop_int = GObject.Property(type=int)
|
|
prop_float = GObject.Property(type=float)
|
|
prop_bool = GObject.Property(type=bool, default=False)
|
|
prop_str = GObject.Property(type=str)
|
|
|
|
|
|
class TestSetting(tests.util.TestCase):
|
|
"""Test case for our settings manager."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
super().setUp()
|
|
self.settings = self.sql.settings
|
|
|
|
def test_init(self):
|
|
"""Test that the Settings Manager is set up properly."""
|
|
self.assertIsInstance(self.settings, emmental.db.table.Table)
|
|
|
|
def test_get_sort_key(self):
|
|
"""Test comparing settings."""
|
|
a = self.settings.create("Test.A", "gint", 1)
|
|
self.assertEqual(self.settings.do_get_sort_key(a), ["test", "a"])
|
|
|
|
def test_int_setting(self):
|
|
"""Test constructing and creating int settings."""
|
|
with unittest.mock.patch.object(self.settings, "construct",
|
|
wraps=self.settings.construct) as mock:
|
|
setting = self.settings.create("test.int", "gint", 42)
|
|
self.assertIsInstance(setting, emmental.db.table.Row)
|
|
self.assertIsInstance(setting, emmental.db.settings.Setting)
|
|
self.assertIsInstance(setting, emmental.db.settings.IntSetting)
|
|
self.assertEqual(setting.table, self.settings)
|
|
self.assertEqual(setting.primary_key, "test.int")
|
|
self.assertEqual(setting.key, "test.int")
|
|
self.assertEqual(setting.value, 42)
|
|
mock.assert_called_with(key="test.int", type="gint", value="42")
|
|
|
|
def test_float_setting(self):
|
|
"""Test constructing and creating float settings."""
|
|
with unittest.mock.patch.object(self.settings, "construct",
|
|
wraps=self.settings.construct) as mock:
|
|
setting = self.settings.create("test.float", "gdouble", 4.2)
|
|
self.assertIsInstance(setting, emmental.db.table.Row)
|
|
self.assertIsInstance(setting, emmental.db.settings.Setting)
|
|
self.assertIsInstance(setting, emmental.db.settings.FloatSetting)
|
|
self.assertEqual(setting.table, self.settings)
|
|
self.assertEqual(setting.primary_key, "test.float")
|
|
self.assertEqual(setting.key, "test.float")
|
|
self.assertEqual(setting.value, 4.2)
|
|
mock.assert_called_with(key="test.float",
|
|
type="gdouble", value="4.2")
|
|
|
|
def test_bool_setting(self):
|
|
"""Test constructing and creating string settings."""
|
|
with unittest.mock.patch.object(self.settings, "construct",
|
|
wraps=self.settings.construct) as mock:
|
|
setting = self.settings.create("test.bool", "gboolean", True)
|
|
self.assertIsInstance(setting, emmental.db.table.Row)
|
|
self.assertIsInstance(setting, emmental.db.settings.Setting)
|
|
self.assertIsInstance(setting, emmental.db.settings.BoolSetting)
|
|
self.assertEqual(setting.table, self.settings)
|
|
self.assertEqual(setting.primary_key, "test.bool")
|
|
self.assertEqual(setting.key, "test.bool")
|
|
self.assertEqual(setting.value, True)
|
|
mock.assert_called_with(key="test.bool",
|
|
type="gboolean", value="True")
|
|
|
|
def test_string_setting(self):
|
|
"""Test constructing and creating string settings."""
|
|
with unittest.mock.patch.object(self.settings, "construct",
|
|
wraps=self.settings.construct) as mock:
|
|
setting = self.settings.create("test.string", "gchararray", "test")
|
|
self.assertIsInstance(setting, emmental.db.table.Row)
|
|
self.assertIsInstance(setting, emmental.db.settings.Setting)
|
|
self.assertIsInstance(setting, emmental.db.settings.StringSetting)
|
|
self.assertEqual(setting.table, self.settings)
|
|
self.assertEqual(setting.primary_key, "test.string")
|
|
self.assertEqual(setting.key, "test.string")
|
|
self.assertEqual(setting.value, "test")
|
|
mock.assert_called_with(key="test.string",
|
|
type="gchararray", value="test")
|
|
|
|
def test_create_db(self):
|
|
"""Test that creating a setting modifies the database."""
|
|
self.settings.create("test.int", "gint", 42)
|
|
row = self.sql("""SELECT key, type, value FROM settings
|
|
WHERE key='test.int'""").fetchone()
|
|
self.assertEqual(row["key"], "test.int")
|
|
self.assertEqual(row["type"], "gint")
|
|
self.assertEqual(row["value"], "42")
|
|
|
|
self.assertIsNone(self.settings.create("test.int", "gint", 44))
|
|
|
|
def test_delete(self):
|
|
"""Test deleting settings."""
|
|
setting = self.settings.create("test.int", "gint", 42)
|
|
self.assertTrue(setting.delete())
|
|
self.assertIsNone(self.settings.lookup("test.int"))
|
|
self.assertFalse(setting.delete())
|
|
|
|
def test_filter(self):
|
|
"""Test filtering settings."""
|
|
self.settings.create("test.int", "gint", 42)
|
|
self.settings.create("other.int", "gint", 21)
|
|
self.settings.filter("test.*")
|
|
self.assertEqual(self.settings.get_filter().keys, {"test.int"})
|
|
self.settings.filter("*.int")
|
|
self.assertEqual(self.settings.get_filter().keys, {"test.int",
|
|
"other.int"})
|
|
|
|
def test_load(self):
|
|
"""Test loading settings."""
|
|
self.settings.create("test.int", "gint", 42)
|
|
self.settings.create("test.float", "gdouble", 4.2)
|
|
self.settings.create("test.string,", "gchararray", "abc")
|
|
self.settings.create("test.bool", "gboolean", True)
|
|
|
|
settings2 = emmental.db.settings.Table(self.sql)
|
|
self.assertEqual(len(settings2), 0)
|
|
|
|
settings2.load()
|
|
self.assertEqual(len(settings2), 4)
|
|
self.assertEqual(settings2.get_item(0).value, True)
|
|
self.assertEqual(settings2.get_item(1).value, 4.2)
|
|
self.assertEqual(settings2.get_item(2).value, 42)
|
|
self.assertEqual(settings2.get_item(3).value, "abc")
|
|
|
|
def test_lookup(self):
|
|
"""Test looking up settings."""
|
|
set_int = self.settings.create("test.int", "gint", 42)
|
|
set_float = self.settings.create("test.float", "gdouble", 4.2)
|
|
|
|
self.assertEqual(self.settings.lookup("test.int"), set_int)
|
|
self.assertEqual(self.settings["test.int"], 42)
|
|
self.assertEqual(self.settings.lookup("test.float"), set_float)
|
|
self.assertEqual(self.settings["test.float"], 4.2)
|
|
self.assertIsNone(self.settings.lookup("test.none"))
|
|
self.assertIsNone(self.settings["test.none"])
|
|
|
|
def test_update(self):
|
|
"""Test updating settings."""
|
|
setting = self.settings.create("test.int", "gint", 42)
|
|
setting.value = 21
|
|
|
|
cur = self.sql("SELECT value FROM settings WHERE key=?", setting.key)
|
|
self.assertEqual(cur.fetchone()["value"], "21")
|
|
|
|
def test_bind_setting(self):
|
|
"""Test setting an integer value."""
|
|
fake = FakeObj(prop_int=42)
|
|
|
|
self.settings.bind_setting("test.int", fake, "prop_int")
|
|
setting = self.settings.lookup("test.int")
|
|
self.assertIsInstance(setting, emmental.db.settings.IntSetting)
|
|
self.assertEqual(setting.value, 42)
|
|
|
|
setting.set_property("value", 21)
|
|
self.assertEqual(fake.prop_int, 21)
|
|
fake.prop_int = 84
|
|
self.assertEqual(setting.value, 84)
|
|
|
|
fake2 = FakeObj(prop_int=13)
|
|
self.settings.bind_setting("test.int", fake2, "prop_int")
|
|
self.assertEqual(fake2.prop_int, 84)
|
|
|
|
setting.value = 42
|
|
self.assertEqual(fake.prop_int, 42)
|
|
self.assertEqual(fake2.prop_int, 42)
|