def test_service_state_flow_normal(self, mock_creds, mock_dns_client): service_id = str(uuid.uuid4()) domains_old = domain.Domain(domain='cdn.poppy.org') current_origin = origin.Origin(origin='poppy.org') service_obj = service.Service(service_id=service_id, name='poppy cdn service', domains=[domains_old], origins=[current_origin], flavor_id='cdn') enable_kwargs = { 'project_id': json.dumps(str(uuid.uuid4())), 'state': 'enable', 'service_obj': json.dumps(service_obj.to_dict()), 'time_seconds': [i * self.time_factor for i in range(self.total_retries)], 'context_dict': context_utils.RequestContext().to_dict() } disable_kwargs = enable_kwargs.copy() disable_kwargs['state'] = 'disable' service_controller, storage_controller, dns_controller = \ self.all_controllers() with MonkeyPatchControllers(service_controller, dns_controller, storage_controller, memoized_controllers.task_controllers): self.patch_service_state_flow(service_controller, storage_controller, dns_controller) engines.run(update_service_state.enable_service(), store=enable_kwargs) engines.run(update_service_state.disable_service(), store=disable_kwargs)
def test_purge_flow_normal(self, mock_creds, mock_dns_client): service_id = str(uuid.uuid4()) domains_old = domain.Domain(domain='cdn.poppy.org') current_origin = origin.Origin(origin='poppy.org') service_obj = service.Service(service_id=service_id, name='poppy cdn service', domains=[domains_old], origins=[current_origin], flavor_id='cdn') kwargs = { 'project_id': json.dumps(str(uuid.uuid4())), 'service_id': json.dumps(service_id), 'provider_details': json.dumps( dict([(k, v.to_dict()) for k, v in service_obj.provider_details.items()])), 'purge_url': 'cdn.poppy.org', 'hard': json.dumps(True), 'service_obj': json.dumps(service_obj.to_dict()), 'context_dict': context_utils.RequestContext().to_dict() } service_controller, storage_controller, dns_controller = \ self.all_controllers() with MonkeyPatchControllers(service_controller, dns_controller, storage_controller, memoized_controllers.task_controllers): self.patch_purge_flow(service_controller, storage_controller, dns_controller) engines.run(purge_service.purge_service(), store=kwargs)
def test_delete_flow_dns_exception_with_retry_and_fail(self, mock_creds): service_id = str(uuid.uuid4()) domains_old = domain.Domain(domain='cdn.poppy.org') current_origin = origin.Origin(origin='poppy.org') service_obj = service.Service(service_id=service_id, name='poppy cdn service', domains=[domains_old], origins=[current_origin], flavor_id='cdn') kwargs = { 'project_id': json.dumps(str(uuid.uuid4())), 'service_id': json.dumps(service_id), 'time_seconds': [i * self.time_factor for i in range(self.total_retries)], 'provider_details': json.dumps( dict([(k, v.to_dict()) for k, v in service_obj.provider_details.items()])) } service_controller, storage_controller, dns_controller = \ self.all_controllers() with MonkeyPatchControllers(service_controller, dns_controller, storage_controller, memoized_controllers.task_controllers): self.patch_delete_flow(service_controller, storage_controller, dns_controller) dns_controller.delete = mock.Mock() dns_responder_returns = self.dns_exceptions_only() dns_controller.delete._mock_side_effect = ( dns_responder for dns_responder in dns_responder_returns) engines.run(delete_service.delete_service(), store=kwargs)
def test_delete_with_exception(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': str(uuid.uuid1()), 'protocol': 'http', 'certificate': None }]) # test exception exception = RuntimeError('ding') self.controller.policy_api_client.delete.side_effect = exception resp = self.controller.delete(service_obj, provider_service_id) self.assertIn('error', resp[self.driver.provider_name])
def test_delete_flow_normal(self): service_id = str(uuid.uuid4()) domains_old = domain.Domain(domain='cdn.poppy.org') current_origin = origin.Origin(origin='poppy.org') service_obj = service.Service(service_id=service_id, name='poppy cdn service', domains=[domains_old], origins=[current_origin], flavor_id='cdn') kwargs = { 'project_id': json.dumps(str(uuid.uuid4())), 'service_id': json.dumps(service_id), 'time_seconds': [i * self.time_factor for i in range(self.total_retries)], 'provider_details': json.dumps( dict([(k, v.to_dict()) for k, v in service_obj.provider_details.items()])), 'context_dict': context_utils.RequestContext().to_dict() } (service_controller, storage_controller, dns_controller, ssl_cert_controller) = self.all_controllers() with MonkeyPatchControllers(service_controller, dns_controller, storage_controller, ssl_cert_controller, memoized_controllers.task_controllers): self.patch_delete_flow(service_controller, storage_controller, dns_controller) storage_controller.get_service = mock.Mock( return_value=service_obj) engines.run(delete_service.delete_service(), store=kwargs)
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_delete_failed(self, mock_controllerclient, mock_driver): # test create with exceptions mock_response = mock.MagicMock() mock_response.text = 'Mock -- something went wrong!' mock_dict = {u'code': 500} mock_response.__getitem__.side_effect = mock_dict.__getitem__ driver = mock_driver() driver.attach_mock(mock_controllerclient, 'client') driver.client.configure_mock(**{'delete.return_value': mock_response}) controller = services.ServiceController(driver) service_name = 'test_service_name' 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())) resp = controller.delete(service_obj, service_name) self.assertIn('error', resp[driver.provider_name])
def get_service_details_by_domain_name(self, domain_name, project_id=None): r = service.Service(str(uuid.uuid4()), str(uuid.uuid4()), [domain.Domain('wiki.cc', 'https', 'shared')], [origin.Origin('mysite.com')], "strawberry") r.provider_details = MockProviderDetails(r.service_id) return r
def format_result(result): """format_result. :param result :returns formatted result """ service_id = result.get('service_id') project_id = result.get('project_id') name = result.get('service_name') flavor_id = result.get('flavor_id') origins = [json.loads(o) for o in result.get('origins', []) or []] domains = [json.loads(d) for d in result.get('domains', []) or []] restrictions = [ json.loads(r) for r in result.get('restrictions', []) or [] ] caching_rules = [ json.loads(c) for c in result.get('caching_rules', []) or [] ] log_delivery = json.loads(result.get('log_delivery', '{}') or '{}') operator_status = result.get('operator_status', 'enabled') # create models for each item origins = [ origin.Origin(o['origin'], o.get('hostheadertype', 'domain'), o.get('hostheadervalue', None), o.get('port', 80), o.get('ssl', False), [ rule.Rule(rule_i.get('name'), request_url=rule_i.get('request_url')) for rule_i in o.get('rules', []) ]) for o in origins ] domains = [ domain.Domain(d['domain'], d.get('protocol', 'http'), d.get('certificate', None)) for d in domains ] restrictions = [ restriction.Restriction(r.get('name'), r.get( 'access', 'whitelist'), [ rule.Rule(r_rule.get('name'), referrer=r_rule.get('referrer'), client_ip=r_rule.get('client_ip'), geography=r_rule.get('geography'), request_url=r_rule.get('request_url', "/*") or "/*") for r_rule in r['rules'] ]) for r in restrictions ] caching_rules = [ cachingrule.CachingRule( caching_rule.get('name'), caching_rule.get('ttl'), [ rule.Rule(rule_i.get('name'), request_url=rule_i.get('request_url', '/*') or '/*') for rule_i in caching_rule['rules'] ]) for caching_rule in caching_rules ] log_delivery = ld.LogDelivery(log_delivery.get('enabled', False)) # create the service object s = service.Service(service_id=service_id, name=name, domains=domains, origins=origins, flavor_id=flavor_id, caching=caching_rules, restrictions=restrictions, log_delivery=log_delivery, operator_status=operator_status, project_id=project_id) # format the provider details provider_detail_results = result.get('provider_details') or {} provider_details_dict = {} for provider_name in provider_detail_results: provider_detail_dict = json.loads( provider_detail_results[provider_name]) provider_service_id = provider_detail_dict.get('id', None) access_urls = provider_detail_dict.get('access_urls', []) status = provider_detail_dict.get('status', u'unknown') domains_certificate_status = (provider_detail_dict.get( 'domains_certificate_status', {})) error_message = provider_detail_dict.get('error_message', None) provider_detail_obj = provider_details.ProviderDetail( provider_service_id=provider_service_id, access_urls=access_urls, domains_certificate_status=domains_certificate_status, status=status, error_message=error_message) provider_details_dict[provider_name] = provider_detail_obj s.provider_details = provider_details_dict # return the service return s