# imports
import rdflib
import unittest

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

# objects to test
from bsfs.triple_store.sparql.sparql import SparqlStore


## code ##

ns.bse = ns.bsfs.Entity()

class TestSparqlStore(unittest.TestCase):
    def setUp(self):
        self.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 bse: <https://schema.bsfs.io/core/Entity#>
            prefix bsl: <https://schema.bsfs.io/core/Literal/>

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

            # non-unique literal
            bse:comment rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Entity ;
                rdfs:range xsd:string ;
                bsfs:unique "false"^^xsd:boolean .

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

            # non-unique node
            bse:tag rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Entity ;
                rdfs:range bsfs:Tag ;
                bsfs:unique "false"^^xsd:boolean .

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

            # binary range
            bse:asset rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Entity ;
                rdfs:range bsl:BinaryBlob .

            ''')
        self.schema_triples = {
            # schema hierarchy
            (rdflib.URIRef(ns.bsfs.Entity), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
            (rdflib.URIRef(ns.bsfs.Tag), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
            (rdflib.URIRef(ns.bsfs.User), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
            (rdflib.URIRef(ns.xsd.string), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
            (rdflib.URIRef(ns.bsl.Array), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
            (rdflib.URIRef(ns.bsl.BinaryBlob), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
            (rdflib.URIRef(ns.bsl.Array.Feature), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsl.Array)),
            (rdflib.URIRef(ns.bsl.Number), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
            (rdflib.URIRef(ns.bsl.Time), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
            (rdflib.URIRef(ns.xsd.integer), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsl.Number)),
            (rdflib.URIRef(ns.bse.comment), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef(ns.bse.filesize), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef(ns.bse.tag), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef(ns.bse.author), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef(ns.bse.asset), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            }

    def test_essentials(self):
        store = SparqlStore.Open()
        # equality
        self.assertEqual(store, store)
        self.assertEqual(hash(store), hash(store))
        self.assertNotEqual(store, SparqlStore.Open())
        self.assertNotEqual(hash(store), hash(SparqlStore.Open()))
        # string conversion
        self.assertEqual(str(store), 'SparqlStore(uri=None)')
        self.assertEqual(repr(store), 'SparqlStore(uri=None)')
        # open
        self.assertIsInstance(SparqlStore.Open(), SparqlStore)


    def test__has_type(self):
        # setup store
        store = SparqlStore.Open()
        store.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/>

            bsfs:Entity rdfs:subClassOf bsfs:Node .
            bsfs:Document rdfs:subClassOf bsfs:Entity .
            bsfs:Image rdfs:subClassOf bsfs:Entity .
            bsfs:PDF rdfs:subClassOf bsfs:Document .

            ''')
        # add some instances
        store.create(store.schema.node(ns.bsfs.Entity), {URI('http://example.com/me/entity#1234')})
        store.create(store.schema.node(ns.bsfs.Document), {URI('http://example.com/me/document#1234')})
        store.create(store.schema.node(ns.bsfs.Image), {URI('http://example.com/me/image#1234')})
        store.create(store.schema.node(ns.bsfs.PDF), {URI('http://example.com/me/pdf#1234')})

        # node_type must be in the schema
        self.assertRaises(errors.ConsistencyError, store._has_type, URI('http://example.com/me/entity#1234'), store.schema.node(ns.bsfs.Node).child(ns.bsfs.invalid))

        # returns False on inexistent nodes
        self.assertFalse(store._has_type(URI('http://example.com/me/entity#4321'), store.schema.node(ns.bsfs.Entity)))
        self.assertFalse(store._has_type(URI('http://example.com/me/document#4321'), store.schema.node(ns.bsfs.Document)))
        self.assertFalse(store._has_type(URI('http://example.com/me/image#4321'), store.schema.node(ns.bsfs.Image)))
        self.assertFalse(store._has_type(URI('http://example.com/me/pdf#4321'), store.schema.node(ns.bsfs.PDF)))

        # _has_type checks direct types
        self.assertTrue(store._has_type(URI('http://example.com/me/entity#1234'), store.schema.node(ns.bsfs.Entity)))
        self.assertTrue(store._has_type(URI('http://example.com/me/document#1234'), store.schema.node(ns.bsfs.Document)))
        self.assertTrue(store._has_type(URI('http://example.com/me/image#1234'), store.schema.node(ns.bsfs.Image)))
        self.assertTrue(store._has_type(URI('http://example.com/me/pdf#1234'), store.schema.node(ns.bsfs.PDF)))

        # _has_type checks type hierarchy
        self.assertFalse(store._has_type(URI('http://example.com/me/entity#1234'), store.schema.node(ns.bsfs.Document)))
        self.assertFalse(store._has_type(URI('http://example.com/me/entity#1234'), store.schema.node(ns.bsfs.Image)))
        self.assertFalse(store._has_type(URI('http://example.com/me/entity#1234'), store.schema.node(ns.bsfs.PDF)))

        self.assertTrue(store._has_type(URI('http://example.com/me/document#1234'), store.schema.node(ns.bsfs.Entity)))
        self.assertFalse(store._has_type(URI('http://example.com/me/document#1234'), store.schema.node(ns.bsfs.Image)))
        self.assertFalse(store._has_type(URI('http://example.com/me/document#1234'), store.schema.node(ns.bsfs.PDF)))

        self.assertTrue(store._has_type(URI('http://example.com/me/image#1234'), store.schema.node(ns.bsfs.Entity)))
        self.assertFalse(store._has_type(URI('http://example.com/me/image#1234'), store.schema.node(ns.bsfs.Document)))
        self.assertFalse(store._has_type(URI('http://example.com/me/image#1234'), store.schema.node(ns.bsfs.PDF)))

        self.assertTrue(store._has_type(URI('http://example.com/me/pdf#1234'), store.schema.node(ns.bsfs.Entity)))
        self.assertTrue(store._has_type(URI('http://example.com/me/pdf#1234'), store.schema.node(ns.bsfs.Document)))
        self.assertFalse(store._has_type(URI('http://example.com/me/pdf#1234'), store.schema.node(ns.bsfs.Image)))


    def test_schema(self):
        # setup
        store = SparqlStore.Open()
        curr = self.schema
        p_comment = curr.predicate(ns.bse.comment)
        p_filesize = curr.predicate(ns.bse.filesize)
        p_tag = curr.predicate(ns.bse.tag)
        p_author = curr.predicate(ns.bse.author)

        # migrate to an initial schema
        store.schema = curr
        # store has migrated
        self.assertEqual(store.schema, curr)

        # add some instances
        ent_ids = {URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')}
        tag_ids = {URI('http://example.com/me/tag#1234'), URI('http://example.com/me/tag#4321')}
        store.create(curr.node(ns.bsfs.Entity), ent_ids)
        store.create(curr.node(ns.bsfs.Tag), tag_ids)
        store.create(curr.node(ns.bsfs.User), {URI('http://example.com/me')})
        # add some triples
        store.set(curr.node(ns.bsfs.Entity), ent_ids, p_comment, {'foo', 'bar'})
        store.set(curr.node(ns.bsfs.Entity), ent_ids, p_filesize, {1234})
        store.set(curr.node(ns.bsfs.Entity), ent_ids, p_tag,
            {URI('http://example.com/me/tag#1234'), URI('http://example.com/me/tag#4321')})
        store.set(curr.node(ns.bsfs.Entity), ent_ids, p_author,
            {URI('http://example.com/me')})
        # check instances
        instances = self.schema_triples | {
            # node instances
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Tag)),
            (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Tag)),
            (rdflib.URIRef('http://example.com/me'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.User)),
            # comments
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_comment.uri), rdflib.Literal('foo', datatype=rdflib.XSD.string)),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_comment.uri), rdflib.Literal('bar', datatype=rdflib.XSD.string)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_comment.uri), rdflib.Literal('foo', datatype=rdflib.XSD.string)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_comment.uri), rdflib.Literal('bar', datatype=rdflib.XSD.string)),
            # filesize
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_filesize.uri), rdflib.Literal('1234', datatype=rdflib.XSD.integer)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_filesize.uri), rdflib.Literal('1234', datatype=rdflib.XSD.integer)),
            # tags
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
            # author
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_author.uri), rdflib.URIRef('http://example.com/me')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_author.uri), rdflib.URIRef('http://example.com/me')),
            }
        self.assertSetEqual(set(store._graph), instances)

        # add some classes to the schema
        curr = curr + 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 bse: <https://schema.bsfs.io/core/Entity#>
            prefix bst: <https://schema.bsfs.io/core/Tag#>
            prefix bsc: <https://schema.bsfs.io/core/Collection#>

            bsfs:Entity rdfs:subClassOf bsfs:Node .
            bsfs:Tag rdfs:subClassOf bsfs:Node .
            bsfs:Collection rdfs:subClassOf bsfs:Node .
            xsd:boolean rdfs:subClassOf bsfs:Literal .

            # literal
            bse:shared rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Entity ;
                rdfs:range xsd:boolean ;
                bsfs:unique "true"^^xsd:boolean .

            # node
            bse:partOf rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Entity ;
                rdfs:range bsfs:Collection ;
                bsfs:unique "false"^^xsd:boolean .

            # predicates across auxiliary node classes
            bst:usedIn rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Tag ;
                rdfs:range bsfs:Collection ;
                bsfs:unique "false"^^xsd:boolean .

            bsc:tag rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Collection ;
                rdfs:range bsfs:Tag ;
                bsfs:unique "false"^^xsd:boolean .

            bst:principal rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Tag ;
                rdfs:range bsfs:Node ;
                bsfs:unique "true"^^xsd:boolean .

            ''')
        # store migrated to the new schema
        store.schema = curr
        self.assertEqual(store.schema, curr)
        # instances have not changed
        self.assertSetEqual(set(store._graph), instances | {
            # schema hierarchy
            (rdflib.URIRef(ns.bsfs.Collection), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
            (rdflib.URIRef(ns.xsd.boolean), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
            (rdflib.URIRef(ns.bse.shared), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef(ns.bse.partOf), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef('https://schema.bsfs.io/core/Tag#usedIn'), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef('https://schema.bsfs.io/core/Collection#tag'), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef('https://schema.bsfs.io/core/Tag#principal'), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            })
        # add some instances of the new classes
        p_partOf = curr.predicate(ns.bse.partOf)
        p_shared = curr.predicate(ns.bse.shared)
        p_usedIn = curr.predicate('https://schema.bsfs.io/core/Tag#usedIn')
        p_ctag = curr.predicate('https://schema.bsfs.io/core/Collection#tag')
        p_principal = curr.predicate('https://schema.bsfs.io/core/Tag#principal')
        store.create(curr.node(ns.bsfs.Collection), {URI('http://example.com/me/collection#1234'), URI('http://example.com/me/collection#4321')})
        # add some more triples
        store.set(curr.node(ns.bsfs.Entity), ent_ids, p_shared, {True})
        store.set(curr.node(ns.bsfs.Entity), ent_ids, p_partOf,
            {URI('http://example.com/me/collection#1234'), URI('http://example.com/me/collection#4321')})
        store.set(curr.node(ns.bsfs.Tag), {URI('http://example.com/me/tag#1234')}, p_usedIn,
            {URI('http://example.com/me/collection#1234')})
        store.set(curr.node(ns.bsfs.Collection), {URI('http://example.com/me/collection#4321')}, p_ctag,
            {URI('http://example.com/me/tag#1234'), URI('http://example.com/me/tag#4321')})
        store.set(curr.node(ns.bsfs.Tag), {URI('http://example.com/me/tag#1234')}, p_principal,
            {URI('http://example.com/me/collection#1234')})
        # new instances are now in the graph
        self.assertSetEqual(set(store._graph), instances | {
            # same old schema hierarchy
            (rdflib.URIRef(ns.bsfs.Collection), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
            (rdflib.URIRef(ns.xsd.boolean), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
            (rdflib.URIRef(ns.bse.shared), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef(ns.bse.partOf), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef('https://schema.bsfs.io/core/Tag#usedIn'), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef('https://schema.bsfs.io/core/Collection#tag'), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef('https://schema.bsfs.io/core/Tag#principal'), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            # collections
            (rdflib.URIRef('http://example.com/me/collection#1234'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Collection)),
            (rdflib.URIRef('http://example.com/me/collection#4321'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Collection)),
            # partOf
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_partOf.uri), rdflib.URIRef('http://example.com/me/collection#1234')),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_partOf.uri), rdflib.URIRef('http://example.com/me/collection#4321')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_partOf.uri), rdflib.URIRef('http://example.com/me/collection#1234')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_partOf.uri), rdflib.URIRef('http://example.com/me/collection#4321')),
            # shared
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_shared.uri), rdflib.Literal('true', datatype=rdflib.XSD.boolean)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_shared.uri), rdflib.Literal('true', datatype=rdflib.XSD.boolean)),
            # auxiliary node connections
            (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.URIRef(p_usedIn.uri), rdflib.URIRef('http://example.com/me/collection#1234')),
            (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.URIRef(p_principal.uri), rdflib.URIRef('http://example.com/me/collection#1234')),
            (rdflib.URIRef('http://example.com/me/collection#4321'), rdflib.URIRef(p_ctag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
            (rdflib.URIRef('http://example.com/me/collection#4321'), rdflib.URIRef(p_ctag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
            })


        # remove some classes from the schema
        curr = 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 bse: <https://schema.bsfs.io/core/Entity#>
            prefix bst: <https://schema.bsfs.io/core/Tag#>
            prefix bsl: <https://schema.bsfs.io/core/Literal/>

            bsfs:Entity rdfs:subClassOf bsfs:Node .
            bsfs:Tag rdfs:subClassOf bsfs:Node .
            bsfs:User rdfs:subClassOf bsfs:Node .

            xsd:boolean rdfs:subClassOf bsfs:Literal .
            bsl:Number rdfs:subClassOf bsfs:Literal .
            xsd:integer rdfs:subClassOf bsl:Number .

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

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

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

            bst:principal rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Tag ;
                rdfs:range bsfs:Node ;
                bsfs:unique "true"^^xsd:boolean .

            # removed: bsfs:Collection
            # removed: xsd:string
            # removed: bse:comment (bsfs:Entity -> xsd:string)
            # removed: bse:partOf (bsfs:Entity -> bsfs:Collection)
            # removed: bse:author (bsfs:entity -> bsfs:User)
            # removed: bst:usedIn (bsfs:Tag -> bsfs:Collection)
            # removed: bsc:tag (bsfs:Collection -> bsfs:Tag)

            ''')
        # store migrated to the new schema
        store.schema = curr
        self.assertEqual(store.schema, curr)
        # instances of old classes were removed
        self.assertSetEqual(set(store._graph), {
            # schema hierarchy
            (rdflib.URIRef(ns.bsfs.Entity), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
            (rdflib.URIRef(ns.bsfs.Tag), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
            (rdflib.URIRef(ns.bsfs.User), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Node)),
            (rdflib.URIRef(ns.xsd.boolean), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
            (rdflib.URIRef(ns.bsl.Array), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
            (rdflib.URIRef(ns.bsl.BinaryBlob), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
            (rdflib.URIRef(ns.bsl.Array.Feature), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsl.Array)),
            (rdflib.URIRef(ns.bsl.Number), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
            (rdflib.URIRef(ns.bsl.Time), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Literal)),
            (rdflib.URIRef(ns.xsd.integer), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsl.Number)),
            (rdflib.URIRef(ns.bse.shared), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef(ns.bse.tag), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef(ns.bse.filesize), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            (rdflib.URIRef('https://schema.bsfs.io/core/Tag#principal'), rdflib.RDFS.subClassOf, rdflib.URIRef(ns.bsfs.Predicate)),
            # node instances
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Tag)),
            (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Tag)),
            (rdflib.URIRef('http://example.com/me'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.User)),
            # filesize
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_filesize.uri), rdflib.Literal('1234', datatype=rdflib.XSD.integer)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_filesize.uri), rdflib.Literal('1234', datatype=rdflib.XSD.integer)),
            # tags
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
            # shared
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_shared.uri), rdflib.Literal('true', datatype=rdflib.XSD.boolean)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_shared.uri), rdflib.Literal('true', datatype=rdflib.XSD.boolean)),
            })

        # can only assign schema instances
        self.assertRaises(TypeError, setattr, store, 'schema', None)
        self.assertRaises(TypeError, setattr, store, 'schema', 1234)
        self.assertRaises(TypeError, setattr, store, 'schema', 'foo')
        class Foo(): pass
        self.assertRaises(TypeError, setattr, store, 'schema', Foo())

        # cannot define features w/o known distance function
        invalid = 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 bse: <https://schema.bsfs.io/core/Entity#>
            prefix bsl: <https://schema.bsfs.io/core/Literal/>
            prefix bsa: <https://schema.bsfs.io/core/Literal/Array/>

            bsl:Array rdfs:subClassOf bsfs:Literal .
            bsa:Feature rdfs:subClassOf bsl:Array .

            bsfs:Colors rdfs:subClassOf bsa:Feature ;
                bsfs:dimension "4"^^xsd:integer ;
                bsfs:distance bsfs:foobar .

            ''')
        self.assertRaises(errors.UnsupportedError, setattr, store, 'schema', invalid)

        # cannot migrate to incompatible schema
        invalid = 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 bse: <https://schema.bsfs.io/core/Entity#>

            bsfs:Entity rdfs:subClassOf bsfs:Node .
            bsfs:Tag rdfs:subClassOf bsfs:Entity . # inconsistent with previous tag definition

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

            ''')
        self.assertRaises(errors.ConsistencyError, setattr, store, 'schema', invalid)
        invalid = 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 bse: <https://schema.bsfs.io/core/Entity#>

            bsfs:Entity rdfs:subClassOf bsfs:Node .
            bsfs:User rdfs:subClassOf bsfs:Node .

            # inconsistent predicate
            bse:tag rdfs:subClassOf bsfs:Predicate ;
                rdfs:domain bsfs:Entity ;
                rdfs:range bsfs:User;
                bsfs:unique "false"^^xsd:boolean .

            ''')
        self.assertRaises(errors.ConsistencyError, setattr, store, 'schema', invalid)


    def test_transaction(self):
        # store setup
        store = SparqlStore.Open()
        store.schema = self.schema
        p_tag = store.schema.predicate(ns.bse.tag)
        p_filesize = store.schema.predicate(ns.bse.filesize)
        # prepare node types
        ent_type = store.schema.node(ns.bsfs.Entity)
        tag_type = store.schema.node(ns.bsfs.Tag)
        ent_ids = {URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')}
        tag_ids = {URI('http://example.com/me/tag#1234'), URI('http://example.com/me/tag#4321')}
        # target instances
        instances = self.schema_triples | {
            # node instances
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Tag)),
            (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Tag)),
            # links
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
            }

        # add some data
        store.create(ent_type, ent_ids)
        store.create(tag_type, tag_ids)
        store.set(ent_type, ent_ids, p_tag, tag_ids)
        store.set(ent_type, ent_ids, p_filesize, {1234})
        # current transaction is visible
        self.assertSetEqual(set(store._graph), instances | {
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
            })

        # rollback undoes previous changes
        store.rollback()
        self.assertSetEqual(set(store._graph), self.schema_triples)

        # add some data once more
        store.create(ent_type, ent_ids)
        store.create(tag_type, tag_ids)
        store.set(ent_type, ent_ids, p_tag, tag_ids)
        store.set(ent_type, ent_ids, p_filesize, {1234})
        # current transaction is visible
        self.assertSetEqual(set(store._graph), instances | {
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
            })

        # commit saves changes
        store.commit()
        self.assertSetEqual(set(store._graph), instances | {
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
            })

        # add additional data
        store.create(ent_type, {URI('http://example.com/me/entity#hello')})
        store.set(ent_type, {URI('http://example.com/me/entity#hello')}, p_tag, tag_ids)
        store.set(ent_type, ent_ids, p_filesize, {4321})
        self.assertSetEqual(set(store._graph), instances | {
            (rdflib.URIRef('http://example.com/me/entity#hello'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            (rdflib.URIRef('http://example.com/me/entity#hello'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
            (rdflib.URIRef('http://example.com/me/entity#hello'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_filesize.uri), rdflib.Literal(4321, datatype=rdflib.XSD.integer)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_filesize.uri), rdflib.Literal(4321, datatype=rdflib.XSD.integer)),
            })

        # rollback undoes only changes since last commit
        store.rollback()
        self.assertSetEqual(set(store._graph), instances | {
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_filesize.uri), rdflib.Literal(1234, datatype=rdflib.XSD.integer)),
            })

    def test_get(self):
        # store setup
        store = SparqlStore.Open()
        store.schema = self.schema
        ent_type = self.schema.node(ns.bsfs.Entity)
        tag_type = self.schema.node(ns.bsfs.Tag)
        ent_ids = {URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')}
        tag_ids = {URI('http://example.com/me/tag#1234'), URI('http://example.com/me/tag#4321')}
        store.create(ent_type, ent_ids)
        store.create(tag_type, tag_ids)
        store.set(ent_type, ent_ids, self.schema.predicate(ns.bse.tag), tag_ids)
        store.set(ent_type, {URI('http://example.com/me/entity#1234')}, self.schema.predicate(ns.bse.filesize), {1234})
        store.set(ent_type, {URI('http://example.com/me/entity#4321')}, self.schema.predicate(ns.bse.filesize), {4321})
        # node_type must be in the schema
        self.assertRaises(errors.ConsistencyError, set, store.get(self.schema.node(ns.bsfs.Node).child(ns.bsfs.Invalid), ast.filter.IsIn(ent_ids)))
        # query must be a filter expression
        class Foo(): pass
        self.assertRaises(TypeError, set, store.get(ent_type, 1234))
        self.assertRaises(TypeError, set, store.get(ent_type, '1234'))
        self.assertRaises(TypeError, set, store.get(ent_type, Foo()))
        # run some queries
        self.assertSetEqual(set(store.get(tag_type, ast.filter.IsIn(tag_ids))), tag_ids)
        self.assertSetEqual(set(store.get(ent_type, ast.filter.Any(ns.bse.tag, ast.filter.IsIn(tag_ids)))), ent_ids)
        self.assertSetEqual(set(store.get(ent_type, ast.filter.IsIn(tag_ids))), set())
        # invalid queries raise error
        self.assertRaises(errors.ConsistencyError, set, store.get(tag_type, ast.filter.Any(ns.bse.filesize, ast.filter.Equals(1234))))
        self.assertRaises(errors.BackendError, set, store.get(ent_type, ast.filter.Equals('http://example.com/me/entity#1234')))
        # run some more complex query
        q = store.get(tag_type, ast.filter.Any(ast.filter.Predicate(ns.bse.tag, reverse=True),
            ast.filter.Any(ns.bse.filesize,
                ast.filter.LessThan(2000))))
        self.assertSetEqual(set(q), tag_ids)


    def test_fetch(self):
        # store setup
        store = SparqlStore.Open()
        store.schema = self.schema
        # add instances
        ent_type = self.schema.node(ns.bsfs.Entity)
        tag_type = self.schema.node(ns.bsfs.Tag)
        ent_ids = {URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')}
        tag_ids = {URI('http://example.com/me/tag#1234'), URI('http://example.com/me/tag#4321')}
        store.create(ent_type, ent_ids)
        store.create(tag_type, tag_ids)
        store.set(ent_type, ent_ids, self.schema.predicate(ns.bse.tag), tag_ids)
        store.set(ent_type, {URI('http://example.com/me/entity#1234')}, self.schema.predicate(ns.bse.filesize), {1234})
        store.set(ent_type, {URI('http://example.com/me/entity#4321')}, self.schema.predicate(ns.bse.filesize), {4321})
        store.set(ent_type, {URI('http://example.com/me/entity#1234')}, self.schema.predicate(ns.bse.comment), {'hello world'})
        # node_type must be a node from the schema
        self.assertRaises(errors.ConsistencyError, list, store.fetch(self.schema.literal(ns.bsfs.Literal),
            ast.filter.FilterExpression(), ast.fetch.FetchExpression()))
        self.assertRaises(errors.ConsistencyError, list, store.fetch(self.schema.node(ns.bsfs.Node).child(ns.bsfs.Invalid),
            ast.filter.FilterExpression(), ast.fetch.FetchExpression()))
        # requires a filter and a fetch query
        self.assertRaises(TypeError, list, store.fetch(self.schema.node(ns.bsfs.Entity), None, ast.fetch.FetchExpression()))
        self.assertRaises(TypeError, list, store.fetch(self.schema.node(ns.bsfs.Entity), 1234, ast.fetch.FetchExpression()))
        self.assertRaises(TypeError, list, store.fetch(self.schema.node(ns.bsfs.Entity), 'hello', ast.fetch.FetchExpression()))
        self.assertRaises(TypeError, list, store.fetch(self.schema.node(ns.bsfs.Entity), ast.filter.FilterExpression(), None))
        self.assertRaises(TypeError, list, store.fetch(self.schema.node(ns.bsfs.Entity), ast.filter.FilterExpression(), 1234))
        self.assertRaises(TypeError, list, store.fetch(self.schema.node(ns.bsfs.Entity), ast.filter.FilterExpression(), 'hello'))
        # fetch emits triples
        self.assertSetEqual(set(store.fetch(self.schema.node(ns.bsfs.Entity),
            ast.filter.Is('http://example.com/me/entity#1234'),
            ast.fetch.Value(ns.bse.filesize, 'filesize'),
            )), {
            (URI('http://example.com/me/entity#1234'), 'filesize', 1234),
            })
        # fetch respects filter query
        self.assertSetEqual(set(store.fetch(self.schema.node(ns.bsfs.Entity),
            ast.filter.IsIn('http://example.com/me/entity#1234', 'http://example.com/me/entity#4321'),
            ast.fetch.Value(ns.bse.filesize, 'filesize'),
            )), {
            (URI('http://example.com/me/entity#1234'), 'filesize', 1234),
            (URI('http://example.com/me/entity#4321'), 'filesize', 4321),
            })
        # fetch ignores missing data
        self.assertSetEqual(set(store.fetch(self.schema.node(ns.bsfs.Entity),
            ast.filter.IsIn('http://example.com/me/entity#1234', 'http://example.com/me/entity#4321'),
            ast.fetch.Value(ns.bse.comment, 'comment'),
            )), {
            (URI('http://example.com/me/entity#1234'), 'comment', 'hello world'),
            })
        # fetch emits all triples
        self.assertSetEqual(set(store.fetch(self.schema.node(ns.bsfs.Entity),
            ast.filter.Is('http://example.com/me/entity#1234'),
            ast.fetch.All(
                ast.fetch.Value(ns.bse.filesize, 'filesize'),
                ast.fetch.Node(ns.bse.tag, 'tag'),
                )
            )), {
            (URI('http://example.com/me/entity#1234'), 'filesize', 1234),
            (URI('http://example.com/me/entity#1234'), 'tag', URI('http://example.com/me/tag#1234')),
            (URI('http://example.com/me/entity#1234'), 'tag', URI('http://example.com/me/tag#4321')),
            })
        # triples do not repeat
        triples = list(store.fetch(self.schema.node(ns.bsfs.Entity), ast.filter.Is('http://example.com/me/entity#1234'),
            ast.fetch.All(
                ast.fetch.Value(ns.bse.filesize, 'filesize'),
                ast.fetch.Node(ns.bse.tag, 'tag'),
                )
            ))
        self.assertEqual(len(triples), 3)

    def test_exists(self):
        # store setup
        store = SparqlStore.Open()
        store.schema = self.schema
        # prepare node types
        ent_type = store.schema.node(ns.bsfs.Entity)
        tag_type = store.schema.node(ns.bsfs.Tag)
        # create node instances
        ent_ids = {
            URI('http://example.com/me/entity#1234'),
            URI('http://example.com/me/entity#4321'),
            }
        tag_ids = {
            URI('http://example.com/me/tag#1234'),
            URI('http://example.com/me/tag#4321'),
            }
        store.create(ent_type, ent_ids)
        store.create(tag_type, tag_ids)

        # exists returns all existing nodes of the correct type
        self.assertSetEqual(ent_ids, set(store.exists(ent_type, ent_ids)))
        self.assertSetEqual(tag_ids, set(store.exists(tag_type, tag_ids)))
        # exists returns only nodes that match the type
        self.assertSetEqual(set(), set(store.exists(ent_type, tag_ids)))
        self.assertSetEqual({URI('http://example.com/me/entity#1234')}, set(store.exists(ent_type, {
            URI('http://example.com/me/tag#1234'),
            URI('http://example.com/me/entity#1234'),
            })))
        # exists returns only nodes that exist
        self.assertSetEqual(set(), set(store.exists(ent_type, {
            URI('http://example.com/me/entity#foo'),
            URI('http://example.com/me/entity#bar'),
            })))
        self.assertSetEqual({URI('http://example.com/me/entity#1234')}, set(store.exists(ent_type, {
            URI('http://example.com/me/entity#foo'),
            URI('http://example.com/me/entity#1234'),
            })))


    def test_create(self):
        # setup
        store = SparqlStore.Open()
        store.schema = self.schema

        # node type must be valid
        self.assertRaises(errors.ConsistencyError, store.create, self.schema.node(ns.bsfs.Entity).child(ns.bsfs.invalid), {
            URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')})

        # guid must be valid
        self.assertRaises(ValueError, store.create, self.schema.node(ns.bsfs.Entity), {'http://example.com/me/foo and bar'})

        # can create some nodes
        ent_type = store.schema.node(ns.bsfs.Entity)
        store.create(ent_type, {URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')})
        self.assertSetEqual(set(store._graph), self.schema_triples | {
            # instances
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            })

        # existing nodes are skipped
        store.create(ent_type, {URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#5678')})
        self.assertSetEqual(set(store._graph), self.schema_triples | {
            # previous triples
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            # new triples
            (rdflib.URIRef('http://example.com/me/entity#5678'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            })

        # can create nodes of a different type
        tag_type = store.schema.node(ns.bsfs.Tag)
        store.create(tag_type, {URI('http://example.com/me/tag#1234'), URI('http://example.com/me/tag#4321')})
        self.assertSetEqual(set(store._graph), self.schema_triples | {
            # previous triples
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            (rdflib.URIRef('http://example.com/me/entity#5678'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            # new triples
            (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Tag)),
            (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Tag)),
            })

        # creation does not change types of existing nodes
        tag_type = store.schema.node(ns.bsfs.Tag)
        store.create(tag_type, {URI('http://example.com/me/entity#1234'), URI('http://example.com/me/entity#4321')})
        self.assertSetEqual(set(store._graph), self.schema_triples | {
            # previous triples
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            (rdflib.URIRef('http://example.com/me/entity#5678'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Entity)),
            # new triples
            (rdflib.URIRef('http://example.com/me/tag#1234'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Tag)),
            (rdflib.URIRef('http://example.com/me/tag#4321'), rdflib.RDF.type, rdflib.URIRef(ns.bsfs.Tag)),
            })


    def test_set(self):
        # store setup
        store = SparqlStore.Open()
        store.schema = self.schema
        # prepare node types
        ent_type = store.schema.node(ns.bsfs.Entity)
        user_type = store.schema.node(ns.bsfs.User)
        tag_type = store.schema.node(ns.bsfs.Tag)
        # prepare predicates
        p_filesize = store.schema.predicate(ns.bse.filesize)
        p_comment = store.schema.predicate(ns.bse.comment)
        p_author = store.schema.predicate(ns.bse.author)
        p_tag = store.schema.predicate(ns.bse.tag)
        p_invalid = store.schema.predicate(ns.bsfs.Predicate).child(ns.bsfs.foo, range=store.schema.node(ns.bsfs.Tag))
        # create node instances
        ent_ids = {
            URI('http://example.com/me/entity#1234'),
            URI('http://example.com/me/entity#4321'),
            }
        tag_ids = {
            URI('http://example.com/me/tag#1234'),
            URI('http://example.com/me/tag#4321'),
            URI('http://example.com/me/tag#foo'),
            URI('http://example.com/me/tag#bar'),
            URI('http://example.com/me/tag#foobar'),
            URI('http://example.com/me/tag#xyz'),
            }
        user_ids = {
            URI('http://example.com/me/user#1234'),
            URI('http://example.com/me/user#4321'),
            }
        store.create(ent_type, ent_ids)
        store.create(tag_type, tag_ids)
        store.create(user_type, user_ids)

        # invalid node_type is not permitted
        self.assertRaises(errors.ConsistencyError, store.set, self.schema.node(ns.bsfs.Node).child(ns.bse.foo),
            ent_ids, p_comment, {'hello world'})

        # invalid predicate is not permitted
        self.assertRaises(errors.ConsistencyError, store.set, ent_type, ent_ids, p_invalid, {'http://example.com/me/tag#1234'})

        # invalid guid is not permitted
        self.assertRaises(ValueError, store.set, ent_type, {'http://example.com/me/foo and bar'}, p_filesize, {1234})

        # predicate must match node_type
        self.assertRaises(errors.ConsistencyError, store.set, tag_type, tag_ids, p_filesize, {1234})

        # empty value does not change the graph
        plen = len(store._graph)
        store.set(ent_type, ent_ids, p_filesize, [])
        store.set(ent_type, ent_ids, p_comment, [])
        store.set(ent_type, ent_ids, p_author, [])
        store.set(ent_type, ent_ids, p_tag, [])
        self.assertEqual(plen, len(store._graph))

        # cannot set multiple values on unique predicates
        self.assertRaises(ValueError, store.set, ent_type, ent_ids, p_filesize, {1234, 4321})
        self.assertRaises(ValueError, store.set, ent_type, ent_ids, p_author, {URI('http://example.com/me/user#1234'), URI('http://example.com/me/user#4321')})

        # value nodes must exist
        self.assertRaises(errors.InstanceError, store.set, ent_type, ent_ids, p_author, {URI('http://example.com/me/user#invalid')})
        self.assertRaises(errors.InstanceError, store.set, ent_type, ent_ids, p_tag, {URI('http://example.com/me/tag#invalid')})

        # value node types must be consistent with the predicate
        self.assertRaises(errors.InstanceError, store.set, ent_type, ent_ids, p_author, {URI('http://example.com/me/entity#1234')})
        self.assertRaises(errors.InstanceError, store.set, ent_type, ent_ids, p_tag, {URI('http://example.com/me/entity#1234')})

        # all value nodes must exist and be consistent
        self.assertRaises(errors.InstanceError, store.set, ent_type, ent_ids, p_tag, {
            URI('http://example.com/me/tag#1234'), URI('http://example.com/me/tag#invalid'), URI('http://example.com/me/entity#1234')})


        # set unique literal
        store.set(ent_type, ent_ids, p_filesize, {1234})
        self.assertIn(
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_filesize.uri), rdflib.Literal('1234', datatype=rdflib.XSD.integer)),
            set(store._graph))
        self.assertIn(
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_filesize.uri), rdflib.Literal('1234', datatype=rdflib.XSD.integer)),
            set(store._graph))
        # re-assigning the same node changes nothing
        store.set(ent_type, ent_ids, p_filesize, {1234})
        self.assertIn(
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_filesize.uri), rdflib.Literal('1234', datatype=rdflib.XSD.integer)),
            set(store._graph))
        self.assertIn(
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_filesize.uri), rdflib.Literal('1234', datatype=rdflib.XSD.integer)),
            set(store._graph))
        # cannot set multiple unique literals
        self.assertRaises(ValueError, store.set, ent_type, ent_ids, p_filesize, {1234, 4321}) # same test as above
        # unique literals are overwritten by set
        store.set(ent_type, ent_ids, p_filesize, {4321})
        self.assertIn(
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_filesize.uri), rdflib.Literal('4321', datatype=rdflib.XSD.integer)),
            set(store._graph))
        self.assertNotIn(
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_filesize.uri), rdflib.Literal('1234', datatype=rdflib.XSD.integer)),
            set(store._graph))
        self.assertIn(
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_filesize.uri), rdflib.Literal('4321', datatype=rdflib.XSD.integer)),
            set(store._graph))
        self.assertNotIn(
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_filesize.uri), rdflib.Literal('1234', datatype=rdflib.XSD.integer)),
            set(store._graph))

        # set non-unique literal
        store.set(ent_type, ent_ids, p_comment, {'foobar'})
        self.assertTrue(set(store._graph).issuperset({
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_comment.uri), rdflib.Literal('foobar', datatype=rdflib.XSD.string)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_comment.uri), rdflib.Literal('foobar', datatype=rdflib.XSD.string)),
            }))
        # re-assigning the same node changes nothing
        store.set(ent_type, ent_ids, p_comment, {'foobar'})
        self.assertTrue(set(store._graph).issuperset({
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_comment.uri), rdflib.Literal('foobar', datatype=rdflib.XSD.string)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_comment.uri), rdflib.Literal('foobar', datatype=rdflib.XSD.string)),
            }))
        # can set multiple non-unique literals at once
        store.set(ent_type, ent_ids, p_comment, {'foo', 'bar'})
        self.assertTrue(set(store._graph).issuperset({
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_comment.uri), rdflib.Literal('foo', datatype=rdflib.XSD.string)),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_comment.uri), rdflib.Literal('bar', datatype=rdflib.XSD.string)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_comment.uri), rdflib.Literal('foo', datatype=rdflib.XSD.string)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_comment.uri), rdflib.Literal('bar', datatype=rdflib.XSD.string)),
            }))
        # non-unique literals are appended by set
        store.set(ent_type, ent_ids, p_comment, {'hello world'})
        self.assertTrue(set(store._graph).issuperset({
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_comment.uri), rdflib.Literal('foo', datatype=rdflib.XSD.string)),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_comment.uri), rdflib.Literal('bar', datatype=rdflib.XSD.string)),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_comment.uri), rdflib.Literal('hello world', datatype=rdflib.XSD.string)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_comment.uri), rdflib.Literal('foo', datatype=rdflib.XSD.string)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_comment.uri), rdflib.Literal('bar', datatype=rdflib.XSD.string)),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_comment.uri), rdflib.Literal('hello world', datatype=rdflib.XSD.string)),
            }))

        # set unique node
        store.set(ent_type, ent_ids, p_author, {URI('http://example.com/me/user#1234')})
        self.assertIn(
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_author.uri), rdflib.URIRef('http://example.com/me/user#1234')),
            set(store._graph))
        self.assertIn(
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_author.uri), rdflib.URIRef('http://example.com/me/user#1234')),
            set(store._graph))
        # re-assigning the same node changes nothing
        store.set(ent_type, ent_ids, p_author, {URI('http://example.com/me/user#1234')})
        self.assertIn(
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_author.uri), rdflib.URIRef('http://example.com/me/user#1234')),
            set(store._graph))
        self.assertIn(
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_author.uri), rdflib.URIRef('http://example.com/me/user#1234')),
            set(store._graph))
        # cannot set multiple unique nodes
        self.assertRaises(ValueError, store.set, ent_type, ent_ids, p_author, {URI('http://example.com/me/user#1234'), URI('http://example.com/me/user#4321')})
        # unique nodes are overwritten by set
        store.set(ent_type, ent_ids, p_author, {URI('http://example.com/me/user#4321')})
        self.assertIn(
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_author.uri), rdflib.URIRef('http://example.com/me/user#4321')),
            set(store._graph))
        self.assertNotIn(
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_author.uri), rdflib.URIRef('http://example.com/me/user#1234')),
            set(store._graph))
        self.assertIn(
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_author.uri), rdflib.URIRef('http://example.com/me/user#4321')),
            set(store._graph))
        self.assertNotIn(
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_author.uri), rdflib.URIRef('http://example.com/me/user#1234')),
            set(store._graph))

        # set non-unique node
        store.set(ent_type, ent_ids, p_tag, {'http://example.com/me/tag#foobar'})
        self.assertTrue(set(store._graph).issuperset({
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#foobar')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#foobar')),
            }))
        # re-assigning the same node changes nothing
        store.set(ent_type, ent_ids, p_tag, {'http://example.com/me/tag#foobar'})
        self.assertTrue(set(store._graph).issuperset({
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#foobar')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#foobar')),
            }))
        # can set multiple non-unique literals at once
        store.set(ent_type, ent_ids, p_tag, {'http://example.com/me/tag#1234', 'http://example.com/me/tag#4321'})
        self.assertTrue(set(store._graph).issuperset({
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
            }))
        # non-unique nodes are appended by set
        store.set(ent_type, ent_ids, p_tag, {'http://example.com/me/tag#foo', 'http://example.com/me/tag#bar'})
        self.assertTrue(set(store._graph).issuperset({
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#foo')),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#bar')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#1234')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#4321')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#foo')),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_tag.uri), rdflib.URIRef('http://example.com/me/tag#bar')),
            }))

        # nothing happens when no guids are given
        plen = len(store._graph)
        store.set(ent_type, set(), p_comment, {'xyz'})
        store.set(ent_type, set(), p_tag, {URI('http://example.com/me/tag#xyz')})
        self.assertEqual(plen, len(store._graph))

        # guids must be instances of node_type
        self.assertRaises(errors.InstanceError, store.set, ent_type, tag_ids, p_comment, {'xyz'})
        # inexistent guids
        self.assertRaises(errors.InstanceError, store.set, ent_type, {URI('http://example.com/me/entity#foobar')}, p_comment, {'xyz'})

        # BinaryBlob values are base64 encoded
        p_asset = store.schema.predicate(ns.bse.asset)
        store.set(ent_type, ent_ids, p_asset, {bytes(range(128)), bytes(range(128, 256))})
        blob1 = rdflib.Literal('AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn8=',
            datatype=rdflib.URIRef(ns.bsl.BinaryBlob))
        blob2 = rdflib.Literal('gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4+Tl5ufo6err7O3u7/Dx8vP09fb3+Pn6+/z9/v8=',
            datatype=rdflib.URIRef(ns.bsl.BinaryBlob))
        self.assertTrue(set(store._graph).issuperset({
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_asset.uri), blob1),
            (rdflib.URIRef('http://example.com/me/entity#1234'), rdflib.URIRef(p_asset.uri), blob2),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_asset.uri), blob1),
            (rdflib.URIRef('http://example.com/me/entity#4321'), rdflib.URIRef(p_asset.uri), blob2),
            }))
        # lit.value returns the original bytes value
        self.assertSetEqual({lit.value for lit in store._graph.objects(None, rdflib.URIRef(p_asset.uri))},
            {bytes(range(128)), bytes(range(128, 256))})


## main ##

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

## EOF ##