def test_update_domain_config(self, *args):
        new_domain_config_vo = DomainConfigFactory(domain_id=self.domain_id)

        params = {
            'name': new_domain_config_vo.name,
            'data': {
                'update_data_key': 'update_data_value'
            },
            'schema': 'update_schema',
            'tags': {
                'update_key': 'update_value'
            },
            'domain_id': self.domain_id
        }

        self.transaction.method = 'update'
        domain_config_svc = DomainConfigService(transaction=self.transaction)
        domain_config_vo = domain_config_svc.update(params.copy())

        print_data(domain_config_vo.to_dict(), 'test_update_domain_config')
        DomainConfigInfo(domain_config_vo)

        self.assertIsInstance(domain_config_vo, DomainConfig)
        self.assertEqual(params['data'], domain_config_vo.data)
        self.assertEqual(params['schema'], domain_config_vo.schema)
        self.assertEqual(params['tags'], utils.tags_to_dict(domain_config_vo.tags))
        self.assertEqual(params['domain_id'], domain_config_vo.domain_id)
    def test_stat_domain_configs(self, *args):
        domain_config_vos = DomainConfigFactory.build_batch(10, domain_id=self.domain_id)
        list(map(lambda vo: vo.save(), domain_config_vos))

        params = {
            'domain_id': self.domain_id,
            'query': {
                'aggregate': [{
                    'group': {
                        'keys': [{
                            'key': 'name',
                            'name': 'Name'
                        }],
                        'fields': [{
                            'operator': 'count',
                            'name': 'Count'
                        }]
                    }
                }, {
                    'sort': {
                        'key': 'Count',
                        'desc': True
                    }
                }]
            }
        }

        self.transaction.method = 'stat'
        domain_config_svc = DomainConfigService(transaction=self.transaction)
        values = domain_config_svc.stat(params)
        StatisticsInfo(values)

        print_data(values, 'test_stat_domain_configs')
    def test_create_domain_config(self, *args):
        params = {
            'name': 'inventory.server.metadata.view.table.layout',
            'data': {
                'key': 'value'
            },
            'schema': 'test_schema',
            'tags': {
                utils.random_string(): utils.random_string()
            },
            'domain_id': utils.generate_id('domain')
        }

        self.transaction.method = 'create'
        domain_config_svc = DomainConfigService(transaction=self.transaction)
        domain_config_vo = domain_config_svc.create(params.copy())

        print_data(domain_config_vo.to_dict(), 'test_create_domain_config')
        DomainConfigInfo(domain_config_vo)

        self.assertIsInstance(domain_config_vo, DomainConfig)
        self.assertEqual(params['name'], domain_config_vo.name)
        self.assertEqual(params['data'], domain_config_vo.data)
        self.assertEqual(params['schema'], domain_config_vo.schema)
        self.assertEqual(params['tags'], utils.tags_to_dict(domain_config_vo.tags))
        self.assertEqual(params['domain_id'], domain_config_vo.domain_id)
    def test_delete_domain_config(self, *args):
        new_domain_config_vo = DomainConfigFactory(domain_id=self.domain_id)

        params = {
            'name': new_domain_config_vo.name,
            'domain_id': self.domain_id
        }

        self.transaction.method = 'delete'
        domain_config_svc = DomainConfigService(transaction=self.transaction)
        result = domain_config_svc.delete(params.copy())

        self.assertIsNone(result)
    def test_get_domain_config(self, *args):
        new_domain_config_vo = DomainConfigFactory(domain_id=self.domain_id)

        params = {
            'name': new_domain_config_vo.name,
            'domain_id': self.domain_id
        }

        self.transaction.method = 'get'
        domain_config_svc = DomainConfigService(transaction=self.transaction)
        domain_config_vo = domain_config_svc.get(params.copy())

        print_data(domain_config_vo.to_dict(), 'test_get_domain_config')
        DomainConfigInfo(domain_config_vo)

        self.assertIsInstance(domain_config_vo, DomainConfig)
    def test_list_domain_configs_by_name(self, *args):
        domain_config_vos = DomainConfigFactory.build_batch(10, domain_id=self.domain_id)
        list(map(lambda vo: vo.save(), domain_config_vos))

        params = {
            'name': domain_config_vos[0].name,
            'domain_id': self.domain_id
        }

        self.transaction.method = 'list'
        domain_config_svc = DomainConfigService(transaction=self.transaction)
        domain_config_vos, total_count = domain_config_svc.list(params.copy())
        DomainConfigsInfo(domain_config_vos, total_count)

        self.assertEqual(len(domain_config_vos), 1)
        self.assertIsInstance(domain_config_vos[0], DomainConfig)
        self.assertEqual(total_count, 1)
    def test_stat_domain_configs_distinct(self, *args):
        domain_config_vos = DomainConfigFactory.build_batch(10, domain_id=self.domain_id)
        list(map(lambda vo: vo.save(), domain_config_vos))

        params = {
            'domain_id': self.domain_id,
            'query': {
                'distinct': 'name',
                'page': {
                    'start': 2,
                    'limit': 3
                }
            }
        }

        self.transaction.method = 'stat'
        domain_config_svc = DomainConfigService(transaction=self.transaction)
        values = domain_config_svc.stat(params)
        StatisticsInfo(values)

        print_data(values, 'test_stat_domain_configs_distinct')
    def test_list_domain_configs_by_tag(self, *args):
        DomainConfigFactory(tags=[{'key': 'tag_key_1', 'value': 'tag_value_1'}], domain_id=self.domain_id)
        domain_config_vos = DomainConfigFactory.build_batch(9, domain_id=self.domain_id)
        list(map(lambda vo: vo.save(), domain_config_vos))

        params = {
            'query': {
                'filter': [{
                    'k': 'tags.tag_key_1',
                    'v': 'tag_value_1',
                    'o': 'eq'
                }]
            },
            'domain_id': self.domain_id
        }

        self.transaction.method = 'list'
        domain_config_svc = DomainConfigService(transaction=self.transaction)
        domain_config_vos, total_count = domain_config_svc.list(params.copy())
        DomainConfigsInfo(domain_config_vos, total_count)

        self.assertEqual(len(domain_config_vos), 1)
        self.assertIsInstance(domain_config_vos[0], DomainConfig)
        self.assertEqual(total_count, 1)