"""

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

# bsie imports
from bsie.utils import errors

# objects to test
from bsie.extractor import ExtractorBuilder


## code ##

class TestExtractorBuilder(unittest.TestCase):
    def test_iter(self):
        # no specifications
        self.assertListEqual(list(ExtractorBuilder([])), [])
        # some specifications
        builder = ExtractorBuilder([
            {'bsie.extractor.generic.path.Path': {}},
            {'bsie.extractor.generic.stat.Stat': {}},
            {'bsie.extractor.generic.path.Path': {}},
            ])
        self.assertListEqual(list(builder), [0, 1, 2])

    def test_build(self):
        # simple and repeated extractors
        builder = ExtractorBuilder([
            {'bsie.extractor.generic.path.Path': {}},
            {'bsie.extractor.generic.stat.Stat': {}},
            {'bsie.extractor.generic.path.Path': {}},
            ])
        ext = [builder.build(0), builder.build(1), builder.build(2)]
        import bsie.extractor.generic.path
        import bsie.extractor.generic.stat
        self.assertListEqual(ext, [
            bsie.extractor.generic.path.Path(),
            bsie.extractor.generic.stat.Stat(),
            bsie.extractor.generic.path.Path(),
            ])
        # out-of-bounds raises KeyError
        self.assertRaises(IndexError, builder.build, 3)

        # building with args
        builder = ExtractorBuilder([
            {'bsie.extractor.generic.constant.Constant': {
                'schema': '''
                    bse:author rdfs:subClassOf bsfs:Predicate ;
                        rdfs:domain bsfs:Entity ;
                        rdfs:range xsd:string ;
                        bsfs:unique "true"^^xsd:boolean .
                    bse:rating rdfs:subClassOf bsfs:Predicate ;
                        rdfs:domain bsfs:Entity ;
                        rdfs:range xsd:integer ;
                        bsfs:unique "true"^^xsd:boolean .
                    ''',
                'tuples': [
                    ('http://bsfs.ai/schema/Entity#author', 'Me, myself, and I'),
                    ('http://bsfs.ai/schema/Entity#rating', 123),
                    ],
            }}])
        obj = builder.build(0)
        import bsie.extractor.generic.constant
        self.assertEqual(obj, bsie.extractor.generic.constant.Constant('''
                    bse:author rdfs:subClassOf bsfs:Predicate ;
                        rdfs:domain bsfs:Entity ;
                        rdfs:range xsd:string ;
                        bsfs:unique "true"^^xsd:boolean .
                    bse:rating rdfs:subClassOf bsfs:Predicate ;
                        rdfs:domain bsfs:Entity ;
                        rdfs:range xsd:integer ;
                        bsfs:unique "true"^^xsd:boolean .
                    ''', [
            ('http://bsfs.ai/schema/Entity#author', 'Me, myself, and I'),
            ('http://bsfs.ai/schema/Entity#rating', 123),
            ]))

        # building with invalid args
        self.assertRaises(errors.BuilderError, ExtractorBuilder(
            [{'bsie.extractor.generic.path.Path': {'foo': 123}}]).build, 0)
        # non-dict build specification
        self.assertRaises(TypeError, ExtractorBuilder(
            [('bsie.extractor.generic.path.Path', {})]).build, 0)
        # multiple keys per build specification
        self.assertRaises(TypeError, ExtractorBuilder(
            [{'bsie.extractor.generic.path.Path': {},
              'bsie.extractor.generic.stat.Stat': {}}]).build, 0)
        # non-dict value for kwargs
        self.assertRaises(TypeError, ExtractorBuilder(
            [{'bsie.extractor.generic.path.Path': 123}]).build, 0)


## main ##

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

## EOF ##