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)