"""

Part of the bsfs test suite.
A copy of the license is provided with the project.
Author: Matthias Baumgartner, 2022
"""
# imports
import unittest

# bsie imports
from bsfs import schema as _schema
from bsfs.namespace import ns
from bsfs.triple_store import SparqlStore
from bsfs.utils import URI
from bsfs.graph.nodes import Nodes

# objects to test
from bsfs.graph.graph import Graph


## code ##

class TestGraph(unittest.TestCase):
    def setUp(self):
        self.user = URI('http://example.com/me')
        self.backend = SparqlStore.Open(None)
        self.backend.schema = _schema.Schema.from_string('''
            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
            prefix bsfs: <http://bsfs.ai/schema/>
            bsfs:Entity rdfs:subClassOf bsfs:Node .
            ''')

    def test_str(self):
        self.assertEqual(str(Graph(self.backend, self.user)),
            'Graph(SparqlStore(uri=None), http://example.com/me)')
        self.assertEqual(repr(Graph(self.backend, self.user)),
            'Graph(backend=SparqlStore(uri=None), user=http://example.com/me)')
        # str respects backend
        class Foo(SparqlStore): pass
        self.assertEqual(str(Graph(Foo.Open(None), self.user)),
            'Graph(Foo(uri=None), http://example.com/me)')
        self.assertEqual(repr(Graph(Foo.Open(None), self.user)),
            'Graph(backend=Foo(uri=None), user=http://example.com/me)')
        # str respect user
        self.assertEqual(str(Graph(self.backend, URI('http://example.com/you'))),
            'Graph(SparqlStore(uri=None), http://example.com/you)')
        self.assertEqual(repr(Graph(self.backend, URI('http://example.com/you'))),
            'Graph(backend=SparqlStore(uri=None), user=http://example.com/you)')
        # str respects type
        class Bar(Graph): pass
        self.assertEqual(str(Bar(self.backend, self.user)),
            'Bar(SparqlStore(uri=None), http://example.com/me)')
        self.assertEqual(repr(Bar(self.backend, self.user)),
            'Bar(backend=SparqlStore(uri=None), user=http://example.com/me)')

    def test_equality(self):
        graph = Graph(self.backend, self.user)
        # instance is equal to itself
        self.assertEqual(graph, graph)
        self.assertEqual(hash(graph), hash(graph))
        # instance is equal to a clone
        self.assertEqual(graph, Graph(self.backend, self.user))
        self.assertEqual(hash(graph), hash(Graph(self.backend, self.user)))
        # equality respects backend
        self.assertNotEqual(graph, Graph(SparqlStore.Open(None), self.user))
        self.assertNotEqual(hash(graph), hash(Graph(SparqlStore.Open(None), self.user)))
        # equality respects user
        self.assertNotEqual(graph, Graph(self.backend, URI('http://example.com/you')))
        self.assertNotEqual(hash(graph), hash(Graph(self.backend, URI('http://example.com/you'))))

    def test_essentials(self):
        graph = Graph(self.backend, self.user)
        # schema
        self.assertEqual(graph.schema, self.backend.schema)
        self.assertRaises(AttributeError, setattr, graph, 'schema', None)

    def test_nodes(self):
        graph = Graph(self.backend, self.user)
        guids = {URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')}
        # returns a Nodes instance
        self.assertEqual(
            graph.nodes(ns.bsfs.Entity, guids),
            Nodes(self.backend, self.user, graph.schema.node(ns.bsfs.Entity), guids))
        # node_type must be in the schema
        self.assertRaises(KeyError, graph.nodes, ns.bsfs.Invalid, guids)


## main ##

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

## EOF ##