# imports
import unittest

# bsie imports
from bsfs import schema as bsc
from bsfs.namespace import ns
from bsfs.utils import URI

# objects to test
from bsfs.graph.result import to_list_view, to_dict_view


## code ##

ns.bse = ns.bsfs.Entity()

class TestListView(unittest.TestCase):
    def setUp(self):
        self.triples_111 = [('ent#1234', ns.bse.iso, 123)]
        self.triples_11U = [('ent#1234', ns.bse.tag, 'tag#1234'),
                            ('ent#1234', ns.bse.tag, 'tag#5678')]
        self.triples_1M1 = [('ent#1234', ns.bse.iso, 123),
                            ('ent#1234', ns.bse.t_created, '2010-01-02')]
        self.triples_1MU = [('ent#1234', ns.bse.iso, 123),
                            ('ent#1234', ns.bse.tag, 'tag#1234'),
                            ('ent#1234', ns.bse.tag, 'tag#5678')]
        self.triples_N11 = [('ent#1234', ns.bse.iso, 123),
                            ('ent#4321', ns.bse.iso, 321)]
        self.triples_N1U = [('ent#1234', ns.bse.tag, 'tag#1234'),
                            ('ent#1234', ns.bse.tag, 'tag#5678'),
                            ('ent#4321', ns.bse.tag, 'tag#4321')]
        self.triples_NM1 = [('ent#1234', ns.bse.iso, 123),
                            ('ent#1234', ns.bse.t_created, '2010-01-02'),
                            ('ent#4321', ns.bse.iso, 321),
                            ('ent#4321', ns.bse.t_created, '2022-02-22')]
        self.triples_NMU = [('ent#1234', ns.bse.iso, 123),
                            ('ent#1234', ns.bse.tag, 'tag#1234'),
                            ('ent#1234', ns.bse.tag, 'tag#5678'),
                            ('ent#4321', ns.bse.iso, 321),
                            ('ent#4321', ns.bse.t_created, '2022-02-22')]

    def test_copy(self):
        # iterator yields tuples
        self.assertIsInstance(list(to_list_view([('subject', 'predicate', 'object')], node=True, path=True, value=True))[0], tuple)
        # components are not changed
        class Foo(): pass
        foo = Foo()
        self.assertListEqual(list(to_list_view([('subject', 'predicate', 'object')], node=True, path=True, value=True)),
            [('subject', 'predicate', 'object')])
        self.assertListEqual(list(to_list_view([(foo, 'predicate', 'object')], node=True, path=True, value=True)),
            [(foo, 'predicate', 'object')])
        self.assertListEqual(list(to_list_view([('subject', foo, 'object')], node=True, path=True, value=True)),
            [('subject', foo, 'object')])
        self.assertListEqual(list(to_list_view([('subject', 'predicate', foo)], node=True, path=True, value=True)),
            [('subject', 'predicate', foo)])

    def test_agg_none(self):
        self.assertListEqual(list(to_list_view(self.triples_111, node=True, path=True, value=True)), self.triples_111)
        self.assertListEqual(list(to_list_view(self.triples_11U, node=True, path=True, value=True)), self.triples_11U)
        self.assertListEqual(list(to_list_view(self.triples_1M1, node=True, path=True, value=True)), self.triples_1M1)
        self.assertListEqual(list(to_list_view(self.triples_1MU, node=True, path=True, value=True)), self.triples_1MU)
        self.assertListEqual(list(to_list_view(self.triples_N11, node=True, path=True, value=True)), self.triples_N11)
        self.assertListEqual(list(to_list_view(self.triples_N1U, node=True, path=True, value=True)), self.triples_N1U)
        self.assertListEqual(list(to_list_view(self.triples_NM1, node=True, path=True, value=True)), self.triples_NM1)
        self.assertListEqual(list(to_list_view(self.triples_NMU, node=True, path=True, value=True)), self.triples_NMU)

    def test_agg_node(self):
        self.assertListEqual(list(to_list_view(self.triples_111, node=False, path=True, value=True)),
            [(ns.bse.iso, 123)])
        self.assertListEqual(list(to_list_view(self.triples_11U, node=False, path=True, value=True)),
            [(ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678')])
        self.assertListEqual(list(to_list_view(self.triples_1M1, node=False, path=True, value=True)),
            [(ns.bse.iso, 123), (ns.bse.t_created, '2010-01-02')])
        self.assertListEqual(list(to_list_view(self.triples_1MU, node=False, path=True, value=True)),
            [(ns.bse.iso, 123), (ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678')])
        self.assertListEqual(list(to_list_view(self.triples_N11, node=False, path=True, value=True)),
            [(ns.bse.iso, 123), (ns.bse.iso, 321)])
        self.assertListEqual(list(to_list_view(self.triples_N1U, node=False, path=True, value=True)),
            [(ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678'), (ns.bse.tag, 'tag#4321')])
        self.assertListEqual(list(to_list_view(self.triples_NM1, node=False, path=True, value=True)),
            [(ns.bse.iso, 123), (ns.bse.t_created, '2010-01-02'), (ns.bse.iso, 321), (ns.bse.t_created, '2022-02-22')])
        self.assertListEqual(list(to_list_view(self.triples_NMU, node=False, path=True, value=True)),
            [(ns.bse.iso, 123), (ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678'), (ns.bse.iso, 321), (ns.bse.t_created, '2022-02-22')])

    def test_agg_path(self):
        self.assertListEqual(list(to_list_view(self.triples_111, node=True, path=False, value=True)),
            [('ent#1234', 123)])
        self.assertListEqual(list(to_list_view(self.triples_11U, node=True, path=False, value=True)),
            [('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678')])
        self.assertListEqual(list(to_list_view(self.triples_1M1, node=True, path=False, value=True)),
            [('ent#1234', 123), ('ent#1234', '2010-01-02')])
        self.assertListEqual(list(to_list_view(self.triples_1MU, node=True, path=False, value=True)),
            [('ent#1234', 123), ('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678')])
        self.assertListEqual(list(to_list_view(self.triples_N11, node=True, path=False, value=True)),
            [('ent#1234', 123), ('ent#4321', 321)])
        self.assertListEqual(list(to_list_view(self.triples_N1U, node=True, path=False, value=True)),
            [('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678'), ('ent#4321', 'tag#4321')])
        self.assertListEqual(list(to_list_view(self.triples_NM1, node=True, path=False, value=True)),
            [('ent#1234', 123), ('ent#1234', '2010-01-02'), ('ent#4321', 321), ('ent#4321', '2022-02-22')])
        self.assertListEqual(list(to_list_view(self.triples_NMU, node=True, path=False, value=True)),
            [('ent#1234', 123), ('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678'), ('ent#4321', 321), ('ent#4321', '2022-02-22')])

    def test_agg_node_path(self):
        self.assertListEqual(list(to_list_view(self.triples_111, node=False, path=False, value=True)),
            [123])
        self.assertListEqual(list(to_list_view(self.triples_11U, node=False, path=False, value=True)),
            ['tag#1234', 'tag#5678'])
        self.assertListEqual(list(to_list_view(self.triples_1M1, node=False, path=False, value=True)),
            [123, '2010-01-02'])
        self.assertListEqual(list(to_list_view(self.triples_1MU, node=False, path=False, value=True)),
            [123, 'tag#1234', 'tag#5678'])
        self.assertListEqual(list(to_list_view(self.triples_N11, node=False, path=False, value=True)),
            [123, 321])
        self.assertListEqual(list(to_list_view(self.triples_N1U, node=False, path=False, value=True)),
            ['tag#1234', 'tag#5678', 'tag#4321'])
        self.assertListEqual(list(to_list_view(self.triples_NM1, node=False, path=False, value=True)),
            [123, '2010-01-02', 321, '2022-02-22'])
        self.assertListEqual(list(to_list_view(self.triples_NMU, node=False, path=False, value=True)),
            [123, 'tag#1234', 'tag#5678', 321, '2022-02-22'])

    def test_agg_value(self):
        # value flag has no effect
        self.assertListEqual(list(to_list_view(self.triples_111, node=True, path=True, value=True)), self.triples_111)
        self.assertListEqual(list(to_list_view(self.triples_11U, node=True, path=True, value=True)), self.triples_11U)
        self.assertListEqual(list(to_list_view(self.triples_1M1, node=True, path=True, value=True)), self.triples_1M1)
        self.assertListEqual(list(to_list_view(self.triples_1MU, node=True, path=True, value=True)), self.triples_1MU)
        self.assertListEqual(list(to_list_view(self.triples_N11, node=True, path=True, value=True)), self.triples_N11)
        self.assertListEqual(list(to_list_view(self.triples_N1U, node=True, path=True, value=True)), self.triples_N1U)
        self.assertListEqual(list(to_list_view(self.triples_NM1, node=True, path=True, value=True)), self.triples_NM1)
        self.assertListEqual(list(to_list_view(self.triples_NMU, node=True, path=True, value=True)), self.triples_NMU)

    def test_agg_node_value(self):
        # value flag has no effect -> same test as test_agg_node
        self.assertListEqual(list(to_list_view(self.triples_111, node=False, path=True, value=False)),
            [(ns.bse.iso, 123)])
        self.assertListEqual(list(to_list_view(self.triples_11U, node=False, path=True, value=False)),
            [(ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678')])
        self.assertListEqual(list(to_list_view(self.triples_1M1, node=False, path=True, value=False)),
            [(ns.bse.iso, 123), (ns.bse.t_created, '2010-01-02')])
        self.assertListEqual(list(to_list_view(self.triples_1MU, node=False, path=True, value=False)),
            [(ns.bse.iso, 123), (ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678')])
        self.assertListEqual(list(to_list_view(self.triples_N11, node=False, path=True, value=False)),
            [(ns.bse.iso, 123), (ns.bse.iso, 321)])
        self.assertListEqual(list(to_list_view(self.triples_N1U, node=False, path=True, value=False)),
            [(ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678'), (ns.bse.tag, 'tag#4321')])
        self.assertListEqual(list(to_list_view(self.triples_NM1, node=False, path=True, value=False)),
            [(ns.bse.iso, 123), (ns.bse.t_created, '2010-01-02'), (ns.bse.iso, 321), (ns.bse.t_created, '2022-02-22')])
        self.assertListEqual(list(to_list_view(self.triples_NMU, node=False, path=True, value=False)),
            [(ns.bse.iso, 123), (ns.bse.tag, 'tag#1234'), (ns.bse.tag, 'tag#5678'), (ns.bse.iso, 321), (ns.bse.t_created, '2022-02-22')])

    def test_agg_path_value(self):
        # value flag has no effect -> same test as test_agg_path
        self.assertListEqual(list(to_list_view(self.triples_111, node=True, path=False, value=False)),
            [('ent#1234', 123)])
        self.assertListEqual(list(to_list_view(self.triples_11U, node=True, path=False, value=False)),
            [('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678')])
        self.assertListEqual(list(to_list_view(self.triples_1M1, node=True, path=False, value=False)),
            [('ent#1234', 123), ('ent#1234', '2010-01-02')])
        self.assertListEqual(list(to_list_view(self.triples_1MU, node=True, path=False, value=False)),
            [('ent#1234', 123), ('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678')])
        self.assertListEqual(list(to_list_view(self.triples_N11, node=True, path=False, value=False)),
            [('ent#1234', 123), ('ent#4321', 321)])
        self.assertListEqual(list(to_list_view(self.triples_N1U, node=True, path=False, value=False)),
            [('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678'), ('ent#4321', 'tag#4321')])
        self.assertListEqual(list(to_list_view(self.triples_NM1, node=True, path=False, value=False)),
            [('ent#1234', 123), ('ent#1234', '2010-01-02'), ('ent#4321', 321), ('ent#4321', '2022-02-22')])
        self.assertListEqual(list(to_list_view(self.triples_NMU, node=True, path=False, value=False)),
            [('ent#1234', 123), ('ent#1234', 'tag#1234'), ('ent#1234', 'tag#5678'), ('ent#4321', 321), ('ent#4321', '2022-02-22')])

    def test_agg_all(self):
        # value flag has no effect -> same test as test_agg_node_path
        self.assertListEqual(list(to_list_view(self.triples_111, node=False, path=False, value=False)),
            [123])
        self.assertListEqual(list(to_list_view(self.triples_11U, node=False, path=False, value=False)),
            ['tag#1234', 'tag#5678'])
        self.assertListEqual(list(to_list_view(self.triples_1M1, node=False, path=False, value=False)),
            [123, '2010-01-02'])
        self.assertListEqual(list(to_list_view(self.triples_1MU, node=False, path=False, value=False)),
            [123, 'tag#1234', 'tag#5678'])
        self.assertListEqual(list(to_list_view(self.triples_N11, node=False, path=False, value=False)),
            [123, 321])
        self.assertListEqual(list(to_list_view(self.triples_N1U, node=False, path=False, value=False)),
            ['tag#1234', 'tag#5678', 'tag#4321'])
        self.assertListEqual(list(to_list_view(self.triples_NM1, node=False, path=False, value=False)),
            [123, '2010-01-02', 321, '2022-02-22'])
        self.assertListEqual(list(to_list_view(self.triples_NMU, node=False, path=False, value=False)),
            [123, 'tag#1234', 'tag#5678', 321, '2022-02-22'])


class TestDictView(unittest.TestCase):
    def setUp(self):
        self.unique_paths = {ns.bse.iso, ns.bse.t_created}
        self.triples_111 = [('ent#1234', ns.bse.iso, 123)]
        self.triples_11U = [('ent#1234', ns.bse.tag, 'tag#1234'),
                            ('ent#1234', ns.bse.tag, 'tag#5678')]
        self.triples_1M1 = [('ent#1234', ns.bse.iso, 123),
                            ('ent#1234', ns.bse.t_created, '2010-01-02')]
        self.triples_1MU = [('ent#1234', ns.bse.iso, 123),
                            ('ent#1234', ns.bse.tag, 'tag#1234'),
                            ('ent#1234', ns.bse.tag, 'tag#5678')]
        self.triples_N11 = [('ent#1234', ns.bse.iso, 123),
                            ('ent#4321', ns.bse.iso, 321)]
        self.triples_N1U = [('ent#1234', ns.bse.tag, 'tag#1234'),
                            ('ent#1234', ns.bse.tag, 'tag#5678'),
                            ('ent#4321', ns.bse.tag, 'tag#4321')]
        self.triples_NM1 = [('ent#1234', ns.bse.iso, 123),
                            ('ent#1234', ns.bse.t_created, '2010-01-02'),
                            ('ent#4321', ns.bse.iso, 321),
                            ('ent#4321', ns.bse.t_created, '2022-02-22')]
        self.triples_NMU = [('ent#1234', ns.bse.iso, 123),
                            ('ent#1234', ns.bse.tag, 'tag#1234'),
                            ('ent#1234', ns.bse.tag, 'tag#5678'),
                            ('ent#4321', ns.bse.iso, 321),
                            ('ent#4321', ns.bse.t_created, '2022-02-22')]

    def test_errounous_call(self):
        # return set instead of value
        self.assertSetEqual(to_dict_view(self.triples_111, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
            {123})
        self.assertSetEqual(to_dict_view(self.triples_111, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
            {123})
        # one_node mismatch: return set of values instead of value
        self.assertDictEqual(to_dict_view(self.triples_111, one_node=False, one_path=True, unique_paths=self.unique_paths, node=False, path=True, value=False),
            {ns.bse.iso: {123}})
        # one_path mismatch: return set of values instead of value
        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
            {'ent#1234': {123}})
        # unique_paths mismatch: return set of values instead of value
        self.assertSetEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths={}, node=False, path=False, value=False),
            {123})
        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths={}, node=False, path=True, value=False),
            {ns.bse.iso: {123}})
        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths={}, node=True, path=False, value=False),
            {'ent#1234': {123}})
        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True, one_path=False, unique_paths={}, node=True, path=True, value=False),
            {'ent#1234': {ns.bse.iso: {123}}})

    def test_agg_none(self):
        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True),
            {'ent#1234': {ns.bse.iso: {123}}})
        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True),
            {'ent#1234': {ns.bse.tag: {'tag#1234', 'tag#5678'}}})
        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True),
            {'ent#1234': {ns.bse.iso: {123}, ns.bse.t_created: {'2010-01-02'}}})
        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True),
            {'ent#1234': {ns.bse.iso: {123}, ns.bse.tag: {'tag#1234', 'tag#5678'}}})
        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True),
            {'ent#1234': {ns.bse.iso: {123}}, 'ent#4321': {ns.bse.iso: {321}}})
        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True),
            {'ent#1234': {ns.bse.tag: {'tag#1234', 'tag#5678'}}, 'ent#4321': {ns.bse.tag: {'tag#4321'}}})
        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True),
            {'ent#1234': {ns.bse.iso: {123}, ns.bse.t_created: {'2010-01-02'}}, 'ent#4321': {ns.bse.iso: {321}, ns.bse.t_created: {'2022-02-22'}}})
        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True),
            {'ent#1234': {ns.bse.iso: {123}, ns.bse.tag: {'tag#1234', 'tag#5678'}}, 'ent#4321': {ns.bse.iso: {321}, ns.bse.t_created: {'2022-02-22'}}})
        # empty
        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True), {})
        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True), {})
        self.assertDictEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=True), {})
        self.assertDictEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=True), {})

    def test_agg_node(self):
        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True),
            {ns.bse.iso: {123}})
        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True),
            {ns.bse.tag: {'tag#1234', 'tag#5678'}})
        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True),
            {ns.bse.iso: {123}, ns.bse.t_created: {'2010-01-02'}})
        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True),
            {ns.bse.iso: {123}, ns.bse.tag: {'tag#1234', 'tag#5678'}})
        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True),
            {ns.bse.iso: {123, 321}})
        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True),
            {ns.bse.tag: {'tag#1234', 'tag#5678', 'tag#4321'}})
        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True),
            {ns.bse.iso: {123, 321}, ns.bse.t_created: {'2010-01-02', '2022-02-22'}})
        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True),
            {ns.bse.iso: {123, 321}, ns.bse.tag: {'tag#1234', 'tag#5678'}, ns.bse.t_created: {'2022-02-22'}})
        # empty
        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True), {})
        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True), {})
        self.assertDictEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=True), {})
        self.assertDictEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=True), {})

    def test_agg_path(self):
        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True),
            {'ent#1234': {123}})
        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True),
            {'ent#1234': {'tag#1234', 'tag#5678'}})
        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True),
            {'ent#1234': {123, '2010-01-02'}})
        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True),
            {'ent#1234': {123, 'tag#1234', 'tag#5678'}})
        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True),
            {'ent#1234': {123}, 'ent#4321': {321}})
        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True),
            {'ent#1234': {'tag#1234', 'tag#5678'}, 'ent#4321': {'tag#4321'}})
        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True),
            {'ent#1234': {123, '2010-01-02'}, 'ent#4321': {321, '2022-02-22'}})
        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True),
            {'ent#1234': {123, 'tag#1234', 'tag#5678'}, 'ent#4321': {321, '2022-02-22'}})
        # empty
        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True), {})
        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True), {})
        self.assertDictEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=True), {})
        self.assertDictEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=True), {})

    def test_agg_node_path(self):
        self.assertSetEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True),
            {123})
        self.assertSetEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True),
            {'tag#1234', 'tag#5678'})
        self.assertSetEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True),
            {123, '2010-01-02'})
        self.assertSetEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True),
            {123, 'tag#1234', 'tag#5678'})
        self.assertSetEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True),
            {123, 321})
        self.assertSetEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True),
            {'tag#1234', 'tag#5678', 'tag#4321'})
        self.assertSetEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True),
            {123, '2010-01-02', 321, '2022-02-22'})
        self.assertSetEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True),
            {123, 'tag#1234', 'tag#5678', 321, '2022-02-22'})
        # empty
        self.assertSetEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True), set())
        self.assertSetEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True), set())
        self.assertSetEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=True), set())
        self.assertSetEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=True), set())

    def test_agg_value(self):
        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False),
            {'ent#1234': {ns.bse.iso: 123}})
        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False),
            {'ent#1234': {ns.bse.tag: {'tag#1234', 'tag#5678'}}})
        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False),
            {'ent#1234': {ns.bse.iso: 123, ns.bse.t_created: '2010-01-02'}})
        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False),
            {'ent#1234': {ns.bse.iso: 123, ns.bse.tag: {'tag#1234', 'tag#5678'}}})
        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False),
            {'ent#1234': {ns.bse.iso: 123}, 'ent#4321': {ns.bse.iso: 321}})
        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False),
            {'ent#1234': {ns.bse.tag: {'tag#1234', 'tag#5678'}}, 'ent#4321': {ns.bse.tag: {'tag#4321'}}})
        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False),
            {'ent#1234': {ns.bse.iso: 123, ns.bse.t_created: '2010-01-02'}, 'ent#4321': {ns.bse.iso: 321, ns.bse.t_created: '2022-02-22'}})
        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False),
            {'ent#1234': {ns.bse.iso: 123, ns.bse.tag: {'tag#1234', 'tag#5678'}}, 'ent#4321': {ns.bse.iso: 321, ns.bse.t_created: '2022-02-22'}})
        # empty
        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False), {})
        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False), {})
        self.assertDictEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=True, value=False), {})
        self.assertDictEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=True, value=False), {})

    def test_agg_node_value(self):
        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False),
            {ns.bse.iso: 123})
        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False),
            {ns.bse.tag: {'tag#1234', 'tag#5678'}})
        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False),
            {ns.bse.iso: 123, ns.bse.t_created: '2010-01-02'})
        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False),
            {ns.bse.iso: 123, ns.bse.tag: {'tag#1234', 'tag#5678'}})
        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False),
            {ns.bse.iso: {123, 321}})
        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False),
            {ns.bse.tag: {'tag#1234', 'tag#5678', 'tag#4321'}})
        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False),
            {ns.bse.iso: {123, 321}, ns.bse.t_created: {'2010-01-02', '2022-02-22'}})
        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False),
            {ns.bse.iso: {123, 321}, ns.bse.tag: {'tag#1234', 'tag#5678'}, ns.bse.t_created: {'2022-02-22'}})
        # empty
        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False), {})
        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False), {})
        self.assertDictEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=True, value=False), {})
        self.assertDictEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=True, value=False), {})

    def test_agg_path_value(self):
        self.assertDictEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False),
            {'ent#1234': 123})
        self.assertDictEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False),
            {'ent#1234': {'tag#1234', 'tag#5678'}})
        self.assertDictEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
            {'ent#1234': {123, '2010-01-02'}})
        self.assertDictEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
            {'ent#1234': {123, 'tag#1234', 'tag#5678'}})
        self.assertDictEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False),
            {'ent#1234': 123, 'ent#4321': 321})
        self.assertDictEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False),
            {'ent#1234': {'tag#1234', 'tag#5678'}, 'ent#4321': {'tag#4321'}})
        self.assertDictEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
            {'ent#1234': {123, '2010-01-02'}, 'ent#4321': {321, '2022-02-22'}})
        self.assertDictEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False),
            {'ent#1234': {123, 'tag#1234', 'tag#5678'}, 'ent#4321': {321, '2022-02-22'}})
        # empty
        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False), {})
        self.assertDictEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False), {})
        self.assertDictEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=True, path=False, value=False), {})
        self.assertDictEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=True, path=False, value=False), {})

    def test_agg_all(self):
        self.assertEqual(to_dict_view(self.triples_111, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
            123)
        self.assertSetEqual(to_dict_view(self.triples_11U, one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
            {'tag#1234', 'tag#5678'})
        self.assertSetEqual(to_dict_view(self.triples_1M1, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
            {123, '2010-01-02'})
        self.assertSetEqual(to_dict_view(self.triples_1MU, one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
            {123, 'tag#1234', 'tag#5678'})
        self.assertSetEqual(to_dict_view(self.triples_N11, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
            {123, 321})
        self.assertSetEqual(to_dict_view(self.triples_N1U, one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False),
            {'tag#1234', 'tag#5678', 'tag#4321'})
        self.assertSetEqual(to_dict_view(self.triples_NM1, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
            {123, '2010-01-02', 321, '2022-02-22'})
        self.assertSetEqual(to_dict_view(self.triples_NMU, one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False),
            {123, 'tag#1234', 'tag#5678', 321, '2022-02-22'})
        # empty
        self.assertEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False), None)
        self.assertSetEqual(to_dict_view([], one_node=True,  one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False), set())
        self.assertSetEqual(to_dict_view([], one_node=False, one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False), set())
        self.assertSetEqual(to_dict_view([], one_node=False, one_path=False, unique_paths=self.unique_paths, node=False, path=False, value=False), set())
        self.assertEqual(to_dict_view([], one_node=True,  one_path=True,  unique_paths=self.unique_paths, node=False, path=False, value=False, default=123), 123)

## main ##

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

## EOF ##