def test_init_data_source(self, *args):
params = {
'options': {}
}
self.transaction.method = 'init'
data_source_svc = DataSourceService(transaction=self.transaction)
response = data_source_svc.init(params.copy())
print_data(response, 'test_init_data_source')
PluginInfo(response)
def test_register_metric_data_source_with_secret_id(self, mock_plugin_verify, mock_list_secrets,
mock_get_plugin, *args):
secret_id = utils.generate_id('secret')
plugin_id = utils.generate_id('plugin')
plugin_version = '1.0'
mock_plugin_verify.return_value = {
'metadata': {
'supported_resource_type': ['inventory.Server', 'inventory.CloudService'],
'supported_stat': ['AVERAGE', 'MAX', 'MIN'],
'required_keys': ['reference.resource_id']
}
}
mock_list_secrets.return_value = {
'results': [{
'secret_id': secret_id,
'schema': 'aws_access_key'
}],
'total_count': 1
}
mock_get_plugin.return_value = {
'capability': {
'supported_schema': ['aws_access_key', 'aws_assume_role'],
'monitoring_type': 'METRIC'
},
'provider': 'aws'
}
params = {
'name': 'AWS CloudWatch',
'plugin_info': {
'plugin_id': plugin_id,
'version': plugin_version,
'options': {},
'secret_id': secret_id
},
'tags': {
utils.random_string(): utils.random_string()
},
'domain_id': self.domain_id
}
self.transaction.method = 'register'
data_source_svc = DataSourceService(transaction=self.transaction)
data_source_vo = data_source_svc.register(params.copy())
print_data(data_source_vo.to_dict(), 'test_register_metric_data_source_with_secret_id')
DataSourceInfo(data_source_vo)
self.assertIsInstance(data_source_vo, DataSource)
self.assertEqual(params['name'], data_source_vo.name)
self.assertEqual(params['tags'], utils.tags_to_dict(data_source_vo.tags))
self.assertEqual(params['domain_id'], data_source_vo.domain_id)
def test_update_protocol_plugin(self, mock_plugin_init, mock_list_secrets, *args):
plugin_version = '1.2'
update_options = {
'test': 'xxxxx'
}
mock_plugin_init.return_value = {
'metadata': {
'data_type': 'PLAIN_TEXT',
'data': {
'schema': {
'properties': {
'phone_number': {
'minLength': 10,
'title': 'Phone Number',
'type': 'string',
'pattern': '^01(?:0|1|[6-9])[.-]?(\\d{3}|\\d{4}[.-]?(\\d{4})$'
}
},
'required': [
'phone_number'
],
'type': 'object'
}
}
}
}
mock_list_secrets.return_value = {
'results': [{
'secret_id': utils.generate_id('secret')
}],
'total_count': 1
}
protocol_vo = ProtocolFactory(domain_id=self.domain_id)
params = {
'protocol_id': protocol_vo.protocol_id,
'version': plugin_version,
'options': update_options,
'domain_id': self.domain_id
}
self.transaction.method = 'update_plugin'
protocol_svc = ProtocolService(transaction=self.transaction)
new_protocol_vo = protocol_svc.update_plugin(params.copy())
print_data(new_protocol_vo.to_dict(), 'test_update_protocol_plugin')
ProtocolInfo(new_protocol_vo)
self.assertIsInstance(new_protocol_vo, Protocol)
self.assertEqual(new_protocol_vo.protocol_id, protocol_vo.protocol_id)
self.assertEqual(params['version'], new_protocol_vo.plugin_info.version)
self.assertEqual(params['options'], new_protocol_vo.plugin_info.options)
def test_list_service_account_logs(self, mock_list_logs, mock_list_secrets,
mock_get_server, *args):
service_account_id = utils.generate_id('sa')
end = datetime.utcnow()
start = end - timedelta(days=1)
mock_list_logs.return_value.__iter__ = lambda response: iter([{
'resource_type':
'monitoring.Log',
'result': {
'logs': [{
'key1': 'value1',
'key2': 'value2',
'key3': 'value3'
}]
}
}])
mock_list_secrets.return_value = {
'results': [{
'secret_id': utils.generate_id('secret')
}],
'total_count': 1
}
mock_get_server.return_value = {
'service_account_id': service_account_id
}
new_data_source_vo = DataSourceFactory(domain_id=self.domain_id)
params = {
'data_source_id': new_data_source_vo.data_source_id,
'resource_type': 'identity.ServiceAccount',
'resource_id': service_account_id,
'filter': {},
'start': start.isoformat(),
'end': end.isoformat(),
'sort': {
'key': 'EventId',
'desc': False
},
'limit': 10,
'domain_id': self.domain_id
}
self.transaction.method = 'list'
log_svc = LogService(transaction=self.transaction)
logs_data_info = log_svc.list(params.copy())
print_data(logs_data_info, 'test_list_logs')
LogDataInfo(logs_data_info)
self.assertEqual(params['domain_id'], logs_data_info['domain_id'])
def test_get_metric_data(self, mock_get_metric_data, mock_list_secrets, mock_list_servers, *args):
server_id_1 = utils.generate_id('server')
server_id_2 = utils.generate_id('server')
end = datetime.utcnow()
start = end - timedelta(days=1)
start_ts = int(time.mktime(start.timetuple()))
mock_get_metric_data.return_value = {
'labels': [start_ts, start_ts + 3600, start_ts + (3600 * 2), start_ts + (3600 * 3),
start_ts + (3600 * 4)],
'values': [1, 2, 3, 4, 5]
}
mock_list_secrets.return_value = {
'results': [{
'secret_id': utils.generate_id('secret')
}],
'total_count': 1
}
mock_list_servers.return_value = {
'results': [{
'server_id': server_id_1,
'reference': {'resource_id': 'arn:aws:ec2:ap-northeast-2:123456789012:instance/i-1234'},
'collection_info': {'secrets': [utils.generate_id('secret')]}
}, {
'server_id': server_id_2,
'reference': {'resource_id': 'arn:aws:ec2:ap-northeast-2:123456789012:instance/i-4567'},
'collection_info': {'secrets': [utils.generate_id('secret')]}
}],
'total_count': 2
}
new_data_source_vo = DataSourceFactory(domain_id=self.domain_id)
params = {
'data_source_id': new_data_source_vo.data_source_id,
'resource_type': 'inventory.Server',
'resources': [server_id_1, server_id_2],
'metric': 'cpu',
'start': start.isoformat(),
'end': end.isoformat(),
'domain_id': self.domain_id
}
self.transaction.method = 'get_data'
metric_svc = MetricService(transaction=self.transaction)
metrics_data_info = metric_svc.get_data(params.copy())
print_data(metrics_data_info, 'test_get_metric_data')
MetricDataInfo(metrics_data_info)
self.assertEqual(params['domain_id'], metrics_data_info['domain_id'])
def test_update_data_source(self, mock_plugin_verify, mock_list_secrets,
*args):
mock_plugin_verify.return_value.__iter__ = lambda response: iter([{
'resource_type':
'monitoring.DataSource',
'result': {
'options': {
'supported_resource_type': ['inventory.Server'],
'supported_stat': ['AVERAGE', 'MAX', 'MIN'],
'reference_keys': [{
'resource_type': 'inventory.Server',
'reference_key': 'reference.resource_id'
}]
}
}
}])
mock_list_secrets.return_value = {
'results': [{
'secret_id': utils.generate_id('secret')
}],
'total_count': 1
}
new_data_source_vo = DataSourceFactory(domain_id=self.domain_id)
params = {
'data_source_id': new_data_source_vo.data_source_id,
'name': 'Update AWS CloudWatch',
'plugin_info': {
'plugin_id': new_data_source_vo.plugin_info.plugin_id,
'version': '2.0',
'options': {},
'provider': 'aws'
},
'tags': {
'update_key': 'update_value'
},
'domain_id': self.domain_id
}
self.transaction.method = 'update'
data_source_svc = DataSourceService(transaction=self.transaction)
data_source_vo = data_source_svc.update(params.copy())
print_data(data_source_vo.to_dict(), 'test_update_data_source')
DataSourceInfo(data_source_vo)
self.assertIsInstance(data_source_vo, DataSource)
self.assertEqual(new_data_source_vo.data_source_id,
data_source_vo.data_source_id)
self.assertEqual(params['name'], data_source_vo.name)
self.assertEqual(params.get('tags', {}), data_source_vo.tags)
def test_resource_stat_index_join_wrong_index(self, mock_stat_resource,
*args):
mock_stat_resource.side_effect = [{
'results': []
}, {
'results': [{
'fail_count': 0
}]
}]
params = {
'resource_type':
'inventory.Job',
'query': {
'filter': [{
'key': 'state',
'value': 'SUCCESS',
'operator': 'eq'
}],
'aggregate': {
'count': {
'name': 'success_count'
}
}
},
'join': [{
'type': 'OUTER',
'resource_type': 'inventory.Jon',
'query': {
'filter': [{
'key': 'state',
'value': 'FAILURE',
'operator': 'eq'
}],
'aggregate': {
'count': {
'name': 'fail_count'
}
}
}
}],
'domain_id':
utils.generate_id('domain')
}
self.transaction.method = 'stat'
resource_svc = ResourceService(transaction=self.transaction)
results = resource_svc.stat(params.copy())
print_data(results, 'test_resource_stat_index_join_wrong_index')
StatisticsInfo(results)
def test_generate_default_provider_by_list_providers_method(self, *args):
params = {'provider': 'aws', 'domain_id': self.domain_id}
self.transaction.method = 'list'
provider_svc = ProviderService(transaction=self.transaction)
providers_vos, total_count = provider_svc.list(params)
print_data(providers_vos,
'test_generate_default_provider_by_list_providers_method')
ProvidersInfo(providers_vos, total_count)
self.assertEqual(len(providers_vos), 1)
self.assertIsInstance(providers_vos[0], Provider)
self.assertEqual(total_count, 1)
def test_get_cloudwatch_query(self, *args):
resource = {
"namespace": "AWS/EC2",
"dimensions": [{
"Name": "InstanceId",
"Value": "i-011e8d755568b446b"
}],
"region_name": "ap-northeast-2"
}
aws_mgr = AWSManager()
namespace, dimensions = aws_mgr._get_cloudwatch_query(resource)
print_data(namespace, 'test_get_cloudwatch_query.namespace')
print_data(dimensions, 'test_get_cloudwatch_query.dimensions')
def test_list_servers(self):
response = self.inventory_connector.list_servers({'page': {'limit': 3}, 'minimal': True}, self.domain_id)
server_ids = [server_info['server_id'] for server_info in response['results']]
query = {
'filter': [{
'k': 'server_id',
'v': server_ids,
'o': 'in'
}],
'only': ['server_id', 'name', 'collection_info.secrets']
}
response = self.inventory_connector.list_servers(query, self.domain_id)
print_data(response, 'test_list_servers')
def test_list_cloud_services(self):
response = self.inventory_connector.list_cloud_services({'page': {'limit': 3}, 'minimal': True}, self.domain_id)
cloud_service_ids = [cloud_service_info['cloud_service_id'] for cloud_service_info in response['results']]
query = {
'filter': [{
'k': 'cloud_service_id',
'v': cloud_service_ids,
'o': 'in'
}],
'only': ['cloud_service_id', 'reference.resource_id', 'collection_info.secrets']
}
response = self.inventory_connector.list_cloud_services(query, self.domain_id)
print_data(response, 'test_list_cloud_services')
def test_get_provider(self, *args):
new_provider_vo = ProviderFactory()
params = {
'provider': new_provider_vo.provider,
'domain_id': self.domain_id
}
self.transaction.method = 'get'
provider_svc = ProviderService(transaction=self.transaction)
provider_vo = provider_svc.get(params)
print_data(provider_vo.to_dict(), 'test_get_provider')
ProviderInfo(provider_vo)
self.assertIsInstance(provider_vo, Provider)
def test_get_metric_data(self):
endpoint = self.connector_conf['endpoint']
secret_data = self.connector_conf['secret_data']
resource = self.connector_conf['resource']
metric_name = self.connector_conf['metric']
schema = self.connector_conf['schema']
end = datetime.utcnow()
start = end - timedelta(minutes=60)
self.mp_connector.initialize(endpoint)
response = self.mp_connector.get_metric_data(schema, {}, secret_data, resource, metric_name, start, end,
None, None)
print_data(response, 'test_get_metric_data')
def test_get_project_channel(self, *args):
project_channel_vo = ProjectChannelFactory(domain_id=self.domain_id)
params = {
'project_channel_id': project_channel_vo.project_channel_id,
'domain_id': self.domain_id
}
self.transaction.method = 'get'
project_channel_svc = ProjectChannelService(transaction=self.transaction)
get_project_channel_vo = project_channel_svc.get(params)
print_data(get_project_channel_vo.to_dict(), 'test_get_project_channel')
ProjectChannelInfo(get_project_channel_vo)
self.assertIsInstance(get_project_channel_vo, ProjectChannel)
def test_list_metrics(self):
options = {}
secret_data = self.secret_data
self.gcp_connector.set_connect({}, options, secret_data)
resource = {
'type': 'gce_instance',
'filters': [{
'key': 'metric.labels.instance_name',
'value': 'stackdriver-jhsong-01'
}]
}
metrics_info = self.gcp_connector.list_metrics(resource)
print_data(metrics_info, 'test_list_metrics')
def test_get_schema_from_multi_repositories(self, *args):
new_repository_vo = RepositoryFactory(repository_type='remote')
new_schema_vo = SchemaFactory(domain_id=self.domain_id,
repository=new_repository_vo)
params = {'name': new_schema_vo.name, 'domain_id': self.domain_id}
self.transaction.method = 'get'
schema_svc = SchemaService(transaction=self.transaction)
schema_vo = schema_svc.get(params)
print_data(schema_vo.to_dict(),
'test_get_schema_from_multi_repositories')
SchemaInfo(schema_vo)
self.assertIsInstance(schema_vo, Schema)
def test_get_data_source(self, *args):
new_data_source_vo = DataSourceFactory(domain_id=self.domain_id)
params = {
'data_source_id': new_data_source_vo.data_source_id,
'domain_id': self.domain_id
}
self.transaction.method = 'get'
data_source_svc = DataSourceService(transaction=self.transaction)
data_source_vo = data_source_svc.get(params)
print_data(data_source_vo.to_dict(), 'test_get_data_source')
DataSourceInfo(data_source_vo)
self.assertIsInstance(data_source_vo, DataSource)
def test_get_user_channel(self, *args):
user_channel_vo = UserChannelFactory(domain_id=self.domain_id)
params = {
'user_channel_id': user_channel_vo.user_channel_id,
'domain_id': self.domain_id
}
self.transaction.method = 'get'
user_channel_svc = UserChannelService(transaction=self.transaction)
get_user_channel_vo = user_channel_svc.get(params)
print_data(get_user_channel_vo.to_dict(), 'test_get_user_channel')
UserChannelInfo(get_user_channel_vo)
self.assertIsInstance(get_user_channel_vo, UserChannel)
def test_get_metric_data(self, *args):
schema = 'azure_client_secret'
azure_mgr = AzureManager()
metric = 'Percentage CPU'
resource = f'subscriptions/{self.subscription_id}/resourceGroups/{self.resource_group}/providers/Microsoft.Compute/virtualMachines/{self.vm_name}'
stat = 'AVERAGE'
options = {}
end = datetime.utcnow()
start = end - timedelta(days=2)
period = azure_mgr._make_period_from_time_range(start, end)
azure_mgr.get_metric_data(schema, options, self.secret_data, resource,
metric, start, end, period, stat)
print_data(period, 'test_make_period_from_time_range')
def test_get_metric_data(self, mock_get_metric_data, *args):
end = datetime.utcnow()
start = end - timedelta(days=1)
mock_get_metric_data.return_value = {
'labels': [{
'seconds': 1586988300
}, {
'seconds': 1586988000
}, {
'seconds': 1586987700
}, {
'seconds': 1586987400
}, {
'seconds': 1586987100
}, {
'seconds': 1586986800
}, {
'seconds': 1586986500
}, {
'seconds': 1586986200
}, {
'seconds': 1586985900
}, {
'seconds': 1586985600
}, {
'seconds': 1586985300
}, {
'seconds': 1586985000
}],
'values':
[4.0, 4.0, 4.0, 4.0, 4.4, 4.4, 4.0, 4.0, 6.0, 4.0, 4.0, 4.4]
}
params = {
'options': {},
'secret_data': {},
'resource':
'subscriptions/xxx/resourceGroups/cloudone/providers/Microsoft.Compute/virtualMachines/cloud-vm',
'metric': 'CPUUtilization',
'start': start.isoformat(),
'end': end.isoformat()
}
self.transaction.method = 'get_data'
metric_svc = MetricService(transaction=self.transaction)
response = metric_svc.get_data(params.copy())
print_data(response, 'test_get_metric_data')
PluginMetricDataResponse(response)
def test_get_metric_data(self, mock_get_metric_data, *args):
end = datetime.utcnow()
start = end - timedelta(days=1)
mock_get_metric_data.return_value = {
'labels': [{
'seconds': 1586988300
}, {
'seconds': 1586988000
}, {
'seconds': 1586987700
}, {
'seconds': 1586987400
}, {
'seconds': 1586987100
}, {
'seconds': 1586986800
}, {
'seconds': 1586986500
}, {
'seconds': 1586986200
}, {
'seconds': 1586985900
}, {
'seconds': 1586985600
}, {
'seconds': 1586985300
}, {
'seconds': 1586985000
}],
'values':
[4.0, 4.0, 4.0, 4.0, 4.4, 4.4, 4.0, 4.0, 6.0, 4.0, 4.0, 4.4]
}
params = {
'options': {},
'secret_data': {},
'resource':
'arn:aws:ec2:ap-northeast-2:072548720675:instance/i-0547704161b1aa823',
'metric': 'CPUUtilization',
'start': start.isoformat(),
'end': end.isoformat()
}
self.transaction.method = 'get_data'
metric_svc = MetricService(transaction=self.transaction)
for response in metric_svc.get_data(params.copy()):
print_data(response, 'test_get_metric_data')
MetricDataInfo(response)
def test_get_schedule(self, *args):
new_schedule_vo = ScheduleFactory(domain_id=self.domain_id)
params = {
'schedule_id': new_schedule_vo.storage_id,
'domain_id': self.domain_id
}
self.transaction.method = 'get'
schedule_svc = ScheduleService(transaction=self.transaction)
schedule_vo = schedule_svc.get(params.copy())
print_data(schedule_vo.to_dict(), 'test_get_schedule')
ScheduleInfo(schedule_vo)
self.assertIsInstance(schedule_vo, Schedule)
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_get_config_map(self, *args):
new_config_map_vo = ConfigMapFactory(domain_id=self.domain_id)
params = {
'name': new_config_map_vo.name,
'domain_id': self.domain_id
}
self.transaction.method = 'get'
config_map_svc = ConfigMapService(transaction=self.transaction)
config_map_vo = config_map_svc.get(params.copy())
print_data(config_map_vo.to_dict(), 'test_get_config_map')
ConfigMapInfo(config_map_vo)
self.assertIsInstance(config_map_vo, ConfigMap)
def test_get_schema(self, *args):
new_schema_vo = SchemaFactory(domain_id=self.domain_id)
params = {
'name': new_schema_vo.name,
'repository_id': self.repository_id,
'domain_id': self.domain_id
}
self.transaction.method = 'get'
schema_svc = SchemaService(transaction=self.transaction)
schema_vo = schema_svc.get(params)
print_data(schema_vo.to_dict(), 'test_get_schema')
SchemaInfo(schema_vo)
self.assertIsInstance(schema_vo, Schema)
def test_create_schema(self, *args):
params = {
'name': 'aws_access_key',
'service_type': 'secret.credentials',
'schema': {
'type': 'object',
'properties': {
'aws_access_key_id': {
'title': 'AWS Access Key',
'type': 'string',
'minLength': 4
},
'aws_secret_access_key': {
'title': 'AWS Secret Key',
'type': 'string',
'minLength': 4
},
'region_name': {
'title': "Region",
'type': 'string',
'minLength': 4,
'examples': ['ap-northeast-2']
}
},
'required': ['aws_access_key_id', 'aws_secret_access_key']
},
'labels': ['cc', 'dd'],
'tags': {
utils.random_string(): utils.random_string()
},
'domain_id': self.domain_id
}
self.transaction.method = 'create'
schema_svc = SchemaService(transaction=self.transaction)
schema_vo = schema_svc.create(params.copy())
print_data(schema_vo.to_dict(), 'test_create_schema')
SchemaInfo(schema_vo)
self.assertIsInstance(schema_vo, Schema)
self.assertEqual(params['name'], schema_vo.name)
self.assertEqual(params['service_type'], schema_vo.service_type)
self.assertEqual(params.get('schema', {}), schema_vo.schema)
self.assertEqual(params.get('labels', []), schema_vo.labels)
self.assertEqual(params['tags'], utils.tags_to_dict(schema_vo.tags))
self.assertEqual(params['domain_id'], schema_vo.domain_id)
def test_create_project_channel_secret(self, *args):
protocol_capability = {
'data_type': 'SECRET',
'supported_schema': ['slack_webhook']
}
protocol_vo = ProtocolFactory(domain_id=self.domain_id, capability=protocol_capability)
protocol_id = protocol_vo.protocol_id
params = {
'name': 'Test Project Channel',
'protocol_id': protocol_id,
'schema': 'slack_webhook',
'project_id': 'project-xyz',
'data': {
'token': 'xxxxxx',
'channel': 'bob'
},
'is_scheduled': True,
'schedule': {
'day_of_week': ['MON'],
'start_hour': 1,
'end_hour': 10
},
'tags': {
utils.random_string(): utils.random_string()
},
'domain_id': self.domain_id
}
self.transaction.method = 'create'
prj_ch_svc = ProjectChannelService(transaction=self.transaction)
project_ch_vo = prj_ch_svc.create(params.copy())
print_data(project_ch_vo.to_dict(), 'test_create_project_channel')
ProjectChannelInfo(project_ch_vo)
self.assertIsInstance(project_ch_vo, ProjectChannel)
self.assertEqual(params['name'], project_ch_vo.name)
self.assertEqual(True, project_ch_vo.is_scheduled)
self.assertEqual(False, project_ch_vo.is_subscribe)
self.assertEqual('secret-xyz', project_ch_vo.secret_id)
self.assertEqual({}, project_ch_vo.data)
self.assertEqual(params['schedule']['day_of_week'], project_ch_vo.schedule.day_of_week)
self.assertEqual(params['schedule']['start_hour'], project_ch_vo.schedule.start_hour)
self.assertEqual(params['tags'], project_ch_vo.tags)
self.assertEqual(params['domain_id'], project_ch_vo.domain_id)
def test_get_metric_data(self):
aws_mgr = AWSManager()
namespace, dimensions = aws_mgr._get_cloudwatch_query(self.resource)
self.aws_credentials['region_name'] = self.resource.get('region_name')
end = datetime.utcnow()
start = end - timedelta(minutes=60)
period = aws_mgr._make_period_from_time_range(start, end)
stat = aws_mgr._convert_stat('AVERAGE')
self.aws_connector.create_session(self.schema, {},
self.aws_credentials)
metric_data_info = self.aws_connector.get_metric_data(
namespace, dimensions, self.metric, start, end, period, stat)
print_data(metric_data_info, 'test_get_metric_data')
def test_disable_project_channel(self, *args):
project_channel_vo = ProjectChannelFactory(domain_id=self.domain_id, state='ENABLED')
params = {
'project_channel_id': project_channel_vo.project_channel_id,
'domain_id': self.domain_id
}
self.transaction.method = 'disable'
project_channel_svc = ProjectChannelService(transaction=self.transaction)
updated_project_channel_vo = project_channel_svc.disable(params.copy())
print_data(updated_project_channel_vo.to_dict(), 'test_disable_project_channel')
ProjectChannelInfo(updated_project_channel_vo)
self.assertIsInstance(updated_project_channel_vo, ProjectChannel)
self.assertEqual(updated_project_channel_vo.project_channel_id, project_channel_vo.project_channel_id)
self.assertEqual('DISABLED', updated_project_channel_vo.state)
def test_enable_user_channel(self, *args):
user_channel_vo = UserChannelFactory(domain_id=self.domain_id, state='DISABLED')
params = {
'user_channel_id': user_channel_vo.user_channel_id,
'domain_id': self.domain_id
}
self.transaction.method = 'enable'
user_channel_svc = UserChannelService(transaction=self.transaction)
updated_user_channel_vo = user_channel_svc.enable(params.copy())
print_data(updated_user_channel_vo.to_dict(), 'test_enable_user_channel')
UserChannelInfo(updated_user_channel_vo)
self.assertIsInstance(updated_user_channel_vo, UserChannel)
self.assertEqual(updated_user_channel_vo.user_channel_id, user_channel_vo.user_channel_id)
self.assertEqual('ENABLED', updated_user_channel_vo.state)
