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_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_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_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)