def test_update(self, service_json):
provider_service_id = uuid.uuid1()
controller = services.ServiceController(self.driver)
controller.client.list_versions.return_value = [self.version]
service_obj = service.load_from_json(service_json)
resp = controller.update(provider_service_id, service_obj)
self.assertIn('id', resp[self.driver.provider_name])
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 setUp(
self,
mock_driver,
mock_controllerclient,
mock_version,
mock_service,
mock_connection
):
super(TestServices, self).setUp()
self.driver = mock_driver()
self.driver.provider_name = 'Fastly'
self.driver.regions = []
self.mock_service = mock_service
self.mock_version = mock_version
self.service_name = 'scarborough'
mock_service_id = '%020x' % random.randrange(16 ** 20)
self.mock_create_version_resp = {
u'service_id': mock_service_id, u'number': 5}
self.service_instance = self.mock_service()
self.service_instance.id = mock_service_id
self.controller = services.ServiceController(self.driver)
self.version = self.mock_version(
self.controller.client,
self.mock_create_version_resp)
self.version.number = self.mock_create_version_resp.get('number')
self.controller.client.create_service.return_value = (
self.service_instance)
self.controller.client.create_version.return_value = self.version
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_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_get_provider_service_id(self):
driver = mock.Mock()
controller = services.ServiceController(driver)
mock_service = mock.Mock()
mock_service.service_id = uuid.uuid4()
self.assertEqual(mock_service.service_id,
controller.get_provider_service_id(mock_service))
def test_update(self, mock_get_client, mock_driver, service_json):
service_name = 'whatsitnamed'
driver = mock_driver()
controller = services.ServiceController(driver)
resp = controller.update(service_name, service_json)
self.assertIn('domain', resp[driver.provider_name])
def test_purge_all(self):
provider_service_id = uuid.uuid1()
controller = services.ServiceController(self.driver)
controller.client.purge_service.return_value = 'some_value'
resp = controller.purge(provider_service_id, hard=True, purge_url='/*')
controller.client.purge_service.assert_called_once_with(
provider_service_id)
self.assertIn('id', resp[self.driver.provider_name])
def test_update_general_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 = (
Exception('Mock -- Something went wrong!'))
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_purge_partial(self):
provider_service_id = uuid.uuid1()
controller = services.ServiceController(self.driver)
controller.client.purge_service.return_value = 'some_value'
controller.client.list_domains.return_value = [
mock.Mock(name='domain_1'),
mock.Mock(name='domain_2')]
controller.client.purge_url.return_value = 'purge_url_return'
resp = controller.purge(provider_service_id, ['/url_1', '/url_2'])
self.assertIn('id', resp[self.driver.provider_name])
def test_create_with_no_restriction(self, service_json):
# instantiate
# this case needs to set all return value for each call
service_obj = service.load_from_json(service_json)
controller = services.ServiceController(self.driver)
controller.client.create_service.return_value = self.service_instance
controller.client.create_version.return_value = self.version
controller.client.list_versions.return_value = [self.version]
controller.client.active_version.return_value = self.version
fastly_fake_domain_check = type(
'FastlyDomain', (object,), {
'name': 'fake_domain.global.prod.fastly.net'})
controller.client.check_domains.return_value = [
mock.Mock(domain=fastly_fake_domain_check)
]
resp = controller.create(service_obj)
controller.client.create_service.assert_called_once_with(
controller.current_customer.id, service_obj.name)
controller.client.create_version.assert_called_once_with(
self.service_instance.id)
controller.client.create_domain.assert_any_call(
self.service_instance.id,
self.version.number,
service_obj.domains[0].domain)
controller.client.create_domain.assert_any_call(
self.service_instance.id,
self.version.number,
service_obj.domains[1].domain)
controller.client.check_domains.assert_called_once_with(
self.service_instance.id, self.version.number)
self.assertEqual(False, controller.client.create_condition.called)
self.assertEqual(False,
controller.client.create_response_object.called)
controller.client.create_backend.assert_any_call(
self.service_instance.id,
self.version.number,
service_obj.origins[0].origin.replace(":", "-"),
service_obj.origins[0].origin,
service_obj.origins[0].ssl,
service_obj.origins[0].port)
self.assertIn('links', resp[self.driver.provider_name])
def test_delete(self):
provider_service_id = uuid.uuid1()
# instantiate
controller = services.ServiceController(self.driver)
# clear run
controller.client.delete_service.side_effect = None
resp = controller.delete(provider_service_id)
controller.client.delete_service.assert_called_once_with(
provider_service_id)
self.assertIn('id', resp[self.driver.provider_name])
def setUp(self, mock_driver, mock_client):
super(TestProviderValidation, self).setUp()
self.driver = mock_driver()
self.controller = services.ServiceController(self.driver)
self.client = mock_client
self.service_name = uuid.uuid1()
service_json = {"name": "mocksite.com",
"domains": [{"domain": "parsely.sage.com"}],
"origins": [{"origin": "mockdomain.com",
"ssl": False, "port": 80}],
"flavor_id": "standard"}
service_obj = service.load_from_json(service_json)
self.controller.create(service_obj)
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_delete(self):
provider_service_id = uuid.uuid1()
# instantiate
controller = services.ServiceController(self.driver)
# clear run
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()))
resp = controller.delete(service_obj, provider_service_id)
controller.client.delete_service.assert_called_once_with(
provider_service_id)
self.assertIn('id', resp[self.driver.provider_name])
def test_regions(self):
driver = mock.Mock()
driver.regions = []
controller = services.ServiceController(driver)
self.assertEqual(controller.driver.regions, [])
def test_get_metrics_by_domain(self):
driver = mock.Mock()
controller = services.ServiceController(driver)
self.assertEqual([],
controller.get_metrics_by_domain(
'project_id', 'domain_name', []))
def test_client(self):
controller = services.ServiceController(self.driver)
self.assertNotEqual(controller.client(), None)
def test_client(self, mock_driver):
driver = mock_driver()
controller = services.ServiceController(driver)
self.assertNotEquals(controller.client(), None)
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_create(self, service_json):
# instantiate
# this case needs to set all return value for each call
service_obj = service.load_from_json(service_json)
controller = services.ServiceController(self.driver)
controller.client.create_service.return_value = self.service_instance
controller.client.create_version.return_value = self.version
controller.client.list_versions.return_value = [self.version]
controller.client.active_version.return_value = self.version
fastly_fake_domain_check = type(
'FastlyDomain', (object, ),
{'name': 'fake_domain.global.prod.fastly.net'})
controller.client.check_domains.return_value = [
mock.Mock(domain=fastly_fake_domain_check)
]
resp = controller.create(service_obj)
controller.client.create_service.assert_called_once_with(
controller.current_customer.id, service_obj.name)
controller.client.create_version.assert_called_once_with(
self.service_instance.id)
controller.client.create_domain.assert_any_call(
self.service_instance.id, self.version.number,
service_obj.domains[0].domain)
controller.client.create_domain.assert_any_call(
self.service_instance.id, self.version.number,
service_obj.domains[1].domain)
controller.client.check_domains.assert_called_once_with(
self.service_instance.id, self.version.number)
referrer_resctriction_list = [
rule.http_host for restriction in service_obj.restrictions
for rule in restriction.rules
]
# referrer assert
host_pattern_stament = ' || '.join([
'request.http.referer'
' !~ %s' % host for host in referrer_resctriction_list
])
condition_stmt = ('req.http.referer && (%s)' % host_pattern_stament)
controller.client.create_condition.assert_has_any_call(
self.service_instance.id,
1,
'Referrer Restriction Matching Rules',
fastly.FastlyConditionType.REQUEST,
condition_stmt,
priority=10)
controller.client.create_response_object.assert_has_any_call()
# cache rule asset
# create condition first
for caching_rule in service_obj.caching:
if caching_rule.name.lower() == 'default':
controller.client.update_settings.assert_called_once_with(
self.service_instance.id, self.version.number,
{'general.default_ttl': caching_rule.ttl})
else:
controller.client.create_cache_settings.assert_has_any_call()
controller.client.create_backend.assert_has_any_call(
self.service_instance.id, 1,
service_obj.origins[0].origin.replace(":", "-"),
service_obj.origins[0].origin, service_obj.origins[0].ssl,
service_obj.origins[0].port)
self.assertIn('links', resp[self.driver.provider_name])
