emmental/db/test_objects.py

# Copyright 2021 (c) Anna Schumaker.
import unittest
from gi.repository import GObject
from . import objects

class FakeCursor:
    def __init__(self, lastrowid): self.lastrowid = lastrowid
    def fetchone(self): return (self.lastrowid,) if self.lastrowid else None
    def fetchall(self): return [ (2,), (3,) ] if self.lastrowid else None


class TestRow(unittest.TestCase):
    def test_row(self):
        row = objects.Row(1)
        self.assertEqual(row.rowid, 1)
        self.assertIsInstance(row, GObject.GObject)

        self.assertEqual(int(row), 1)
        self.assertEqual(row, objects.Row(1))
        self.assertNotEqual(row, objects.Row(2))

        with self.assertRaises(NotImplementedError):
            row.do_get_column("test")


class FakeTagCursor:
    def __init__(self, col, text):
        self.col = col
        self.text = text
    def fetchone(self): return { self.col : self.text }

class FakeTag(objects.Tag):
    def __init__(self, tid, name, sort):
        objects.Tag.__init__(self, tid)
        self.fake_name = name
        self.fake_sort = sort

    def do_get_column(self, column):
        if column == "name":
            return FakeTagCursor(column, self.fake_name)
        return FakeTagCursor(column, self.fake_sort)

class TestTag(unittest.TestCase):
    def test_tag(self):
        a = FakeTag(1, "A", "a")
        b = FakeTag(1, "B", "b")

        self.assertIsInstance(a, objects.Tag)
        self.assertEqual(a.name, "A")
        self.assertEqual(a.sort, "a")
        self.assertEqual(str(a), "A")

        self.assertEqual(a.get_property("name"), "A")
        self.assertEqual(a.get_property("sort"), "a")

        self.assertTrue(a < b)
        self.assertTrue(b > a)

        self.assertFalse(a > b)
        self.assertFalse(b < a)


class FakeTable(objects.Table):
    def do_create(self): self.create_called = True
    def do_insert(self, insert, args): return FakeCursor(1)
    def do_delete(self, obj): self.delete_called = True
    def do_get(self, rowid): return FakeCursor(1)
    def do_get_all(self): return FakeCursor(1)
    def do_lookup(self, lookup, args):
        return FakeCursor(1) if lookup == "lookup" else FakeCursor(None)

class TestTable(unittest.TestCase):
    def on_row_inserted(self, table, row):
        self.row_inserted = row

    def on_row_deleted(self, table, row):
        self.row_deleted = row

    def test_table_errors(self):
        with self.assertRaises(NotImplementedError):
            table = objects.Table("table", objects.Row)
        with self.assertRaises(NotImplementedError):
            objects.Table.do_delete(None, objects.Row(1))
        with self.assertRaises(NotImplementedError):
            objects.Table.do_insert(None, "insert", "arguments")
        with self.assertRaises(NotImplementedError):
            objects.Table.do_get(None, 2)
        with self.assertRaises(NotImplementedError):
            objects.Table.do_get_all(None)
        with self.assertRaises(NotImplementedError):
            objects.Table.do_lookup(None, "lookup", "arguments")

    def test_table(self):
        table = FakeTable("fake", objects.Row)
        table.connect("row-inserted", self.on_row_inserted)
        table.connect("row-deleted", self.on_row_deleted)

        self.assertIsInstance(table, GObject.GObject)
        self.assertEqual(table.table_name, "fake")
        self.assertEqual(table.table_type, objects.Row)
        self.assertTrue(table.create_called)

        self.assertEqual(table.insert("insert", "arguments"), objects.Row(1))
        self.assertEqual(self.row_inserted, objects.Row(1))

        table.delete(objects.Row(1))
        self.assertEqual(self.row_deleted, objects.Row(1))
        self.assertTrue(table.delete_called)

        self.assertEqual(table.get(1), objects.Row(1))
        self.assertEqual(table[1], objects.Row(1))

        self.assertEqual(table.get_all(), [ objects.Row(2), objects.Row(3) ])

        self.assertEqual(table.lookup("lookup", "arguments"), objects.Row(1))

        self.row_inserted = None
        self.assertEqual(table.find("find", "arguments"), objects.Row(1))
        self.assertEqual(self.row_inserted, objects.Row(1))


class FakeMap(objects.Map):
    def do_create(self): self.create_called = True
    def do_insert(self, lhs, rhs): return FakeCursor(1)
    def do_delete(self, lhs, rhs): return FakeCursor(1)
    def do_lookup_rhs(self, lhs): return FakeCursor(1)
    def do_lookup_lhs(self, lhs): return FakeCursor(1)

class TestMap(unittest.TestCase):
    def on_row_inserted(self, table, lhs, rhs):
        self.row_inserted = (lhs, rhs)

    def on_row_deleted(self, table, lhs, rhs):
        self.row_deleted = (lhs, rhs)

    def test_map_errors(self):
        with self.assertRaises(NotImplementedError):
            map = objects.Map("test_map", objects.Tag, objects.Row)
        with self.assertRaises(NotImplementedError):
            objects.Map.do_insert(None, True, False)
        with self.assertRaises(NotImplementedError):
            objects.Map.do_delete(None, True, False)
        with self.assertRaises(NotImplementedError):
            objects.Map.do_lookup_rhs(None, None)
        with self.assertRaises(NotImplementedError):
            objects.Map.do_lookup_lhs(None, None)

    def test_map(self):
        map = FakeMap("test_map", objects.Row, objects.Row)
        map.connect("row-inserted", self.on_row_inserted)
        map.connect("row-deleted", self.on_row_deleted)

        self.assertIsInstance(map, GObject.GObject)
        self.assertEqual(map.map_name, "test_map")
        self.assertEqual(map.map_lhs, objects.Row)
        self.assertEqual(map.map_rhs, objects.Row)
        self.assertTrue(map.create_called)

        map.insert(objects.Row(1), objects.Row(2))
        self.assertEqual(self.row_inserted, (objects.Row(1), objects.Row(2)))

        map.delete(objects.Row(1), objects.Row(2))
        self.assertEqual(self.row_deleted, (objects.Row(1), objects.Row(2)))

        rhs_list = map.lookup_rhs(objects.Row(1))
        self.assertEqual(rhs_list, [ objects.Row(2), objects.Row(3) ])

        lhs_list = map.lookup_lhs(objects.Row(2))
        self.assertEqual(lhs_list, [ objects.Row(2), objects.Row(3) ])