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