def test_purge_with_exception(self):
provider_service_id = uuid.uuid1()
controller = services.ServiceController(self.driver)
exception = fastly.FastlyError(Exception('ding'))
controller.client.purge_service.side_effect = exception
resp = controller.purge(provider_service_id, hard=True, purge_url='/*')
self.assertIn('error', resp[self.driver.provider_name])
def test_delete(self, mock_connection, mock_service, mock_client,
mock_driver):
driver = mock_driver()
driver.provider_name = 'Fastly'
service_name = 'whatsitnamed'
# instantiate
controller = services.ServiceController(driver)
# mock.patch return values
service = mock_service()
service.id = '1234'
controller.client.get_service_by_name.return_value = service
# test exception
exception = fastly.FastlyError(Exception('ding'))
controller.client.delete_service.side_effect = exception
resp = controller.delete('wrongname')
self.assertIn('error', resp[driver.provider_name])
# clear run
controller.client.reset_mock()
controller.client.delete_service.side_effect = None
resp = controller.delete(service_name)
controller.client.get_service_by_name.assert_called_once_with(
service_name)
controller.client.delete_service.assert_called_once_with(service.id)
self.assertIn('domain', resp[driver.provider_name])
def test_delete_with_exception(self):
provider_service_id = uuid.uuid1()
# instantiate
controller = services.ServiceController(self.driver)
# mock.patch return values
service = self.mock_service()
service.id = uuid.uuid1()
controller.client.get_service_by_name.return_value = service
# test exception
controller.client.delete_service.side_effect = None
service_id = str(uuid.uuid4())
current_domain = str(uuid.uuid1())
domains_old = domain.Domain(domain=current_domain)
current_origin = origin.Origin(origin='poppy.org')
service_obj = Service(service_id=service_id,
name='poppy cdn service',
domains=[domains_old],
origins=[current_origin],
flavor_id='cdn',
project_id=str(uuid.uuid4()))
exception = fastly.FastlyError(Exception('ding'))
controller.client.delete_service.side_effect = exception
resp = controller.delete(service_obj, provider_service_id)
self.assertIn('error', resp[self.driver.provider_name])
def test_create_with_create_service_exception(self, service_json):
# ASSERTIONS
# create_service
service_obj = service.load_from_json(service_json)
self.controller.client.create_service.side_effect = fastly.FastlyError(
Exception('Creating service failed.'))
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_create_with_activate_version_exception(self, service_json):
self.controller.client.reset_mock()
self.controller.client.create_backend.side_effect = None
service_obj = service.load_from_json(service_json)
self.controller.client.active_version.side_effect = fastly.FastlyError(
Exception('Active_version failed.'))
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_update_fastly_exception(self, service_json):
provider_service_id = uuid.uuid1()
controller = services.ServiceController(self.driver)
controller.client.list_versions.return_value = [self.version]
controller.client.get_service_details.side_effect = (
fastly.FastlyError('Mock -- Fastly error!'))
service_obj = service.load_from_json(service_json)
resp = controller.update(provider_service_id, service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_create_with_create_backend_exception(self, service_json):
self.controller.client.reset_mock()
self.controller.client.create_domain.side_effect = None
service_obj = service.load_from_json(service_json)
# create backends
self.controller.client.create_backend.side_effect = fastly.FastlyError(
Exception('Creating backend failed.'))
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_delete_with_exception(self):
provider_service_id = uuid.uuid1()
# instantiate
controller = services.ServiceController(self.driver)
# mock.patch return values
service = self.mock_service()
service.id = uuid.uuid1()
controller.client.get_service_by_name.return_value = service
# test exception
exception = fastly.FastlyError(Exception('ding'))
controller.client.delete_service.side_effect = exception
resp = controller.delete(provider_service_id)
self.assertIn('error', resp[self.driver.provider_name])
def test_create(self, service_json, mock_connection, mock_service,
mock_version, mock_controllerclient, mock_driver):
driver = mock_driver()
driver.provider_name = 'Fastly'
# instantiate
controller = services.ServiceController(driver)
service_name = 'scarborough'
mock_service_id = '%020x' % random.randrange(16**20)
mock_create_version_resp = {
u'service_id': mock_service_id,
u'number': 5
}
service = mock_service()
service.id = mock_service_id
version = mock_version(controller.client, mock_create_version_resp)
controller.client.create_service.return_value = service
controller.client.create_version.return_value = version
# ASSERTIONS
# create_service
controller.client.create_service.side_effect = fastly.FastlyError(
Exception('Creating service failed.'))
resp = controller.create(service_name, service_json)
self.assertIn('error', resp[driver.provider_name])
controller.client.reset_mock()
controller.client.create_service.side_effect = None
# create_version
controller.client.create_version.side_effect = fastly.FastlyError(
Exception('Creating version failed.'))
resp = controller.create(service_name, service_json)
self.assertIn('error', resp[driver.provider_name])
controller.client.reset_mock()
controller.client.create_version.side_effect = None
# create domains
controller.client.create_domain.side_effect = fastly.FastlyError(
Exception('Creating domains failed.'))
resp = controller.create(service_name, service_json)
self.assertIn('error', resp[driver.provider_name])
controller.client.reset_mock()
controller.client.create_domain.side_effect = None
# create backends
controller.client.create_backend.side_effect = fastly.FastlyError(
Exception('Creating backend failed.'))
resp = controller.create(service_name, service_json)
self.assertIn('error', resp[driver.provider_name])
controller.client.reset_mock()
controller.client.create_backend.side_effect = None
# test a general exception
controller.client.create_service.side_effect = Exception(
'Wild exception occurred.')
resp = controller.create(service_name, service_json)
self.assertIn('error', resp[driver.provider_name])
# finally, a clear run
controller.client.reset_mock()
controller.client.create_service.side_effect = None
resp = controller.create(service_name, service_json)
controller.client.create_service.assert_called_once_with(
controller.current_customer.id, service_name)
controller.client.create_version.assert_called_once_with(service.id)
controller.client.create_domain.assert_any_call(
service.id, version.number, service_json['domains'][0]['domain'])
controller.client.create_domain.assert_any_call(
service.id, version.number, service_json['domains'][1]['domain'])
controller.client.create_backend.assert_has_any_call(
service.id, 1, service_json['origins'][0]['origin'],
service_json['origins'][0]['origin'],
service_json['origins'][0]['ssl'],
service_json['origins'][0]['port'])
self.assertIn('domain', resp[driver.provider_name])
def test_get_service_details_error(self):
error = fastly.FastlyError('DIMMM')
self.controller.client.get_service_by_name.side_effect = error
resp = self.controller.get('rror-service')
self.assertIn('error', resp[self.driver.provider_name])
