"""

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

# objects to test
from tagit.utils.builder import BuilderBase, InvalidFactoryName


## code ##

class Foo(object):
    """Description Foo"""
    def __init__(self, *args, **kwargs):
        self.args = args
        self.kwargs = kwargs
    def __eq__(self, other):
        return self.args == other.args and self.kwargs == other.kwargs

def bar(*args, **kwargs):
    """Description bar"""
    return args, kwargs

class BuilderStub(BuilderBase):
    _factories = {
        'foo': Foo,
        'bar': bar,
        }

class TestBuilderBase(unittest.TestCase):
    def test_magics(self):
        builder = BuilderStub()
        # contains
        self.assertIn('foo', builder)
        self.assertIn('bar', builder)
        self.assertNotIn('foobar', builder)
        # iter
        self.assertEqual(set(builder), {'foo', 'bar'})
        self.assertCountEqual(list(builder), ['foo', 'bar'])
        self.assertEqual(set(BuilderBase()), set())
        # len
        self.assertEqual(len(builder), 2)
        self.assertEqual(len(BuilderBase()), 0)
        # eq
        self.assertEqual(BuilderStub(), BuilderStub())
        self.assertNotEqual(BuilderBase(), BuilderStub())
        # hash
        self.assertEqual(hash(BuilderStub()), hash(BuilderStub()))
        self.assertEqual(hash(BuilderBase()), hash(BuilderBase()))

    def test_get(self):
        builder = BuilderStub()
        # get
        self.assertEqual(builder.get('foo'), Foo)
        self.assertEqual(builder.get('bar'), bar)
        self.assertRaises(InvalidFactoryName, builder.get, 'foobar')
        # getitem
        self.assertEqual(builder['foo'], Foo)
        self.assertEqual(builder['bar'], bar)
        self.assertRaises(InvalidFactoryName, builder.__getitem__, 'foobar')

    def test_keys(self):
        self.assertEqual(set(BuilderStub().keys()), {'foo', 'bar'})
        self.assertEqual(set(BuilderBase().keys()), set())

    def test_describe(self):
        builder = BuilderStub()
        self.assertEqual(builder.describe('foo'), 'Description Foo')
        self.assertEqual(builder.describe('bar'), 'Description bar')
        self.assertRaises(InvalidFactoryName, builder.describe, 'foobar')

    def test_prepare(self):
        builder = BuilderStub()
        # empty args
        # foo
        part = builder.prepare('foo')
        self.assertIsInstance(part, partial)
        self.assertEqual((part.func, part.args, part.keywords), (Foo, (), {}))
        # bar
        part = builder.prepare('bar')
        self.assertIsInstance(part, partial)
        self.assertEqual((part.func, part.args, part.keywords), (bar, (), {}))
        # foobar
        self.assertRaises(InvalidFactoryName, builder.prepare, 'foobar')

        # args
        # foo
        part = builder.prepare('foo', 1, 2, 3)
        self.assertIsInstance(part, partial)
        self.assertEqual((part.func, part.args, part.keywords), (Foo, (1, 2, 3), {}))
        # bar
        part = builder.prepare('bar', 1, 2, 3)
        self.assertIsInstance(part, partial)
        self.assertEqual((part.func, part.args, part.keywords), (bar, (1, 2, 3), {}))
        # foobar
        self.assertRaises(InvalidFactoryName, builder.prepare, 'foobar', 1, 2, 3)

        # kwargs
        # foo
        part = builder.prepare('foo', arg1='hello', arg2='world')
        self.assertIsInstance(part, partial)
        self.assertEqual((part.func, part.args, part.keywords),
            (Foo, (), {'arg1': 'hello', 'arg2': 'world'}))
        # bar
        part = builder.prepare('bar', arg1='hello', arg2='world')
        self.assertIsInstance(part, partial)
        self.assertEqual((part.func, part.args, part.keywords),
            (bar, (), {'arg1': 'hello', 'arg2': 'world'}))
        # foobar
        self.assertRaises(InvalidFactoryName, builder.prepare, 'foobar',
            arg1='hello', arg2='world')

        # mixed
        # foo
        part = builder.prepare('foo', 1, 2, 3, arg1='hello', arg2='world')
        self.assertIsInstance(part, partial)
        self.assertEqual((part.func, part.args, part.keywords),
            (Foo, (1, 2, 3), {'arg1': 'hello', 'arg2': 'world'}))
        # bar
        part = builder.prepare('bar', 1, 2, 3, arg1='hello', arg2='world')
        self.assertIsInstance(part, partial)
        self.assertEqual((part.func, part.args, part.keywords),
            (bar, (1, 2, 3), {'arg1': 'hello', 'arg2': 'world'}))
        # foobar
        self.assertRaises(InvalidFactoryName, builder.prepare, 'foobar',
            1, 2, 3, arg1='hello', arg2='world')

    def test_build(self):
        builder = BuilderStub()
        # empty args
        self.assertEqual(builder.build('foo'), Foo())
        self.assertEqual(builder.build('bar'), bar())
        self.assertRaises(InvalidFactoryName, builder.build, 'foobar')
        # args
        self.assertEqual(builder.build('foo', 1, 2, 3), Foo(1, 2, 3))
        self.assertEqual(builder.build('bar', 1, 2, 3), bar(1, 2, 3))
        self.assertRaises(InvalidFactoryName, builder.build, 'foobar', 1, 2, 3)
        # kwargs
        self.assertEqual(builder.build('foo', arg1='hello', arg2='world'),
            Foo(arg1='hello', arg2='world'))
        self.assertEqual(builder.build('bar', arg1='hello', arg2='world'),
            bar(arg1='hello', arg2='world'))
        self.assertRaises(InvalidFactoryName, builder.build, 'foobar',
            arg1='hello', arg2='world')
        # mixed
        self.assertEqual(
            builder.build('foo', 1, 2, 3, arg1='hello', arg2='world'),
            Foo(1, 2, 3, arg1='hello', arg2='world'))
        self.assertEqual(
            builder.build('bar', 1, 2, 3, arg1='hello', arg2='world'),
            bar(1, 2, 3, arg1='hello', arg2='world'))
        self.assertRaises(InvalidFactoryName, builder.build, 'foobar',
            1, 2, 3, arg1='hello', arg2='world')

    def test_key_from_instance(self):
        builder = BuilderStub()
        self.assertEqual(builder.key_from_instance(Foo()), 'foo')
        self.assertEqual(builder.key_from_instance(bar), 'bar')
        self.assertRaises(KeyError, builder.key_from_instance, 'foobar')
        self.assertRaises(KeyError, builder.key_from_instance, BuilderStub())


## main ##

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

## EOF ##