emmental/tests/db/test_table.py

# Copyright 2022 (c) Anna Schumaker
"""Tests our database object base classes."""
import unittest
import unittest.mock
import emmental.db.table
import tests.util.table
from gi.repository import GObject
from gi.repository import Gio
from gi.repository import Gtk


class TestRow(unittest.TestCase):
    """Tests our common database Row object."""

    def setUp(self):
        """Set up common variables."""
        self.table = Gio.ListStore()
        self.table.delete = unittest.mock.Mock(return_value=True)
        self.table.update = unittest.mock.Mock(return_value=True)
        self.row = tests.util.table.MockRow(table=self.table)

    def test_init(self):
        """Test that the database Row is configured correctly."""
        self.assertIsInstance(self.row, emmental.db.table.Row)
        self.assertIsInstance(self.row, GObject.GObject)
        self.assertEqual(self.row.table, self.table)

    def test_primary_key(self):
        """Test the primary_key property."""
        with self.assertRaises(NotImplementedError):
            emmental.db.table.Row(self.table).primary_key

        self.row.number = 2
        self.assertEqual(self.row.primary_key, 2)

    def test_do_update(self):
        """Test updating a Row attribute."""
        self.row.number = 1
        self.table.update.assert_called_with(self.row, "number", 1)

        self.table.update.reset_mock()
        self.row.table = None
        self.table.update.assert_not_called()

    def test_delete(self):
        """Test deleting a Row."""
        self.assertTrue(self.row.delete())
        self.table.delete.assert_called_with(self.row)


@unittest.mock.patch("gi.repository.Gtk.Filter.changed")
class TestFilter(unittest.TestCase):
    """Tests our database row Filter."""

    def setUp(self):
        """Set up common variables."""
        self.filter = emmental.db.table.Filter()
        self.table = Gio.ListStore()
        self.row1 = tests.util.table.MockRow(number=1, table=self.table)
        self.row2 = tests.util.table.MockRow(number=2, table=self.table)

    def test_init(self, mock_changed: unittest.mock.Mock):
        """Test that the filter is created correctly."""
        self.assertIsInstance(self.filter, Gtk.Filter)
        self.assertIsNone(self.filter._keys, None)
        self.assertEqual(self.filter.n_keys, -1)

        filter2 = emmental.db.table.Filter(keys={1, 2, 3})
        self.assertSetEqual(filter2._keys, {1, 2, 3})
        self.assertEqual(filter2.n_keys, 3)

    def test_subtract(self, mock_changed: unittest.mock.Mock):
        """Test subtracting two filters."""
        filter2 = emmental.db.table.Filter(keys={2, 3})
        self.assertIsNone(self.filter - self.filter)
        self.assertIsNone(self.filter - filter2)
        self.assertSetEqual(filter2 - self.filter, {2, 3})

        self.filter.keys = {1, 2, 3, 4, 5}
        self.assertSetEqual(self.filter - filter2, {1, 4, 5})
        self.assertSetEqual(filter2 - self.filter, set())

    def test_strictness(self, mock_changed: unittest.mock.Mock):
        """Test checking strictness."""
        self.assertEqual(self.filter.get_strictness(), Gtk.FilterMatch.ALL)
        self.filter._keys = set()
        self.assertEqual(self.filter.get_strictness(), Gtk.FilterMatch.NONE)
        self.filter._keys = {1, 2, 3}
        self.assertEqual(self.filter.get_strictness(), Gtk.FilterMatch.SOME)

    def test_add_row(self, mock_changed: unittest.mock.Mock):
        """Test adding Rows to the filter."""
        self.filter.add_row(self.row1)
        self.assertIsNone(self.filter.keys)

        self.filter.keys = set()
        self.filter.add_row(self.row1)
        self.assertSetEqual(self.filter.keys, {1})
        mock_changed.assert_called_with(Gtk.FilterChange.LESS_STRICT)
        self.assertEqual(self.filter.n_keys, 1)

        self.filter.add_row(self.row2)
        self.assertSetEqual(self.filter.keys, {1, 2})
        mock_changed.assert_called_with(Gtk.FilterChange.LESS_STRICT)
        self.assertEqual(self.filter.n_keys, 2)

    def test_remove_row(self, mock_changed: unittest.mock.Mock):
        """Test removing Rows from the filter."""
        self.filter.remove_row(self.row1)
        mock_changed.assert_not_called()

        self.filter.keys = {1, 2}
        self.filter.remove_row(self.row1)
        self.assertSetEqual(self.filter._keys, {2})
        mock_changed.assert_called_with(Gtk.FilterChange.MORE_STRICT)
        self.assertEqual(self.filter.n_keys, 1)

        mock_changed.reset_mock()
        self.filter.remove_row(self.row2)
        self.assertSetEqual(self.filter._keys, set())
        mock_changed.assert_called_with(Gtk.FilterChange.MORE_STRICT)
        self.assertEqual(self.filter.n_keys, 0)

    def test_keys(self, mock_changed: unittest.mock.Mock):
        """Test setting and getting the filter keys property."""
        self.assertIsNone(self.filter.keys)

        self.filter.keys = {1, 2, 3}
        self.assertSetEqual(self.filter._keys, {1, 2, 3})
        mock_changed.assert_called_with(Gtk.FilterChange.MORE_STRICT)
        self.assertEqual(self.filter.n_keys, 3)

        mock_changed.reset_mock()
        self.filter.keys = {1, 2}
        self.assertSetEqual(self.filter.keys, {1, 2})
        mock_changed.assert_called_with(Gtk.FilterChange.MORE_STRICT)
        self.assertEqual(self.filter.n_keys, 2)

        mock_changed.reset_mock()
        self.filter.keys = {1, 2}
        mock_changed.assert_not_called()

        self.filter.keys = {1, 2, 3}
        self.assertSetEqual(self.filter.keys, {1, 2, 3})
        mock_changed.assert_called_with(Gtk.FilterChange.LESS_STRICT)

        self.filter.keys = {4, 5, 6}
        self.assertSetEqual(self.filter._keys, {4, 5, 6})
        mock_changed.assert_called_with(Gtk.FilterChange.DIFFERENT)

        self.filter.keys = None
        self.assertIsNone(self.filter._keys)
        mock_changed.assert_called_with(Gtk.FilterChange.LESS_STRICT)
        self.assertEqual(self.filter.n_keys, -1)

    def test_match(self, mock_changed: unittest.mock.Mock):
        """Test matching playlists."""
        self.assertTrue(self.filter.match(self.row1))
        self.filter.keys = {1, 2, 3}
        self.assertTrue(self.filter.match(self.row1))
        self.filter.keys = {4, 5, 6}
        self.assertFalse(self.filter.match(self.row1))
        self.filter.keys = set()
        self.assertFalse(self.filter.match(self.row1))