# imports
import unittest

# bsie imports
from bsfs import schema as bsc
from bsfs.namespace import ns
from bsfs.query import ast
from bsfs.triple_store import SparqlStore
from bsfs.utils import URI

# objects to test
from bsfs.graph.ac.base import AccessControlBase


## code ##

class StubAC(AccessControlBase):
    def is_protected_predicate(self, pred):
        pass
    def create(self, node_type, guids):
        pass
    def link_from_node(self, node_type, guids):
        pass
    def link_to_node(self, node_type, guids):
        pass
    def write_literal(self, node_type, guids):
        pass
    def createable(self, node_type, guids):
        pass
    def filter_read(self, node_type, query):
        pass
    def fetch_read(self, node_type, query):
        pass


class TestAccessControlBase(unittest.TestCase):
    def setUp(self):
        self.backend = SparqlStore()
        self.user = URI('http://www.example.com/me')

    def test_essentials(self):
        ac = StubAC(self.backend, self.user)
        # equal construction means equal instance
        self.assertEqual(StubAC(self.backend, self.user), StubAC(self.backend, self.user))
        self.assertEqual(hash(StubAC(self.backend, self.user)), hash(StubAC(self.backend, self.user)))
        self.assertEqual(ac, StubAC(self.backend, self.user))
        self.assertEqual(hash(ac), hash(StubAC(self.backend, self.user)))
        # equivalence respects type
        class Foo(): pass
        self.assertNotEqual(ac, 1234)
        self.assertNotEqual(hash(ac), hash(1234))
        self.assertNotEqual(ac, 'hello')
        self.assertNotEqual(hash(ac), hash('hello'))
        self.assertNotEqual(ac, Foo())
        self.assertNotEqual(hash(ac), hash(Foo()))
        # equivalence respects backend
        self.assertNotEqual(ac, StubAC(SparqlStore(), self.user))
        self.assertNotEqual(hash(ac), hash(StubAC(SparqlStore(), self.user)))
        # equivalence respects user
        self.assertNotEqual(ac, StubAC(self.backend, URI('http://www.example.com/you')))
        self.assertNotEqual(hash(ac), hash(StubAC(self.backend, URI('http://www.example.com/you'))))
        # string conversion
        self.assertEqual(str(ac), f'StubAC({self.user})')
        self.assertEqual(repr(ac), f'StubAC({self.user})')
        # string conversion respects user
        self.assertEqual(str(StubAC(self.backend, URI('http://www.example.com/you'))),
            f'StubAC(http://www.example.com/you)')
        self.assertEqual(repr(StubAC(self.backend, URI('http://www.example.com/you'))),
            f'StubAC(http://www.example.com/you)')


## main ##

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

## EOF ##