# 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.null import NullAC


## code ##

ns.bse = ns.bsfs.Entity()

class TestNullAC(unittest.TestCase):
    def setUp(self):
        self.backend = SparqlStore()
        self.backend.schema = bsc.from_string('''
            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
            prefix xsd: <http://www.w3.org/2001/XMLSchema#>

            prefix bsfs: <https://schema.bsfs.io/core/>
            prefix bsl: <https://schema.bsfs.io/core/Literal/>
            prefix bsn: <https://schema.bsfs.io/core/Node#>
            prefix bse: <https://schema.bsfs.io/core/Entity#>

            bsfs:Entity rdfs:subClassOf bsfs:Node .
            bsfs:Tag rdfs:subClassOf bsfs:Node .
            xsd:string rdfs:subClassOf bsfs:Literal .
            bsl:Number rdfs:subClassOf bsfs:Literal .
            xsd:integer rdfs:subClassOf bsl:Number .

            # predicates mandated by Nodes
            bsn:t_created rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Node ;
                rdfs:range xsd:integer ;
                bsfs:unique "true"^^xsd:boolean .

            # additionally defined predicates
            bse:tag rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Entity ;
                rdfs:range bsfs:Tag ;
                bsfs:unique "false"^^xsd:boolean .

            bse:author rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Entity ;
                rdfs:range xsd:string ;
                bsfs:unique "true"^^xsd:boolean .

            bse:filesize rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Entity ;
                rdfs:range xsd:integer ;
                bsfs:unique "false"^^xsd:boolean .

            ''')
        self.user = URI('http://www.example.com/me')
        self.p_author = self.backend.schema.predicate(ns.bse.author)
        self.p_filesize = self.backend.schema.predicate(ns.bse.filesize)
        self.p_tag = self.backend.schema.predicate(ns.bse.tag)
        self.p_created = self.backend.schema.predicate(ns.bsn.t_created)
        self.ent_type = self.backend.schema.node(ns.bsfs.Entity)
        self.ent_ids = {URI('http://www.example.com/me/entity#1234'), URI('http://www.example.com/me/entity#4321')}

    def test_essentials(self):
        ac = NullAC(self.backend, self.user)
        # equal construction means equal instance
        self.assertEqual(NullAC(self.backend, self.user), NullAC(self.backend, self.user))
        self.assertEqual(hash(NullAC(self.backend, self.user)), hash(NullAC(self.backend, self.user)))
        self.assertEqual(ac, NullAC(self.backend, self.user))
        self.assertEqual(hash(ac), hash(NullAC(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, NullAC(SparqlStore(), self.user))
        self.assertNotEqual(hash(ac), hash(NullAC(SparqlStore(), self.user)))
        # equivalence respects user
        self.assertNotEqual(ac, NullAC(self.backend, URI('http://www.example.com/you')))
        self.assertNotEqual(hash(ac), hash(NullAC(self.backend, URI('http://www.example.com/you'))))
        # string conversion
        self.assertEqual(str(ac), f'NullAC({self.user})')
        self.assertEqual(repr(ac), f'NullAC({self.user})')
        # string conversion respects user
        self.assertEqual(str(NullAC(self.backend, URI('http://www.example.com/you'))),
            f'NullAC(http://www.example.com/you)')
        self.assertEqual(repr(NullAC(self.backend, URI('http://www.example.com/you'))),
            f'NullAC(http://www.example.com/you)')

    def test_is_protected_predicate(self):
        ac = NullAC(self.backend, self.user)
        self.assertTrue(ac.is_protected_predicate(self.p_created))
        self.assertFalse(ac.is_protected_predicate(self.p_filesize))
        self.assertFalse(ac.is_protected_predicate(self.p_author))
        self.assertFalse(ac.is_protected_predicate(self.p_tag))

    def test_create(self):
        ac = NullAC(self.backend, self.user)
        self.assertEqual(None, ac.create(self.ent_type, self.ent_ids))

    def test_link_from_node(self):
        ac = NullAC(self.backend, self.user)
        self.assertSetEqual(self.ent_ids, ac.link_from_node(self.ent_type, self.ent_ids))

    def test_link_to_node(self):
        ac = NullAC(self.backend, self.user)
        self.assertSetEqual(self.ent_ids, ac.link_to_node(self.ent_type, self.ent_ids))

    def test_write_literal(self):
        ac = NullAC(self.backend, self.user)
        self.assertSetEqual(self.ent_ids, ac.write_literal(self.ent_type, self.ent_ids))

    def test_createable(self):
        ac = NullAC(self.backend, self.user)
        self.assertSetEqual(self.ent_ids, ac.createable(self.ent_type, self.ent_ids))

    def test_filter_read(self):
        query = ast.filter.Or(
            ast.filter.Any(ns.bse.tag, ast.filter.Is('http://example.com/tag#1234')),
            ast.filter.Any(ns.bse.tag, ast.filter.Is('http://example.com/tag#4321')),
            ast.filter.Any(ns.bse.author, ast.filter.Equals('Me, Myself, and I')))
        ac = NullAC(self.backend, self.user)
        # NullAC returns query
        self.assertEqual(query, ac.filter_read(self.ent_type, query))
        # query can be none
        self.assertIsNone(ac.filter_read(self.ent_type, None))

    def test_fetch_read(self):
        query = ast.fetch.All(
            ast.fetch.Fetch(ns.bse.tag, ast.fetch.Value(ns.bse.label, 'tag_label')),
            ast.fetch.Node(ns.bse.tag, 'tag_node'),
            ast.fetch.Value(ns.bse.iso, 'iso'))
        ac = NullAC(self.backend, self.user)
        # NullAC returns query
        self.assertEqual(query, ac.fetch_read(self.ent_type, query))


## main ##

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

## EOF ##