def test_delete_flow_dns_exception_with_retry(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()
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_create_flow_normal(self):
providers = ['cdn_provider']
kwargs = {
'providers_list_json':
json.dumps(providers),
'project_id':
json.dumps(str(uuid.uuid4())),
'auth_token':
json.dumps(str(uuid.uuid4())),
'service_id':
json.dumps(str(uuid.uuid4())),
'time_seconds':
[i * self.time_factor for i in range(self.total_retries)],
'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_create_flow(service_controller, storage_controller,
dns_controller)
engines.run(create_service.create_service(), store=kwargs)
def test_create_flow_dns_exception_with_retry_and_fail(self, mock_creds):
providers = ['cdn_provider']
kwargs = {
'providers_list_json': json.dumps(providers),
'project_id': json.dumps(str(uuid.uuid4())),
'auth_token': json.dumps(str(uuid.uuid4())),
'service_id': json.dumps(str(uuid.uuid4())),
'time_seconds': [i * self.time_factor for
i in range(self.total_retries)],
'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_create_flow(service_controller, storage_controller,
dns_controller)
dns_controller.create = mock.Mock()
dns_responder_returns = self.dns_exceptions_only()
dns_controller.create._mock_side_effect = (dns_responder for
dns_responder in
dns_responder_returns)
engines.run(create_service.create_service(), store=kwargs)
def test_create_flow_dns_exception(self, mock_creds, mock_dns_client):
providers = ['cdn_provider']
kwargs = {
'providers_list_json':
json.dumps(providers),
'project_id':
json.dumps(str(uuid.uuid4())),
'auth_token':
json.dumps(str(uuid.uuid4())),
'service_id':
json.dumps(str(uuid.uuid4())),
'time_seconds':
[i * self.time_factor for i in range(self.total_retries)]
}
service_controller, storage_controller, dns_controller = \
self.all_controllers()
with MonkeyPatchControllers(service_controller, dns_controller,
storage_controller,
memoized_controllers.task_controllers):
self.patch_create_flow(service_controller, storage_controller,
dns_controller)
dns_controller.create = mock.Mock()
dns_controller.create._mock_return_value = {
'cdn_provider': {
'error':
'Whoops!',
'error_class':
'tests.unit.distributed_task'
'.taskflow.test_flows.DNSException'
}
}
engines.run(create_service.create_service(), store=kwargs)
def test_delete_vm(self):
# create a few vms
new_instances = [
self.nova_client.servers.create(name="vm1",
image=self.valid_image,
flavor=self.flavor),
self.nova_client.servers.create(name="vm2",
image=self.valid_image,
flavor=self.flavor),
self.nova_client.servers.create(name="vm3",
image=self.valid_image,
flavor=self.flavor)
]
# delete one vm
vm_to_delete = new_instances.pop()
DeleteVmTests.task_store['server'] = str(vm_to_delete.id)
# start engine to run delete task
engines.run(self.flow, store=DeleteVmTests.task_store)
# verify vm has been deleted
vms = self.nova_client.servers.list()
vm_found = False
for vm in vms:
if vm.id == vm_to_delete.id:
vm_found = True
break
# cleanup
for vm in new_instances:
self.nova_client.servers.delete(vm)
self.assertFalse(vm_found, "VM was not deleted successfully")
def test_delete_vm_invalid_id(self):
# create a few vms
new_instances = [
self.nova_client.servers.create(name="vm1",
image=self.valid_image,
flavor=self.flavor),
self.nova_client.servers.create(name="vm2",
image=self.valid_image,
flavor=self.flavor),
self.nova_client.servers.create(name="vm3",
image=self.valid_image,
flavor=self.flavor)
]
# delete non-existing vm (invalid id)
DeleteVmTests.task_store['server'] = str(uuid.uuid4())
# start engine to run delete task
engines.run(self.flow, store=DeleteVmTests.task_store)
# verify our existing vms have not been deleted
vms = self.nova_client.servers.list()
found = 0
for vm in vms:
for created_vm in new_instances:
if vm.id == created_vm.id:
found += 1
# cleanup
for vm in new_instances:
self.nova_client.servers.delete(vm)
self.assertEqual(len(new_instances), found, "Not all VMs were found")
def test_delete_ssl_certificate_normal(self):
providers = ['cdn_provider']
cert_obj = ssl_certificate.SSLCertificate(
'cdn',
'mytestsite.com',
'san',
)
kwargs = {
'cert_type': "san",
'project_id': json.dumps(str(uuid.uuid4())),
'domain_name': "mytestsite.com",
'cert_obj': json.dumps(cert_obj.to_dict()),
'providers_list': json.dumps(providers),
'flavor_id': "premium",
'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_ssl_certificate_flow(service_controller,
storage_controller,
dns_controller,
ssl_cert_controller)
engines.run(delete_ssl_certificate.delete_ssl_certificate(),
store=kwargs)
def test_create_flow_normal(self, mock_creds, mock_dns_client):
providers = ['cdn_provider']
kwargs = {
'providers_list_json':
json.dumps(providers),
'project_id':
json.dumps(str(uuid.uuid4())),
'auth_token':
json.dumps(str(uuid.uuid4())),
'service_id':
json.dumps(str(uuid.uuid4())),
'time_seconds':
[i * self.time_factor for i in range(self.total_retries)]
}
service_controller, storage_controller, dns_controller = \
self.all_controllers()
with MonkeyPatchControllers(service_controller, dns_controller,
storage_controller,
memoized_controllers.task_controllers):
self.patch_create_flow(service_controller, storage_controller,
dns_controller)
engines.run(create_service.create_service(), store=kwargs)
def test_service_state_flow_normal(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())),
'state': 'enable',
'service_obj': json.dumps(service_obj.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_service_state_flow(service_controller,
storage_controller,
dns_controller)
engines.run(update_service_state.enable_service(), store=kwargs)
engines.run(update_service_state.disable_service(), store=kwargs)
def test_create_flow_dns_exception(self, mock_creds,
mock_dns_client):
providers = ['cdn_provider']
kwargs = {
'providers_list_json': json.dumps(providers),
'project_id': json.dumps(str(uuid.uuid4())),
'auth_token': json.dumps(str(uuid.uuid4())),
'service_id': json.dumps(str(uuid.uuid4())),
'time_seconds': [i * self.time_factor for
i in range(self.total_retries)],
'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_create_flow(service_controller, storage_controller,
dns_controller)
dns_controller.create = mock.Mock()
dns_controller.create._mock_return_value = {
'cdn_provider': {
'error': 'Whoops!',
'error_class': 'tests.unit.distributed_task'
'.taskflow.test_flows.DNSException'
}
}
engines.run(create_service.create_service(), store=kwargs)
def test_delete_flow_normal(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)
engines.run(delete_service.delete_service(), store=kwargs)
def test_create_ssl_certificate_normal(self):
providers = ['cdn_provider']
cert_obj_json = ssl_certificate.SSLCertificate('cdn',
'mytestsite.com',
'san')
kwargs = {
'providers_list_json': json.dumps(providers),
'project_id': json.dumps(str(uuid.uuid4())),
'cert_obj_json': json.dumps(cert_obj_json.to_dict()),
'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_create_ssl_certificate_flow(service_controller,
storage_controller,
dns_controller)
engines.run(create_ssl_certificate.create_ssl_certificate(),
store=kwargs)
def test_create_port(self):
# retrieve neutron client API class
neutron_client = client.neutron_client()
# set an existing network_id and unique name to use
network_name = "private"
networks = neutron_client.list_networks(name=network_name)
network = networks['networks'][0]
CreatePortTests.task_store['network_id'] = network['id']
CreatePortTests.task_store['port_name'] = "port_" + str(uuid.uuid4())
# create flow with "CreatePort" task, given neutron client
flow = linear_flow.Flow('create port').add(
neutron_task.CreatePort(os_client=neutron_client,
provides='neutron_port_id'))
# execute flow with parameters required for "CreatePort" task
engines.run(flow, store=CreatePortTests.task_store)
# retrieve list of ports from Neutron service
port_list = neutron_client.list_ports()
# find our newly created port
found = False
for port in port_list['ports']:
if port['network_id'] == CreatePortTests.task_store['network_id']:
if port['name'] == CreatePortTests.task_store['port_name']:
found = True
break
self.assertTrue(found, "New port was not found")
def test_delete_flow_dns_exception(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_controller.delete._mock_return_value = {
"cdn_provider": {
"error": "Whoops!",
"error_class": "tests.unit.distributed_task" ".taskflow.test_flows.DNSException",
}
}
engines.run(delete_service.delete_service(), store=kwargs)
def test_delete_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),
'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)
engines.run(delete_service.delete_service(), store=kwargs)
def test_service_state_flow_normal(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())),
"state": "enable",
"service_obj": json.dumps(service_obj.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_service_state_flow(service_controller, storage_controller, dns_controller)
engines.run(update_service_state.enable_service(), store=kwargs)
engines.run(update_service_state.disable_service(), store=kwargs)
def test_create_flow_dns_exception(self, mock_creds):
providers = ["cdn_provider"]
kwargs = {
"providers_list_json": json.dumps(providers),
"project_id": json.dumps(str(uuid.uuid4())),
"auth_token": json.dumps(str(uuid.uuid4())),
"service_id": json.dumps(str(uuid.uuid4())),
"time_seconds": [i * self.time_factor for i in range(self.total_retries)],
}
service_controller, storage_controller, dns_controller = self.all_controllers()
with MonkeyPatchControllers(
service_controller, dns_controller, storage_controller, memoized_controllers.task_controllers
):
self.patch_create_flow(service_controller, storage_controller, dns_controller)
dns_controller.create = mock.Mock()
dns_controller.create._mock_return_value = {
"cdn_provider": {
"error": "Whoops!",
"error_class": "tests.unit.distributed_task" ".taskflow.test_flows.DNSException",
}
}
engines.run(create_service.create_service(), store=kwargs)
def test_purge_flow_normal(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),
"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()),
}
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_recreate_ssl_certificate(self, mock_creds, mock_dns_client):
providers = ['cdn_provider']
cert_obj_json = ssl_certificate.SSLCertificate('cdn',
'mytestsite.com',
'san')
kwargs = {
'providers_list_json': json.dumps(providers),
'project_id': json.dumps(str(uuid.uuid4())),
'domain_name': 'mytestsite.com',
'cert_type': 'san',
'cert_obj_json': json.dumps(cert_obj_json.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_recreate_ssl_certificate_flow(service_controller,
storage_controller,
dns_controller)
engines.run(recreate_ssl_certificate.recreate_ssl_certificate(),
store=kwargs)
def test_create_flow_normal(self):
providers = ['cdn_provider']
kwargs = {
'providers_list_json': json.dumps(providers),
'project_id': json.dumps(str(uuid.uuid4())),
'auth_token': json.dumps(str(uuid.uuid4())),
'service_id': json.dumps(str(uuid.uuid4())),
'time_seconds': [i * self.time_factor
for i in range(self.total_retries)],
'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_create_flow(service_controller,
storage_controller,
dns_controller)
engines.run(create_service.create_service(), store=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_existing_port_single(self):
# create port
body_value = {
"port": {
"admin_state_up": True,
"name": "test port",
"network_id": self.valid_network['id'],
}
}
port_info = self.neutron_client.create_port(body=body_value)
port_id = port_info['port']['id']
# populate task_store with port-id of port created for this test
task_store = {'port_ids': port_id}
# retrieve port list prior to delete
pre_port_list = self.neutron_client.list_ports()
# search for created port in port list
self.assertTrue(_find_port(port_id, pre_port_list),
"port-id %s not found in neutron port list" % port_id)
engines.run(self.flow, store=task_store)
# retrieve port list after delete
post_port_list = self.neutron_client.list_ports()
# search for deleted port in port list
self.assertFalse(
_find_port(port_id, post_port_list),
"port-id %s found in neutron port after "
"delete" % port_id)
def test_exceptions(self):
def bad1(wrapper, s):
bad2(wrapper)
def bad2(wrapper):
bad3(wrapper.field)
def bad3(tag):
raise IOError("this is an exception on %s!" % tag)
# With one entry in the feed, one exception should be raised, and it
# should bubble up as normal.
feed = [mock.Mock(spec=lpar.LPAR, field='lpar1')]
ft = tx.FeedTask('ft', feed).add_functor_subtask(bad1, 'this is bad')
flow = tf_uf.Flow('the flow')
flow.add(ft)
self.assertRaises(IOError, tf_eng.run, flow)
# With multiple entries in the feed, TaskFlow will wrap the exceptions
# in a WrappedFailure. We should repackage it, and the message in the
# resulting MultipleExceptionsInFeedTask should contain all the
# exception messages.
feed.append(mock.Mock(spec=lpar.LPAR, field='lpar2'))
ft = tx.FeedTask('ft', feed).add_functor_subtask(bad1, 'this is bad')
flow = tf_uf.Flow('the flow')
flow.add(ft)
with self.assertRaises(ex.MultipleExceptionsInFeedTask) as mult_ex:
tf_eng.run(flow)
# Make sure the wrapped exception messages show up in the exception.
self.assertIn('exception on lpar1!', mult_ex.exception.args[0])
self.assertIn('exception on lpar2!', mult_ex.exception.args[0])
def test_create_flow_dns_exception_with_retry_and_fail(self):
providers = ['cdn_provider']
kwargs = {
'providers_list_json':
json.dumps(providers),
'project_id':
json.dumps(str(uuid.uuid4())),
'auth_token':
json.dumps(str(uuid.uuid4())),
'service_id':
json.dumps(str(uuid.uuid4())),
'time_seconds':
[i * self.time_factor for i in range(self.total_retries)],
'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_create_flow(service_controller, storage_controller,
dns_controller)
dns_controller.create = mock.Mock()
dns_responder_returns = self.dns_exceptions_only()
dns_controller.create._mock_side_effect = (
dns_responder for dns_responder in dns_responder_returns)
engines.run(create_service.create_service(), store=kwargs)
def test_delete_ssl_certificate_normal(self):
kwargs = {
'cert_type': "san",
'project_id': json.dumps(str(uuid.uuid4())),
'domain_name': "san.san.com",
'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_create_ssl_certificate_flow(
service_controller,
storage_controller,
dns_controller
)
engines.run(
delete_ssl_certificate.delete_ssl_certificate(),
store=kwargs
)
def test_recreate_ssl_certificate(self):
providers = ['cdn_provider']
cert_obj_json = ssl_certificate.SSLCertificate('cdn', 'mytestsite.com',
'san')
kwargs = {
'providers_list_json': json.dumps(providers),
'project_id': json.dumps(str(uuid.uuid4())),
'domain_name': 'mytestsite.com',
'cert_type': 'san',
'cert_obj_json': json.dumps(cert_obj_json.to_dict()),
'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_recreate_ssl_certificate_flow(service_controller,
storage_controller,
dns_controller)
engines.run(recreate_ssl_certificate.recreate_ssl_certificate(),
store=kwargs)
def test_service_state_flow_dns_exception(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')
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,
ssl_cert_controller) = self.all_controllers()
with MonkeyPatchControllers(service_controller, dns_controller,
storage_controller, ssl_cert_controller,
memoized_controllers.task_controllers):
self.patch_service_state_flow(service_controller,
storage_controller, dns_controller)
dns_controller.enable = mock.Mock()
dns_controller.enable._mock_return_value = {
'cdn_provider': {
'error':
'Whoops!',
'error_class':
'tests.unit.distributed_task'
'.taskflow.test_flows.DNSException'
}
}
dns_controller.disable = mock.Mock()
dns_controller.disable._mock_return_value = {
'cdn_provider': {
'error':
'Whoops!',
'error_class':
'tests.unit.distributed_task'
'.taskflow.test_flows.DNSException'
}
}
engines.run(update_service_state.enable_service(),
store=enable_kwargs)
engines.run(update_service_state.disable_service(),
store=disable_kwargs)
def test_delete_stack(self):
heat_client = mock.MagicMock(name='heat_client')
stack_id = 'stack_id'
flow_store = {'stack_id': stack_id}
flow = self._get_delete_stack_flow(heat_client)
engines.run(flow, store=flow_store)
heat_client.stacks.delete.assert_called_once_with(stack_id)
def test_service_state_flow_dns_exception(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')
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,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller,
dns_controller,
storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers):
self.patch_service_state_flow(service_controller,
storage_controller,
dns_controller)
dns_controller.enable = mock.Mock()
dns_controller.enable._mock_return_value = {
'cdn_provider': {
'error': 'Whoops!',
'error_class': 'tests.unit.distributed_task'
'.taskflow.test_flows.DNSException'
}
}
dns_controller.disable = mock.Mock()
dns_controller.disable._mock_return_value = {
'cdn_provider': {
'error': 'Whoops!',
'error_class': 'tests.unit.distributed_task'
'.taskflow.test_flows.DNSException'
}
}
engines.run(update_service_state.enable_service(),
store=enable_kwargs)
engines.run(update_service_state.disable_service(),
store=disable_kwargs)
def test_create_cluster_max_retries_multi_node_single_retry(self):
flow_store = {
"tenant_id": str(self.valid_network['tenant_id']),
"image": self.valid_image.id,
"flavor": self.valid_flavor.id,
"port": self.port,
"context": self.context.to_dict(),
"erlang_cookie": str(uuid.uuid4()),
"default_rabbit_user": '******',
"default_rabbit_pass": str(uuid.uuid4()),
}
cluster_values = {
"project_id": self.context.tenant_id,
"name": "RabbitCluster",
"network_id": self.valid_network['id'],
"flavor": "1",
"size": 3,
}
new_cluster = objects.Cluster(**cluster_values)
new_cluster.create(self.context)
nodes = objects.Node.get_nodes_by_cluster_id(self.context,
new_cluster.id)
# Todo: Raise the retry count once the fixture timeout issue
# is resolved
CONF.flow_options.create_cluster_node_vm_active_retry_count = 1
# configure custom vm_status list
nova.VmStatusDetails.set_vm_status(['BUILD',
'BUILD',
'BUILD',
'BUILD'])
node_ids = []
for node in nodes:
node_ids.append(node.id)
flow = create_cluster(new_cluster.id,
node_ids,
self.valid_network['id'],
self.management_network['id'])
try:
engines.run(flow, store=flow_store)
except taskflow_exc.WrappedFailure as err:
self.assertEqual(3, len(err._causes))
exc_list = set(type(c.exception) for c in err._causes)
self.assertEqual({cue_exceptions.VmBuildingException,
cue_exceptions.VmBuildingException,
cue_exceptions.VmBuildingException},
exc_list)
except Exception as e:
self.assertEqual(taskflow_exc.WrappedFailure, type(e))
else:
self.fail("Expected taskflow_exc.WrappedFailure exception.")
def test_check_cert_status_and_update_flow(self):
kwargs = {
'domain_name': "blog.testabc.com",
'cert_type': "san",
'flavor_id': "premium",
'project_id': "000"
}
engines.run(check_cert_status_and_update_flow.
check_cert_status_and_update_flow(),
store=kwargs)
def test_check_cert_status_and_update_flow(self):
kwargs = {
'domain_name': "blog.testabc.com",
'cert_type': "san",
'flavor_id': "premium",
'project_id': "000"
}
engines.run(check_cert_status_and_update_flow.
check_cert_status_and_update_flow(),
store=kwargs)
def test_update_flow_dns_exception(self, mock_creds, mock_dns_client):
service_id = str(uuid.uuid4())
domains_old = domain.Domain(domain='cdn.poppy.org')
domains_new = domain.Domain(domain='mycdn.poppy.org')
current_origin = origin.Origin(origin='poppy.org')
service_old = service.Service(service_id=service_id,
name='poppy cdn service',
domains=[domains_old],
origins=[current_origin],
flavor_id='cdn')
service_new = service.Service(service_id=service_id,
name='poppy cdn service',
domains=[domains_new],
origins=[current_origin],
flavor_id='cdn')
kwargs = {
'project_id':
json.dumps(str(uuid.uuid4())),
'auth_token':
json.dumps(str(uuid.uuid4())),
'service_id':
json.dumps(service_id),
'time_seconds':
[i * self.time_factor for i in range(self.total_retries)],
'service_old':
json.dumps(service_old.to_dict()),
'service_obj':
json.dumps(service_new.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_update_flow(service_controller, storage_controller,
dns_controller)
dns_controller.update = mock.Mock()
dns_controller.update._mock_return_value = {
'cdn_provider': {
'error':
'Whoops!',
'error_class':
'tests.unit.distributed_task'
'.taskflow.test_flows.DNSException'
}
}
engines.run(update_service.update_service(), store=kwargs)
def test_get_rabbit_cluster_status(self):
"""Verifies GetRabbitClusterStatus task."""
urllib2_fixture.Urllib2ResultDetails.set_urllib2_result([
'{"status": "ok"}', '{"status": "clustering"}', '[{"name": "/"}]'
])
self.flow = linear_flow.Flow(name="wait for RabbitMQ ready state").add(
get_rabbit_cluster_status.GetRabbitClusterStatus(
name="get RabbitMQ status"))
# start engine
engines.run(self.flow, store=GetRabbitClusterStatusTest.task_store)
def test_service_state_flow_dns_exception_retry_and_succeed(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')
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,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller,
dns_controller,
storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers):
self.patch_service_state_flow(service_controller,
storage_controller,
dns_controller)
dns_responder_returns = self.dns_exceptions_and_succeed()
dns_controller.enable._mock_side_effect = (dns_responder for
dns_responder in
dns_responder_returns)
dns_controller.disable._mock_side_effect = (dns_responder for
dns_responder in
dns_responder_returns)
engines.run(update_service_state.enable_service(),
store=enable_kwargs)
engines.run(update_service_state.disable_service(),
store=disable_kwargs)
def test_delete_flow_dns_exception(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)
service_mock = mock.Mock()
type(service_mock).domains = []
storage_controller.get_service.return_value = service_mock
dns_controller.delete = mock.Mock()
dns_controller.delete._mock_return_value = {
'cdn_provider': {
'error': 'Whoops!',
'error_class': 'tests.unit.distributed_task'
'.taskflow.test_flows.DNSException'
}
}
engines.run(delete_service.delete_service(), store=kwargs)
def test_update_flow_dns_exception_with_retry_and_fail(self):
service_id = str(uuid.uuid4())
domains_old = domain.Domain(domain='cdn.poppy.org')
domains_new = domain.Domain(domain='mycdn.poppy.org')
current_origin = origin.Origin(origin='poppy.org')
service_old = service.Service(service_id=service_id,
name='poppy cdn service',
domains=[domains_old],
origins=[current_origin],
flavor_id='cdn')
service_new = service.Service(service_id=service_id,
name='poppy cdn service',
domains=[domains_new],
origins=[current_origin],
flavor_id='cdn')
kwargs = {
'project_id': json.dumps(str(uuid.uuid4())),
'auth_token': json.dumps(str(uuid.uuid4())),
'service_id': json.dumps(service_id),
'time_seconds': [i * self.time_factor for
i in range(self.total_retries)],
'service_old': json.dumps(service_old.to_dict()),
'service_obj': json.dumps(service_new.to_dict()),
'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_update_flow(service_controller, storage_controller,
dns_controller)
dns_controller.update = mock.Mock()
dns_responder_returns = self.dns_exceptions_only()
dns_controller.update._mock_side_effect = (dns_responder for
dns_responder in
dns_responder_returns)
engines.run(update_service.update_service(), store=kwargs)
def test_get_rabbit_cluster_status_fail(self):
"""Verifies unsuccessful path.
This test simulates when the RMQ vm is not responding to the
urllib2.open calls on the RMQ management port.
"""
urllib2_fixture.Urllib2ResultDetails.set_urllib2_result(['{}', '[]'])
self.flow = linear_flow.Flow(name="wait for RabbitMQ ready state").add(
get_rabbit_cluster_status.GetRabbitClusterStatus(
name="get RabbitMQ status"))
# start engine
engines.run(self.flow, store=GetRabbitClusterStatusTest.task_store)
def test_update_flow_dns_exception_with_retry_and_succeed(
self, mock_creds):
service_id = str(uuid.uuid4())
domains_old = domain.Domain(domain='cdn.poppy.org')
domains_new = domain.Domain(domain='mycdn.poppy.org')
current_origin = origin.Origin(origin='poppy.org')
service_old = service.Service(service_id=service_id,
name='poppy cdn service',
domains=[domains_old],
origins=[current_origin],
flavor_id='cdn')
service_new = service.Service(service_id=service_id,
name='poppy cdn service',
domains=[domains_new],
origins=[current_origin],
flavor_id='cdn')
kwargs = {
'project_id':
json.dumps(str(uuid.uuid4())),
'auth_token':
json.dumps(str(uuid.uuid4())),
'service_id':
json.dumps(service_id),
'time_seconds':
[i * self.time_factor for i in range(self.total_retries)],
'service_old':
json.dumps(service_old.to_dict()),
'service_obj':
json.dumps(service_new.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_update_flow(service_controller, storage_controller,
dns_controller)
dns_controller.update = mock.Mock()
dns_responder_returns = self.dns_exceptions_and_succeed()
dns_controller.update._mock_side_effect = (
dns_responder for dns_responder in dns_responder_returns)
engines.run(update_service.update_service(), store=kwargs)
def test_delete_flow_dns_exception(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)
service_mock = mock.Mock()
type(service_mock).domains = []
storage_controller.get_service.return_value = service_mock
dns_controller.delete = mock.Mock()
dns_controller.delete._mock_return_value = {
'cdn_provider': {
'error':
'Whoops!',
'error_class':
'tests.unit.distributed_task'
'.taskflow.test_flows.DNSException'
}
}
engines.run(delete_service.delete_service(), store=kwargs)
def test_get_rabbit_cluster_status_connection_failed(self):
"""Verifies GetRabbitClusterStatus task."""
urllib2_fixture.Urllib2ResultDetails.set_urllib2_result(['URLError'])
self.flow = linear_flow.Flow(name="wait for RabbitMQ ready state").add(
get_rabbit_cluster_status.GetRabbitClusterStatus(
name="get RabbitMQ status"))
try:
# start engine
engines.run(self.flow, store=GetRabbitClusterStatusTest.task_store)
except urllib.error.URLError:
# Expected
pass
def test_create_cluster_invalid_user_network(self):
invalid_network_id = str(uuid.uuid4())
cluster_size = 3
flow_store = {
"tenant_id": str(self.valid_network['tenant_id']),
'image': self.valid_image.id,
'flavor': self.valid_flavor.id,
"port": self.port,
"context": self.context.to_dict(),
"erlang_cookie": str(uuid.uuid4()),
"default_rabbit_user": '******',
"default_rabbit_pass": str(uuid.uuid4()),
}
cluster_values = {
"project_id": self.context.tenant_id,
"name": "RabbitCluster",
"network_id": invalid_network_id,
"flavor": "1",
"size": cluster_size,
}
new_cluster = objects.Cluster(**cluster_values)
new_cluster.create(self.context)
nodes = objects.Node.get_nodes_by_cluster_id(self.context,
new_cluster.id)
node_ids = []
for node in nodes:
node_ids.append(node.id)
flow = create_cluster(new_cluster.id,
node_ids,
invalid_network_id,
self.management_network['id'])
try:
engines.run(flow, store=flow_store)
except neutron_exceptions.NeutronClientException as err:
# When an incorrect user network ID is given, the neutron client
# returns a NeutronClientException.
self.assertEqual(err.message,
"Network " + str(invalid_network_id) +
" could not be found.")
else:
self.fail("Expected taskflow_exc.WrappedFailure exception.")
def test_update_flow_dns_exception(self, mock_creds,
mock_dns_client):
service_id = str(uuid.uuid4())
domains_old = domain.Domain(domain='cdn.poppy.org')
domains_new = domain.Domain(domain='mycdn.poppy.org')
current_origin = origin.Origin(origin='poppy.org')
service_old = service.Service(service_id=service_id,
name='poppy cdn service',
domains=[domains_old],
origins=[current_origin],
flavor_id='cdn')
service_new = service.Service(service_id=service_id,
name='poppy cdn service',
domains=[domains_new],
origins=[current_origin],
flavor_id='cdn')
kwargs = {
'project_id': json.dumps(str(uuid.uuid4())),
'auth_token': json.dumps(str(uuid.uuid4())),
'service_id': json.dumps(service_id),
'time_seconds': [i * self.time_factor for
i in range(self.total_retries)],
'service_old': json.dumps(service_old.to_dict()),
'service_obj': json.dumps(service_new.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_update_flow(service_controller, storage_controller,
dns_controller)
dns_controller.update = mock.Mock()
dns_controller.update._mock_return_value = {
'cdn_provider': {
'error': 'Whoops!',
'error_class': 'tests.unit.distributed_task'
'.taskflow.test_flows.DNSException'
}
}
engines.run(update_service.update_service(), store=kwargs)
def test_create_cluster_anti_affinity(self):
self.flags(cluster_node_anti_affinity=True, group="taskflow")
flow_store = {
"tenant_id": str(self.valid_network['tenant_id']),
'image': self.valid_image.id,
'flavor': self.valid_flavor.id,
"port": self.port,
"context": self.context.to_dict(),
"erlang_cookie": str(uuid.uuid4()),
"default_rabbit_user": '******',
"default_rabbit_pass": str(uuid.uuid4()),
}
cluster_values = {
"project_id": self.context.tenant_id,
"name": "RabbitCluster",
"network_id": str(uuid.uuid4()),
"flavor": "1",
"size": 3,
}
new_cluster = objects.Cluster(**cluster_values)
new_cluster.create(self.context)
nodes = objects.Node.get_nodes_by_cluster_id(self.context,
new_cluster.id)
node_ids = []
for node in nodes:
node_ids.append(node.id)
flow = create_cluster(new_cluster.id,
node_ids,
self.valid_network['id'],
self.management_network['id'])
engines.run(flow, store=flow_store)
nodes_after = objects.Node.get_nodes_by_cluster_id(self.context,
new_cluster.id)
# check if the host_ids are different for cluster nodes
host_ids = []
for node in nodes_after:
host_id = self.nova_client.servers.get(node.instance_id).host_id
self.assertNotIn(host_id, host_ids)
host_ids.append(host_id)
def test_get_vm_status_task(self):
"""Verifies GetVMStatus task directly."""
# create flow with "GetVmStatus" task
self.flow = linear_flow.Flow('get vm status').add(
get_vm_status.GetVmStatus(os_client=self.nova_client,
provides='vm_status'))
# create a vm
new_instance = self.nova_client.servers.create(name="vm1",
image=self.image,
flavor=self.flavor)
# set vm_id variable in TaskFlow's data store required for task
GetVmStatusTests.task_store['nova_vm_id'] = new_instance.id
# start engine to run task
result = engines.run(self.flow, store=GetVmStatusTests.task_store)
# verify vm_status key is present in result dictionary
if 'vm_status' not in result:
self.fail("Expected vm_status is was not returned by GetVmStatus "
"task.")
# cleanup
self.nova_client.servers.delete(new_instance)
def test_update_stack(self):
heat_client = mock.MagicMock(name='heat_client')
stack_id = 'stack_id'
flow_store = {
'stack_id': stack_id,
'parameters': 'parameters',
'template': 'template',
'files': 'files'
}
flow = self._get_update_stack_flow(heat_client)
expected_params = dict(flow_store)
del expected_params['stack_id']
engines.run(flow, store=flow_store)
heat_client.stacks.update.assert_called_once_with(stack_id,
**expected_params)
def test_update_papi_flow(self):
kwargs = {
"property_spec": "akamai_https_san_config_numbers",
"update_type": "hostnames",
"update_info_list": json.dumps([
(
"add",
{
"cnameFrome": "blog.testabc.com",
"cnameTo": 'secure2.san1.test_cdn.com',
"cnameType": "EDGE_HOSTNAME"
}
)])
}
engines.run(update_property_flow.update_property_flow(),
store=kwargs)
def test_get_valid_vm(self):
flow_store = {'server': self.valid_vm_id}
result = engines.run(self.flow, store=flow_store)
new_vm = result['vm_info']
self.assertEqual(self.valid_vm_id, new_vm['id'])
self.assertEqual(self.valid_vm_name, new_vm['name'])
def test_service_state_flow_dns_exception_retry_and_succeed(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')
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,
ssl_cert_controller) = self.all_controllers()
with MonkeyPatchControllers(service_controller, dns_controller,
storage_controller, ssl_cert_controller,
memoized_controllers.task_controllers):
self.patch_service_state_flow(service_controller,
storage_controller, dns_controller)
dns_responder_returns = self.dns_exceptions_and_succeed()
dns_controller.enable._mock_side_effect = (
dns_responder for dns_responder in dns_responder_returns)
dns_controller.disable._mock_side_effect = (
dns_responder for dns_responder in dns_responder_returns)
engines.run(update_service_state.enable_service(),
store=enable_kwargs)
engines.run(update_service_state.disable_service(),
store=disable_kwargs)
def test_update_papi_flow(self):
kwargs = {
"property_spec": "akamai_https_san_config_numbers",
"update_type": "hostnames",
"update_info_list": json.dumps(
[
(
"add",
{
"cnameFrome": "blog.testabc.com",
"cnameTo": "secure2.san1.test_cdn.com",
"cnameType": "EDGE_HOSTNAME",
},
)
]
),
}
engines.run(update_property_flow.update_property_flow(), store=kwargs)
def test_create_flow_normal(self, mock_creds):
providers = ["cdn_provider"]
kwargs = {
"providers_list_json": json.dumps(providers),
"project_id": json.dumps(str(uuid.uuid4())),
"auth_token": json.dumps(str(uuid.uuid4())),
"service_id": json.dumps(str(uuid.uuid4())),
"time_seconds": [i * self.time_factor for i in range(self.total_retries)],
}
service_controller, storage_controller, dns_controller = self.all_controllers()
with MonkeyPatchControllers(
service_controller, dns_controller, storage_controller, memoized_controllers.task_controllers
):
self.patch_create_flow(service_controller, storage_controller, dns_controller)
engines.run(create_service.create_service(), store=kwargs)
def test_check_cert_status_and_update_flow(self):
cert_obj_json = json.dumps(
ssl_certificate.SSLCertificate(
'cdn',
'website.com',
'san',
cert_details={
'Akamai': {
'extra_info': {
'san cert': 'secure1.san1.testcdn.com'
}
}
}).to_dict())
kwargs = {'cert_obj_json': cert_obj_json, 'project_id': "000"}
engines.run(check_cert_status_and_update_flow.
check_cert_status_and_update_flow(),
store=kwargs)
def test_delete_flow_dns_exception_with_retry_and_succeed(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()])),
'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_delete_flow(service_controller, storage_controller,
dns_controller)
dns_controller.delete = mock.Mock()
dns_responder_returns = self.dns_exceptions_and_succeed()
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_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_create_flow_normal(self, mock_creds, mock_dns_client):
providers = ['cdn_provider']
kwargs = {
'providers_list_json': json.dumps(providers),
'project_id': json.dumps(str(uuid.uuid4())),
'auth_token': json.dumps(str(uuid.uuid4())),
'service_id': json.dumps(str(uuid.uuid4())),
'time_seconds': [i * self.time_factor
for i in range(self.total_retries)]
}
service_controller, storage_controller, dns_controller = \
self.all_controllers()
with MonkeyPatchControllers(service_controller,
dns_controller,
storage_controller,
memoized_controllers.task_controllers):
self.patch_create_flow(service_controller,
storage_controller,
dns_controller)
engines.run(create_service.create_service(), store=kwargs)
def test_check_cert_status_and_update_flow(self):
cert_obj_json = json.dumps(
ssl_certificate.SSLCertificate(
'cdn',
'website.com',
'san',
cert_details={
'Akamai': {
'extra_info': {
'san cert': 'secure1.san1.testcdn.com'
}
}
}
).to_dict()
)
kwargs = {
'cert_obj_json': cert_obj_json,
'project_id': "000"
}
engines.run(check_cert_status_and_update_flow.
check_cert_status_and_update_flow(),
store=kwargs)
def test_update_flow_normal(self, mock_creds):
service_id = str(uuid.uuid4())
domains_old = domain.Domain(domain='cdn.poppy.org')
domains_new = domain.Domain(domain='mycdn.poppy.org')
current_origin = origin.Origin(origin='poppy.org')
service_old = service.Service(service_id=service_id,
name='poppy cdn service',
domains=[domains_old],
origins=[current_origin],
flavor_id='cdn')
service_new = service.Service(service_id=service_id,
name='poppy cdn service',
domains=[domains_new],
origins=[current_origin],
flavor_id='cdn')
kwargs = {
'project_id': json.dumps(str(uuid.uuid4())),
'auth_token': json.dumps(str(uuid.uuid4())),
'service_id': json.dumps(service_id),
'time_seconds': [i * self.time_factor
for i in range(self.total_retries)],
'service_old': json.dumps(service_old.to_dict()),
'service_obj': json.dumps(service_new.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_update_flow(service_controller, storage_controller,
dns_controller)
engines.run(update_service.update_service(), store=kwargs)
def test_update_flow_normal(self, mock_creds):
service_id = str(uuid.uuid4())
domains_old = domain.Domain(domain="cdn.poppy.org")
domains_new = domain.Domain(domain="mycdn.poppy.org")
current_origin = origin.Origin(origin="poppy.org")
service_old = service.Service(
service_id=service_id,
name="poppy cdn service",
domains=[domains_old],
origins=[current_origin],
flavor_id="cdn",
)
service_new = service.Service(
service_id=service_id,
name="poppy cdn service",
domains=[domains_new],
origins=[current_origin],
flavor_id="cdn",
)
kwargs = {
"project_id": json.dumps(str(uuid.uuid4())),
"auth_token": json.dumps(str(uuid.uuid4())),
"service_id": json.dumps(service_id),
"time_seconds": [i * self.time_factor for i in range(self.total_retries)],
"service_old": json.dumps(service_old.to_dict()),
"service_obj": json.dumps(service_new.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_update_flow(service_controller, storage_controller, dns_controller)
engines.run(update_service.update_service(), store=kwargs)
