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