def test_process_origin_rule(self): controller = services.ServiceController(self.driver) rule_entry = rule.Rule('index', request_url='*.jpg') origin_rule = origin.Origin(origin='poppy.com', rules=[rule_entry]) rules_list = [{ 'matches': [{ 'name': 'url-wildcard', 'value': u'/*' }], 'behaviors': [{ 'params': { 'hostHeaderValue': '-', 'cacheKeyType': 'digital_property', 'cacheKeyValue': '-', 'originDomain': 'www.mydomain.com', 'hostHeaderType': 'digital_property' }, 'name': 'origin', 'value': '-' }] }] controller._process_new_origin(origin_rule, rules_list) origin_rule_valid = False for origin_rule in rules_list: matches = origin_rule['matches'] for match in matches: if match['value'] == u'/*.jpg': origin_rule_valid = True break self.assertTrue(origin_rule_valid)
def test_purge_with_service_id_json_load_error(self): provider_service_id = None controller = services.ServiceController(self.driver) resp = controller.purge(provider_service_id, service_obj=self.service_obj, hard=True, purge_url=None) self.assertIn('error', resp[self.driver.provider_name])
def test_upsert(self, service_json): provider_service_id = json.dumps([{'policy_name': "densely.sage.com", 'protocol': 'http', 'certificate': None}]) controller = services.ServiceController(self.driver) controller.subcustomer_api_client.get.return_value = \ mock.Mock(status_code=200, ok=True, content=json.dumps({"geo": "US"})) controller.subcustomer_api_client.delete.return_value = \ mock.Mock(status_code=200, ok=True) controller.policy_api_client.get.return_value = mock.Mock( status_code=404, text='Service not found' ) controller.policy_api_client.put.return_value = mock.Mock( status_code=200, text='Put successful' ) service_obj = service.load_from_json(service_json) resp = controller.update( provider_service_id, service_obj) self.assertIn('id', resp[self.driver.provider_name])
def test_update_with_get_error(self, service_json): provider_service_id = json.dumps([{'policy_name': str(uuid.uuid1()), 'protocol': 'http'}]) controller = services.ServiceController(self.driver) controller.subcustomer_api_client.get.return_value = \ mock.Mock(status_code=200, ok=True, content=json.dumps({"geo": "US"})) controller.subcustomer_api_client.delete.return_value = \ mock.Mock(status_code=200, ok=True) controller.policy_api_client.get.return_value = mock.Mock( status_code=400, text='Some get error happened' ) controller.policy_api_client.put.return_value = mock.Mock( status_code=200, text='Put successful' ) controller.policy_api_client.delete.return_value = mock.Mock( status_code=200, text='Delete successful' ) service_obj = service.load_from_json(service_json) resp = controller.update( provider_service_id, service_obj) self.assertIn('error', resp[self.driver.provider_name])
def test_purge(self): provider_service_id = json.dumps([{'policy_name': str(uuid.uuid1()), 'protocol': 'https', 'certificate': 'shared'}]) controller = services.ServiceController(self.driver) controller.ccu_api_client.post.return_value = mock.Mock( status_code=201, text="purge request post complete" ) purge_url = '/img/abc.jpeg' actual_purge_url = ("https://" + json.loads(provider_service_id)[0]['policy_name'] + purge_url) data = { 'objects': [ actual_purge_url ] } resp = controller.purge(provider_service_id, service_obj=self.service_obj, hard=True, purge_url=purge_url) controller.ccu_api_client.post.assert_called_once_with( controller.ccu_api_base_url, data=json.dumps(data), headers=( controller.request_header )) self.assertIn('id', resp[self.driver.provider_name])
def test_cache_invalidate(self): provider_service_id = json.dumps([{'policy_name': str(uuid.uuid1()), 'protocol': 'https', 'certificate': 'shared'}]) controller = services.ServiceController(self.driver) controller.subcustomer_api_client.get.return_value = \ mock.Mock(status_code=200, ok=True, content=json.dumps({"geo": "US"})) controller.subcustomer_api_client.delete.return_value = \ mock.Mock(status_code=200, ok=True) controller.policy_api_client.get.return_value = mock.Mock( status_code=200, text=json.dumps(dict(rules=[])) ) controller.policy_api_client.put.return_value = mock.Mock( status_code=200, text='Put successful' ) controller.policy_api_client.delete.return_value = mock.Mock( status_code=200, text='Delete successful' ) purge_url = '/img/abc.jpeg' resp = controller.purge(provider_service_id, service_obj=self.service_obj, hard=False, purge_url=purge_url) self.assertIn('id', resp[self.driver.provider_name])
def setUp(self): super(TestServices, self).setUp() driver_patcher = mock.patch('poppy.provider.akamai.driver.CDNProvider') mock_driver = driver_patcher.start() self.addCleanup(driver_patcher.stop) self.driver = mock_driver() self.policy_client = self.driver.policy_api_client self.ccu_client = self.driver.ccu_api_client self.driver.provider_name = 'Akamai' self.driver.http_conf_number = 1 self.driver.akamai_https_access_url_suffix = str(uuid.uuid1()) self.san_cert_cnames = [str(x) for x in range(7)] self.driver.san_cert_cnames = self.san_cert_cnames self.driver.regions = geo_zone_code_mapping.REGIONS self.driver.metrics_resolution = 86400 self.controller = services.ServiceController(self.driver) service_id = str(uuid.uuid4()) domains_old = domain.Domain(domain='cdn.poppy.org') current_origin = origin.Origin(origin='poppy.org') self.service_obj = Service(service_id=service_id, name='poppy cdn service', domains=[domains_old], origins=[current_origin], flavor_id='cdn')
def test_update_create_new_sub_customer_new_policy(self, service_json): provider_service_id = json.dumps([{ 'policy_name': str(uuid.uuid1()), 'protocol': 'http', 'certificate': None }]) controller = services.ServiceController(self.driver) controller.subcustomer_api_client.get.side_effect = [ mock.Mock(status_code=400, ok=False, text='Error retrieving sub customer!'), mock.Mock(status_code=200, ok=True, content=json.dumps({"geo": "US"})), mock.Mock(status_code=200, ok=True, content=json.dumps({"geo": "US"})), mock.Mock(status_code=200, ok=True, content=json.dumps({"geo": "US"})) ] controller.subcustomer_api_client.delete.return_value = \ mock.Mock(status_code=200, ok=True) controller.policy_api_client.get.return_value = mock.Mock( status_code=200, text=json.dumps(dict(rules=[]))) controller.policy_api_client.put.return_value = mock.Mock( status_code=200, text='Put successful') controller.policy_api_client.delete.return_value = mock.Mock( status_code=200, text='Delete successful') service_obj = service.load_from_json(service_json) resp = controller.update(provider_service_id, service_obj) self.assertIn('id', resp[self.driver.provider_name])
def test_process_caching_rules(self): controller = services.ServiceController(self.driver) caching_rule_entry = rule.Rule('index', request_url='*.jpg') caching_rule = cachingrule.CachingRule('home', 600, rules=[caching_rule_entry]) caching_rules = [caching_rule] rules_list = [{ 'matches': [{ 'name': 'url-wildcard', 'value': u'/*' }], 'behaviors': [{ 'params': { 'hostHeaderValue': '-', 'cacheKeyType': 'digital_property', 'cacheKeyValue': '-', 'originDomain': 'www.mydomain.com', 'hostHeaderType': 'digital_property' }, 'name': 'origin', 'value': '-' }] }] controller._process_caching_rules(caching_rules, rules_list) caching_rule_valid = False for caching_rule in rules_list: matches = caching_rule['matches'] for match in matches: if match['value'] == u'/*.jpg': caching_rule_valid = True break self.assertTrue(caching_rule_valid)
def test_delete_with_service_id_json_load_error(self): # This should trigger a json.loads error service_id = str(uuid.uuid4()) current_domain = str(uuid.uuid1()) domains_old = domain.Domain(domain=current_domain) current_origin = origin.Origin(origin='poppy.org') service_obj = Service(service_id=service_id, name='poppy cdn service', domains=[domains_old], origins=[current_origin], flavor_id='cdn', project_id=str(uuid.uuid4())) provider_service_id = None controller = services.ServiceController(self.driver) controller.subcustomer_api_client.get.return_value = \ mock.Mock(status_code=200, ok=True, content=json.dumps({"geo": "US"})) controller.subcustomer_api_client.delete.return_value = \ mock.Mock(status_code=200, ok=True) controller.policy_api_client.get.return_value = mock.Mock( status_code=200, text='Get successful') controller.policy_api_client.put.return_value = mock.Mock( status_code=200, text='Put successful') controller.policy_api_client.delete.return_value = mock.Mock( status_code=200, text='Delete successful') resp = controller.delete(service_obj, provider_service_id) self.assertIn('error', resp[self.driver.provider_name])
def get_provider_service_id(self): controller = services.ServiceController(self.driver) provider_service_id = controller.get(self.service_obj) self.assertTrue(provider_service_id is not None) self.assertTrue(isinstance(provider_service_id, str)) for domain_obj in self.service_obj.domains: self.assertTrue(domain_obj.domain in provider_service_id)
def test_purge_all(self): provider_service_id = json.dumps([{'policy_name': str(uuid.uuid1()), 'protocol': 'http', 'certificate': None}]) controller = services.ServiceController(self.driver) resp = controller.purge(provider_service_id, service_obj=self.service_obj, hard=True, purge_url=None) self.assertIn('error', resp[self.driver.provider_name])
def test_purge_with_ccu_exception(self): provider_service_id = json.dumps([{'policy_name': str(uuid.uuid1()), 'protocol': 'http', 'certificate': None}]) controller = services.ServiceController(self.driver) controller.ccu_api_client.post.return_value = mock.Mock( status_code=400, text="purge request post failed" ) resp = controller.purge(provider_service_id, service_obj=self.service_obj, hard=True, purge_url='/img/abc.jpeg') self.assertIn('error', resp[self.driver.provider_name])
def test_create(self, service_json): controller = services.ServiceController(self.driver) controller.subcustomer_api_client.get.return_value = \ mock.Mock(status_code=200, ok=True, content=json.dumps({"geo": "US"})) controller.policy_api_client.put.return_value = mock.Mock( status_code=200, text='Put successful') service_obj = service.load_from_json(service_json) resp = controller.create(service_obj) self.assertIn('id', resp[self.driver.provider_name])
def test_get_provider_service_id(self): controller = services.ServiceController(self.driver) expected_id = [] for service_domain in self.service_obj.domains: dp_obj = {'policy_name': service_domain.domain, 'protocol': service_domain.protocol, 'certificate': service_domain.certificate} expected_id.append(dp_obj) actual_id = controller.get_provider_service_id(self.service_obj) self.assertEqual(json.dumps(expected_id), actual_id)
def test_get_metrics_by_domain_metrics_controller_return(self, metrictype): controller = services.ServiceController(self.driver) project_id = str(uuid.uuid4()) domain_name = 'www.' + str(uuid.uuid4()) + '.com' regions = ['NorthAmerica', 'SouthAmerica', 'EMEA', 'Japan', 'India', 'APAC'] end_time = datetime.datetime.utcnow() start_time = (datetime.datetime.utcnow() - datetime.timedelta(days=1)) startTime = start_time.strftime("%Y-%m-%dT%H:%M:%S") endTime = end_time.strftime("%Y-%m-%dT%H:%M:%S") metrics_controller = mock.Mock() metric_buckets = [] if 'httpResponseCode' in metrictype: http_series = metrictype.split('_')[1] for region in regions: metric_buckets.append('_'.join(['httpResponseCode', http_series, domain_name, region])) else: for region in regions: metric_buckets.append('_'.join([metrictype, domain_name, region])) timestamp = str(int(time.time())) value = 55 metrics_response = [(metric_bucket, {timestamp: value}) for metric_bucket in metric_buckets] metrics_controller.read = mock.Mock(return_value=metrics_response) extras = { 'metricType': metrictype, 'startTime': startTime, 'endTime': endTime, 'metrics_controller': metrics_controller } formatted_results = controller.get_metrics_by_domain(project_id, domain_name, regions, **extras) self.assertEqual(formatted_results['domain'], domain_name) self.assertEqual(sorted(formatted_results[metrictype].keys()), sorted(regions)) for timestamp_counter in formatted_results[metrictype].values(): self.assertEqual(timestamp_counter[0][timestamp], value)
def test_cache_invalidate(self): provider_service_id = json.dumps([{ 'policy_name': str(uuid.uuid1()), 'protocol': 'https', 'certificate': 'shared' }]) controller = services.ServiceController(self.driver) controller.ccu_api_client.post.return_value = mock.Mock( status_code=201, text='Post succesful') purge_url = '/img/abc.jpeg' resp = controller.purge(provider_service_id, service_obj=self.service_obj, hard=False, purge_url=purge_url) self.assertIn('id', resp[self.driver.provider_name])
def setUp(self, mock_controller_policy_api_client, mock_controller_ccu_api_client, mock_driver): super(TestServices, self).setUp() self.driver = mock_driver() self.driver.akamai_https_access_url_suffix = str(uuid.uuid1()) self.san_cert_cnames = [str(x) for x in range(7)] self.driver.san_cert_cnames = self.san_cert_cnames self.controller = services.ServiceController(self.driver) service_id = str(uuid.uuid4()) domains_old = domain.Domain(domain='cdn.poppy.org') current_origin = origin.Origin(origin='poppy.org') self.service_obj = Service(service_id=service_id, name='poppy cdn service', domains=[domains_old], origins=[current_origin], flavor_id='cdn')
def test_update_with_domain_protocol_change(self, service_json): provider_service_id = json.dumps([{ 'policy_name': "densely.sage.com", 'protocol': 'http', 'certificate': None }]) controller = services.ServiceController(self.driver) controller.policy_api_client.get.return_value = mock.Mock( status_code=200, text=json.dumps(dict(rules=[]))) controller.policy_api_client.put.return_value = mock.Mock( status_code=200, text='Put successful') controller.policy_api_client.delete.return_value = mock.Mock( status_code=200, text='Delete successful') service_obj = service.load_from_json(service_json) resp = controller.update(provider_service_id, service_obj) self.assertIn('id', resp[self.driver.provider_name])
def test_get_metrics_by_domain_metrics_controller(self, metrictype): controller = services.ServiceController(self.driver) project_id = str(uuid.uuid4()) domain_name = 'www.' + str(uuid.uuid4()) + '.com' regions = controller.driver.regions end_time = datetime.datetime.utcnow() start_time = (datetime.datetime.utcnow() - datetime.timedelta(days=1)) startTime = start_time.strftime("%Y-%m-%dT%H:%M:%S") endTime = end_time.strftime("%Y-%m-%dT%H:%M:%S") metrics_controller = mock.Mock() # NOTE(TheSriram): We mock a empty return value, to just test # what the call args were for the metrics_controller metrics_controller.read = mock.Mock(return_value=[]) extras = { 'metricType': metrictype, 'startTime': startTime, 'endTime': endTime, 'metrics_controller': metrics_controller } controller.get_metrics_by_domain(project_id, domain_name, regions, **extras) call_args = metrics_controller.read.call_args[1] self.assertEqual(call_args['resolution'], self.driver.metrics_resolution) self.assertEqual(call_args['to_timestamp'], endTime) self.assertEqual(call_args['from_timestamp'], startTime) metric_names = call_args['metric_names'] for metric_name in metric_names: metric_split = metric_name.split('_') if len(metric_split) == 3: self.assertEqual(metric_split[0], metrictype) self.assertEqual(metric_split[1], domain_name) self.assertIn(metric_split[2], regions) else: self.assertEqual(metric_split[0], 'httpResponseCode') self.assertIn(metric_split[1], metrictype.split('_')[1]) self.assertEqual(metric_split[2], domain_name) self.assertIn(metric_split[3], regions)
def test_delete(self): service_id = str(uuid.uuid4()) current_domain = str(uuid.uuid1()) domains_old = domain.Domain(domain=current_domain) current_origin = origin.Origin(origin='poppy.org') service_obj = Service(service_id=service_id, name='poppy cdn service', domains=[domains_old], origins=[current_origin], flavor_id='cdn', project_id=str(uuid.uuid4())) provider_service_id = json.dumps([{'policy_name': current_domain, 'protocol': 'http', 'certificate': None}]) controller = services.ServiceController(self.driver) controller.subcustomer_api_client.get.return_value = \ mock.Mock(status_code=200, ok=True, content=json.dumps({"geo": "US"})) controller.subcustomer_api_client.delete.return_value = \ mock.Mock(status_code=200, ok=True) controller.policy_api_client.get.return_value = mock.Mock( status_code=200, text='Get successful' ) controller.policy_api_client.put.return_value = mock.Mock( status_code=200, text='Put successful' ) controller.policy_api_client.delete.return_value = mock.Mock( status_code=200, text='Delete successful' ) resp = controller.delete(service_obj, provider_service_id) self.assertIn('id', resp[self.driver.provider_name])
def test_process_restriction_rules(self): controller = services.ServiceController(self.driver) rule_entry = rule.Rule('index', request_url='*.jpg', referrer='www.poppy.com') restriction_rule = restriction.Restriction(name='restriction', rules=[rule_entry]) restriction_rules = [restriction_rule] rules_list = [{ 'matches': [{ 'name': 'url-wildcard', 'value': u'/*' }], 'behaviors': [{ 'params': { 'hostHeaderValue': '-', 'cacheKeyType': 'digital_property', 'cacheKeyValue': '-', 'originDomain': 'www.mydomain.com', 'hostHeaderType': 'digital_property' }, 'name': 'origin', 'value': '-' }] }] controller._process_restriction_rules(restriction_rules, rules_list) restriction_rule_valid = False for restriction_rule in rules_list: matches = restriction_rule['matches'] for match in matches: if match['value'] == u'/*.jpg': restriction_rule_valid = True break self.assertTrue(restriction_rule_valid)
def test_update_https_san_domains_with_cert_info(self, service_json): provider_service_id = [] for domain_obj in service_json.get('domains', []): provider_service_id.append( { 'policy_name': domain_obj['domain'], 'protocol': domain_obj.get('protocol', 'http'), 'certificate': domain_obj.get('certificate', None) } ) if len(provider_service_id) == 0: provider_service_id = [{'policy_name': str(uuid.uuid1()), 'protocol': 'http', 'certificate': None}] provider_service_id = json.dumps(provider_service_id) controller = services.ServiceController(self.driver) controller.subcustomer_api_client.get.side_effect = [ mock.Mock(status_code=400, ok=False, text='Error retrieving sub customer!'), mock.Mock(status_code=200, ok=True, content=json.dumps({"geo": "US"})), mock.Mock(status_code=200, ok=True, content=json.dumps({"geo": "US"})), mock.Mock(status_code=200, ok=True, content=json.dumps({"geo": "US"})) ] controller.subcustomer_api_client.delete.return_value = \ mock.Mock(status_code=200, ok=True) controller.policy_api_client.get.return_value = mock.Mock( status_code=200, text=json.dumps(dict(rules=[])) ) controller.policy_api_client.put.return_value = mock.Mock( status_code=200, text='Put successful' ) controller.policy_api_client.delete.return_value = mock.Mock( status_code=200, text='Delete successful' ) service_obj = service.load_from_json(service_json) san_domains = [] for curr_domain in service_obj.domains: if ( curr_domain.certificate in ['san', 'sni'] and curr_domain.protocol == 'https' ): cert_key = ( 'san cert' if curr_domain.certificate == 'san' else 'sni_cert' ) curr_domain.cert_info = ssl_certificate.SSLCertificate( 'flavor_id', curr_domain.domain, curr_domain.certificate, service_obj.project_id, cert_details={ 'Akamai': dict( cert_domain='1', extra_info={ 'status': 'deployed', cert_key: '1', 'created_at': str(datetime.datetime.now()) } ) } ) san_domains.append(curr_domain) resp = controller.update(provider_service_id, service_obj) self.assertIn('id', resp[self.driver.provider_name])
def test_regions(self): controller = services.ServiceController(self.driver) self.assertEqual(controller.driver.regions, geo_zone_code_mapping.REGIONS)
def test_create_ssl_certificate_negative_path( self, sps_status_workFlowProgress_tuple): sps_status, workFlowProgress = sps_status_workFlowProgress_tuple self.driver.san_cert_cnames = ["secure.san1.poppycdn.com"] controller = services.ServiceController(self.driver) data = { "cert_type": "san", "domain_name": "www.abc.com", "flavor_id": "premium" } lastSpsId = (controller.san_info_storage.get_cert_last_spsid( "secure.san1.poppycdn.com")) controller.san_info_storage.get_cert_info.return_value = { 'cnameHostname': "secure.san1.poppycdn.com", 'jobId': "secure.san1.poppycdn.com", 'issuer': 1789, 'createType': 'modSan', 'ipVersion': 'ipv4', 'slot-deployment.class': 'esslType' } cert_info = controller.san_info_storage.get_cert_info( "secure.san1.poppycdn.com") cert_info['add.sans'] = "www.abc.com" controller.sps_api_client.get.return_value = mock.Mock( status_code=200, # Mock an SPS request text=json.dumps({ "requestList": [{ "resourceUrl": "/config-secure-provisioning-service/" "v1/sps-requests/1849", "parameters": [{ "name": "cnameHostname", "value": "secure.san1.poppycdn.com" }, { "name": "createType", "value": "modSan" }, { "name": "csr.cn", "value": "secure.san3.poppycdn.com" }, { "name": "add.sans", "value": "www.abc.com" }], "lastStatusChange": "2015-03-19T21:47:10Z", "spsId": 1789, "status": sps_status, "workflowProgress": workFlowProgress, "jobId": 44306 }] })) controller.sps_api_client.post.return_value = mock.Mock( status_code=202, text=json.dumps({ "spsId": 1789, "resourceLocation": "/config-secure-provisioning-service/v1/sps-requests/1856", "Results": { "size": 1, "data": [{ "text": None, "results": { "type": "SUCCESS", "jobID": 44434 } }] } })) controller.create_certificate(ssl_certificate.load_from_json(data), False) controller.sps_api_client.get.assert_called_once_with( controller.sps_api_base_url.format(spsId=lastSpsId)) self.assertFalse(controller.sps_api_client.post.called) return
def test_get(self): controller = services.ServiceController(self.driver) self.assertIsNone(controller.get('service_name'))
def test_current_customer(self): controller = services.ServiceController(self.driver) self.assertIsNone(controller.current_customer)
def test_pick_san_edgename(self): controller = services.ServiceController(self.driver) picked_san_cert = controller._pick_san_edgename() picked_idx = (datetime.datetime.today().weekday() % len(self.san_cert_cnames)) self.assertTrue(picked_san_cert == self.san_cert_cnames[picked_idx])