def test_get_protocol(self, *args):
protocol_vo = ProtocolFactory(domain_id=self.domain_id)
params = {
'protocol_id': protocol_vo.protocol_id,
'domain_id': self.domain_id
}
self.transaction.method = 'get'
protocol_svc = ProtocolService(transaction=self.transaction)
protocol_vo = protocol_svc.get(params)
print_data(protocol_vo.to_dict(), 'test_get_protocol')
ProtocolInfo(protocol_vo)
self.assertIsInstance(protocol_vo, Protocol)
def test_update_project_channel_secret(self, *args):
protocol_vo = ProtocolFactory(domain_id=self.domain_id)
project_channel_vo = ProjectChannelFactory(
protocol_id=protocol_vo.protocol_id,
domain_id=self.domain_id,
secret_id='secret-xyz')
name = 'Update Project Channel'
data = {'phone_number': '0109994444'}
params = {
'name': name,
'project_channel_id': project_channel_vo.project_channel_id,
'data': data,
'tags': {
utils.random_string(): utils.random_string()
},
'domain_id': self.domain_id
}
self.transaction.method = 'update'
prj_ch_svc = ProjectChannelService(transaction=self.transaction)
update_project_ch_vo = prj_ch_svc.update(params.copy())
print_data(update_project_ch_vo.to_dict(),
'test_update_project_channel')
ProjectChannelInfo(update_project_ch_vo)
self.assertIsInstance(update_project_ch_vo, ProjectChannel)
self.assertEqual(name, update_project_ch_vo.name)
self.assertEqual('secret-xyz', update_project_ch_vo.secret_id)
self.assertEqual({}, update_project_ch_vo.data)
self.assertEqual(params['tags'], update_project_ch_vo.tags)
self.assertEqual(params['domain_id'], update_project_ch_vo.domain_id)
def test_create_user_channel_no_schedule(self, *args):
protocol_vo = ProtocolFactory(domain_id=self.domain_id)
protocol_id = protocol_vo.protocol_id
params = {
'name': 'Test User Channel',
'protocol_id': protocol_id,
'user_id': 'bluese05',
'data': {
'token': 'xxxxxx',
'channel': 'bob'
},
'is_scheduled': False,
'schedule': None,
'tags': {
utils.random_string(): utils.random_string()
},
'domain_id': self.domain_id
}
self.transaction.method = 'create'
user_ch_svc = UserChannelService(transaction=self.transaction)
user_ch_vo = user_ch_svc.create(params.copy())
print_data(user_ch_vo.to_dict(), 'test_create_project_channel')
UserChannelInfo(user_ch_vo)
self.assertIsInstance(user_ch_vo, UserChannel)
self.assertEqual(params['name'], user_ch_vo.name)
self.assertEqual(False, user_ch_vo.is_scheduled)
self.assertEqual(None, user_ch_vo.schedule)
self.assertEqual(False, user_ch_vo.is_subscribe)
self.assertEqual(None, user_ch_vo.secret_id)
self.assertEqual(params['tags'], user_ch_vo.tags)
self.assertEqual(params['domain_id'], user_ch_vo.domain_id)
def test_stat_protocol(self, *args):
protocol_vos = ProtocolFactory.build_batch(10, domain_id=self.domain_id)
list(map(lambda vo: vo.save(), protocol_vos))
params = {
'domain_id': self.domain_id,
'query': {
'aggregate': [{
'group': {
'keys': [{
'key': 'protocol_id',
'name': 'Id'
}],
'fields': [{
'operator': 'count',
'name': 'Count'
}]
}
}, {
'sort': {
'key': 'Count',
'desc': True
}
}]
}
}
self.transaction.method = 'stat'
protocol_svc = ProtocolService(transaction=self.transaction)
values = protocol_svc.stat(params)
StatisticsInfo(values)
print_data(values, 'test_stat_protocol')
def test_list_protocols_by_protocol_type(self, *args):
internal_protocol_vos = ProtocolFactory.build_batch(
5, protocol_type='INTERNAL', domain_id=self.domain_id)
external_protocol_vos = ProtocolFactory.build_batch(
10, protocol_type='EXTERNAL', domain_id=self.domain_id)
list(map(lambda vo: vo.save(), external_protocol_vos))
params = {'protocol_type': 'EXTERNAL', 'domain_id': self.domain_id}
self.transaction.method = 'list'
protocol_svc = ProtocolService(transaction=self.transaction)
protocol_vos, total_count = protocol_svc.list(params)
ProtocolsInfo(protocol_vos, total_count)
self.assertEqual(len(protocol_vos), 10)
self.assertIsInstance(protocol_vos[0], Protocol)
self.assertEqual(total_count, 10)
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_delete_protocol(self, *args):
protocol_vo = ProtocolFactory(domain_id=self.domain_id)
params = {
'protocol_id': protocol_vo.protocol_id,
'domain_id': self.domain_id
}
self.transaction.method = 'delete'
protocol_svc = ProtocolService(transaction=self.transaction)
result = protocol_svc.delete(params)
self.assertIsNone(result)
def test_list_protocols_by_name(self, *args):
protocol_vos = ProtocolFactory.build_batch(10,
domain_id=self.domain_id)
list(map(lambda vo: vo.save(), protocol_vos))
params = {'name': protocol_vos[0].name, 'domain_id': self.domain_id}
self.transaction.method = 'list'
protocol_svc = ProtocolService(transaction=self.transaction)
protocol_vos, total_count = protocol_svc.list(params)
ProtocolsInfo(protocol_vos, total_count)
self.assertEqual(len(protocol_vos), 1)
self.assertIsInstance(protocol_vos[0], Protocol)
self.assertEqual(total_count, 1)
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_disable_protocol(self, *args):
protocol_vo = ProtocolFactory(domain_id=self.domain_id, state='ENABLED')
params = {
'protocol_id': protocol_vo.protocol_id,
'domain_id': self.domain_id
}
self.transaction.method = 'disable'
protocol_svc = ProtocolService(transaction=self.transaction)
updated_protocol_vo = protocol_svc.disable(params.copy())
print_data(updated_protocol_vo.to_dict(), 'test_disable_protocol')
ProtocolInfo(updated_protocol_vo)
self.assertIsInstance(updated_protocol_vo, Protocol)
self.assertEqual(updated_protocol_vo.protocol_id, protocol_vo.protocol_id)
self.assertEqual('DISABLED', updated_protocol_vo.state)
def test_create_user_channel_secret(self, *args):
protocol_vo = ProtocolFactory(domain_id=self.domain_id)
protocol_id = protocol_vo.protocol_id
params = {
'name': 'Test User Channel',
'protocol_id': protocol_id,
'user_id': 'bluese05',
'data': {
'phone_number': '0107772222'
},
'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'
user_ch_svc = UserChannelService(transaction=self.transaction)
user_ch_vo = user_ch_svc.create(params.copy())
print_data(user_ch_vo.to_dict(), 'test_create_project_channel')
UserChannelInfo(user_ch_vo)
self.assertIsInstance(user_ch_vo, UserChannel)
self.assertEqual(params['name'], user_ch_vo.name)
self.assertEqual(True, user_ch_vo.is_scheduled)
self.assertEqual(False, user_ch_vo.is_subscribe)
self.assertEqual(None, user_ch_vo.secret_id)
self.assertEqual({'phone_number': '0107772222'}, user_ch_vo.data)
self.assertEqual(params['schedule']['day_of_week'],
user_ch_vo.schedule.day_of_week)
self.assertEqual(params['schedule']['start_hour'],
user_ch_vo.schedule.start_hour)
self.assertEqual(params['tags'], user_ch_vo.tags)
self.assertEqual(params['domain_id'], user_ch_vo.domain_id)
def test_create_notification_with_project_channel(self, *args):
protocol_vo = ProtocolFactory(domain_id=self.domain_id)
project_channel_vo = ProjectChannelFactory(
domain_id=self.domain_id, protocol_id=protocol_vo.protocol_id)
params = {
'resource_type': 'identity.Project',
'resource_id': project_channel_vo.project_id,
'topic': 'topic-a',
'message': {
'message': 'TEST..'
},
'notification_type': 'ERROR',
'notification_level': 'LV1',
'domain_id': self.domain_id,
}
self.transaction.method = 'create'
notification_svc = NotificationService(transaction=self.transaction)
notification_svc.create(params.copy())
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': {
'supported_resource_type': ['inventory.Server'],
'supported_stat': ['AVERAGE', 'MAX', 'MIN'],
'required_keys': ['reference.resource_id']
}
}
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_stat_protocol_distinct(self, *args):
protocol_vos = ProtocolFactory.build_batch(10, domain_id=self.domain_id)
list(map(lambda vo: vo.save(), protocol_vos))
params = {
'domain_id': self.domain_id,
'query': {
'distinct': 'protocol_id',
'page': {
'start': 2,
'limit': 3
}
}
}
self.transaction.method = 'stat'
protocol_svc = ProtocolService(transaction=self.transaction)
values = protocol_svc.stat(params)
StatisticsInfo(values)
print_data(values, 'test_stat_protocol_distinct')
def test_update_protocol(self, *args):
protocol_vo = ProtocolFactory(domain_id=self.domain_id)
params = {
'protocol_id': protocol_vo.protocol_id,
'name': 'Update New Protocol',
'tags': {
'update_key': 'update_value'
},
'domain_id': self.domain_id
}
self.transaction.method = 'update'
protocol_svc = ProtocolService(transaction=self.transaction)
update_protocol_vo = protocol_svc.update(params.copy())
print_data(update_protocol_vo.to_dict(), 'test_update_protocol')
ProtocolInfo(update_protocol_vo)
self.assertIsInstance(update_protocol_vo, Protocol)
self.assertEqual(update_protocol_vo.protocol_id, protocol_vo.protocol_id)
self.assertEqual(params['name'], update_protocol_vo.name)
self.assertEqual(params['tags'], update_protocol_vo.tags)
