# imports
import unittest

# bsie imports
from bsfs.utils import URI

# objects to test
from bsfs.triple_store.base import TripleStoreBase


## code ##

class DummyBase(TripleStoreBase):
    @classmethod
    def Open(cls, uri, **kwargs):
        return cls(uri)

    def commit(self):
        pass

    def rollback(self):
        pass

    @property
    def schema(self):
        pass

    @schema.setter
    def schema(self, schema):
        pass

    def get(self, node_type, query):
        pass

    def fetch(self, node_type, filter, fetch):
        pass

    def exists(self, node_type, guids):
        pass

    def create(self, node_type, guids):
        pass

    def set(self, node_type, guids, predicate, values):
        pass

class DummyStore(DummyBase):
    pass

class DummyAlternative(DummyBase):
    pass


class TestTripleStoreBase(unittest.TestCase):

    def test_equality(self):
        # identical instances are equal
        store = DummyStore.Open(None)
        self.assertEqual(store, store)
        self.assertEqual(hash(store), hash(store))
        store = DummyStore.Open(URI('http://example.com/store'))
        self.assertEqual(store, store)
        self.assertEqual(hash(store), hash(store))
        # in-memory storages are not equal
        # NOTE: Don't use
        # >>> self.assertNotEqual(hash(DummyStore(None)), hash(DummyStore(None)))
        # The two stores are created subsequently since each of them is deleted
        # right after hashing. Because the two instances never exist at the same
        # time, their id may (and typically will) be identical.
        # This only matters when the `id` function is used, i.e. when uri=None.
        a, b = DummyStore.Open(None), DummyStore.Open(None)
        self.assertNotEqual(a, b)
        self.assertNotEqual(hash(a), hash(b))
        a, b = DummyStore.Open(None), DummyStore.Open(URI('http://example.com/store'))
        self.assertNotEqual(a, b)
        self.assertNotEqual(hash(a), hash(b))
        a, b = DummyStore.Open(URI('http://example.com/store')), DummyStore.Open(None)
        self.assertNotEqual(a, b)
        self.assertNotEqual(hash(a), hash(b))
        a, b = DummyStore.Open(None), DummyStore.Open(URI('http://example.com/alternative'))
        self.assertNotEqual(a, b)
        self.assertNotEqual(hash(a), hash(b))
        # equality respects uri
        self.assertEqual(
            DummyStore.Open(URI('http://example.com/store')),
            DummyStore.Open(URI('http://example.com/store')))
        self.assertEqual(
            hash(DummyStore.Open(URI('http://example.com/alternative'))),
            hash(DummyStore.Open(URI('http://example.com/alternative'))))
        self.assertNotEqual(
            DummyStore.Open(URI('http://example.com/store')),
            DummyStore.Open(URI('http://example.com/alternative')))
        self.assertNotEqual(
            DummyStore.Open(URI('http://example.com/store')),
            hash(DummyStore.Open(URI('http://example.com/alternative'))))
        # equality respects type
        self.assertNotEqual(DummyStore.Open(None), None)
        self.assertNotEqual(hash(DummyStore.Open(None)), hash(None))
        self.assertNotEqual(DummyStore.Open(None), 'hello world')
        self.assertNotEqual(hash(DummyStore.Open(None)), hash('hello world'))
        self.assertNotEqual(DummyStore.Open(None), 1234)
        self.assertNotEqual(hash(DummyStore.Open(None)), hash(1234))
        class Foo(): pass
        f = Foo()
        self.assertNotEqual(DummyStore.Open(None), f)
        self.assertNotEqual(hash(DummyStore.Open(None)), hash(f))
        self.assertNotEqual(
            DummyStore.Open(None),
            DummyAlternative.Open(None))
        self.assertNotEqual(
            hash(DummyStore.Open(None)),
            hash(DummyAlternative.Open(None)))

    def test_string_conversion(self):
        # string conversion respects uri
        self.assertEqual('DummyStore(uri=http://example.com/store)',
            str(DummyStore.Open(URI('http://example.com/store'))))
        self.assertEqual('DummyStore(uri=http://example.com/store)',
            repr(DummyStore.Open(URI('http://example.com/store'))))
        self.assertEqual('DummyStore(uri=http://example.com/alternative)',
            str(DummyStore.Open(URI('http://example.com/alternative'))))
        self.assertEqual('DummyStore(uri=http://example.com/alternative)',
            repr(DummyStore.Open(URI('http://example.com/alternative'))))
        self.assertEqual('DummyStore(uri=None)',
            str(DummyStore.Open(None)))
        self.assertEqual('DummyStore(uri=None)',
            repr(DummyStore.Open(None)))
        # string conversion respects type
        self.assertEqual('DummyAlternative(uri=http://example.com/store)',
            str(DummyAlternative.Open(URI('http://example.com/store'))))

    def test_uri(self):
        # uri returns correct value
        self.assertEqual(None,
            DummyStore.Open(None).uri)
        self.assertEqual(URI('http://example.com/store'),
            DummyStore.Open(URI('http://example.com/store')).uri)
        self.assertEqual(URI('http://example.com/alternative'),
            DummyStore.Open(URI('http://example.com/alternative')).uri)
        # persistence respects uri
        self.assertFalse(DummyStore.Open(None).is_persistent())
        self.assertTrue(DummyStore.Open(URI('http://example.com/store')).is_persistent())
        self.assertTrue(DummyStore.Open(URI('http://example.com/alternative')).is_persistent())

## main ##

if __name__ == '__main__':
    unittest.main()

## EOF ##