# standard imports
import os
import unittest

# bsie imports
from bsie.extractor import base
from bsie.matcher import nodes
from bsie.utils import bsfs, ns

# objects to test
from bsie.extractor.generic.path import Path


## code ##

class TestPath(unittest.TestCase):
    def test_eq(self):
        # distinct instances, same data
        self.assertEqual(Path(), Path())
        # different classes
        class Foo(): pass
        self.assertNotEqual(Path(), Foo())
        self.assertNotEqual(Path(), 123)
        self.assertNotEqual(Path(), None)

    def test_schema(self):
        self.assertEqual(Path().schema,
            bsfs.schema.from_string(base.SCHEMA_PREAMBLE + '''
                bse:filename rdfs:subClassOf bsfs:Predicate ;
                    rdfs:domain bsn:Entity ;
                    rdfs:range xsd:string ;
                    bsfs:unique "true"^^xsd:boolean .

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

                '''))

    def test_extract(self):
        ext = Path()
        node = nodes.Entity(ucid='abc123')
        content = '/tmp/foo/bar'
        p_filename = ext.schema.predicate(ns.bse.filename)
        p_dirname = ext.schema.predicate(ns.bse.dirname)
        entity = ext.schema.node(ns.bsfs.Node).child(ns.bsn.Entity)
        string = ext.schema.literal(ns.bsfs.Literal).child(ns.xsd.string)

        # baseline
        self.assertSetEqual(set(ext.extract(node, content, (p_filename, p_dirname))),
            {(node, p_filename, 'bar'), (node, p_dirname, '/tmp/foo')})
        # predicates parameter is respected
        p_foo = ext.schema.predicate(ns.bsfs.Predicate).child(ns.bse.foo, domain=entity, range=string) # unsupported predicate
        self.assertSetEqual(set(ext.extract(node, content, (p_filename, p_foo))),
            {(node, p_filename, 'bar')})
        self.assertSetEqual(set(ext.extract(node, content, (p_foo, ))), set())
        # predicates are validated
        p_bar = p_foo.child(ns.bse.filename) # same URI but different hierarchy
        self.assertSetEqual(set(ext.extract(node, content, (p_filename, p_bar))),
            {(node, p_filename, 'bar')})
        self.assertSetEqual(set(ext.extract(node, content, (p_bar, ))), set())
        # path variations
        self.assertSetEqual(set(ext.extract(node, 'bar', (p_filename, p_dirname))),
            {(node, p_filename, 'bar'), (node, p_dirname, os.getcwd())})
        self.assertSetEqual(set(ext.extract(node, '/bar', (p_filename, p_dirname))),
            {(node, p_filename, 'bar'), (node, p_dirname, '/')})
        self.assertSetEqual(set(ext.extract(node, '', (p_filename, p_dirname))),
            {(node, p_filename, ''), (node, p_dirname, os.path.dirname(os.getcwd()))})
        # errors are suppressed
        self.assertSetEqual(set(ext.extract(node, None, (p_filename, p_dirname))), set())


## main ##

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

## EOF ##