def test_should_recover_from_latest_entry(self, mock_request): operation = uuid4() client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success( {'operation': operation}) query = 'test.*' definition = uuid4() destination = '/tmp/some/path/03' discard_paths = True self.assertEqual( client.recover_from_latest(definition=definition, path_query=query, destination=destination, discard_paths=discard_paths), { 'successful': True, 'operation': operation }) self.assert_valid_request( mock=mock_request, expected_method='put', expected_url='/operations/recover/{}/latest'.format(definition), expected_request_params={ 'query': query, 'destination': destination, 'keep_structure': not discard_paths })
def test_should_handle_requests_with_custom_tls_context( self, mock_request, mock_create_pem): path = '/tmp/some/path' password = '******' context = CustomHttpsContext(certificate_type='pkcs12', certificate_path=path, certificate_password=password) client = DefaultClientApi(api_url=self.url, api_token=self.token, context=context) mock_request.return_value = MockResponse.success(mock_data.PING) self.assertTrue(client.is_active()) mock_request.assert_called_once_with( method='get', url='{}{}'.format(self.url, '/service/ping'), params={}, headers={'Authorization': 'Bearer {}'.format(self.token)}, json={}, verify=context.verify) mock_create_pem.assert_called_once_with( pkcs12_certificate_path=path, pkcs12_certificate_password=password, pem_certificate_path='{}.as.pem'.format(path))
def test_should_handle_request_failures(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.failure( response='test failure') with self.assertRaises(Abort): client.operations()
def test_should_get_current_user(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success(mock_data.USER) self.assertEqual(client.user(), mock_data.USER) self.assert_valid_request(mock=mock_request, expected_method='get', expected_url='/user')
def test_should_get_dataset_definitions(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success(mock_data.DEFINITIONS) self.assertEqual(client.dataset_definitions(), mock_data.DEFINITIONS) self.assert_valid_request(mock=mock_request, expected_method='get', expected_url='/datasets/definitions')
def test_should_get_public_schedules(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success( mock_data.SCHEDULES_PUBLIC) self.assertEqual(client.schedules_public(), mock_data.SCHEDULES_PUBLIC) self.assert_valid_request(mock=mock_request, expected_method='get', expected_url='/schedules/public')
def test_should_get_backup_rules(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success( mock_data.BACKUP_RULES) self.assertEqual(client.backup_rules(), mock_data.BACKUP_RULES) self.assert_valid_request(mock=mock_request, expected_method='get', expected_url='/operations/backup/rules')
def test_should_get_active_operations(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success( mock_data.ACTIVE_OPERATIONS) self.assertEqual(client.operations(), mock_data.ACTIVE_OPERATIONS) self.assert_valid_request(mock=mock_request, expected_method='get', expected_url='/operations')
def test_should_get_dataset_metadata(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success(mock_data.METADATA) entry = uuid4() self.assertEqual(client.dataset_metadata(entry=entry), mock_data.METADATA) self.assert_valid_request( mock=mock_request, expected_method='get', expected_url='/datasets/metadata/{}'.format(entry))
def test_should_refresh_configured_schedules(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success() self.assertEqual(client.schedules_configured_refresh(), { 'successful': True, 'operation': None }) self.assert_valid_request(mock=mock_request, expected_method='put', expected_url='/schedules/configured/refresh')
def create_client_api(config, api_token, insecure) -> ClientApi: """ Creates a new client API with the provided configuration. If the default client API cannot be created (API token is missing) then an instance of :class:`InactiveClientApi` is returned instead. :param config: client configuration :param api_token: API token string or None if it is not available :param insecure: set to `True` to not verify TLS certificate when making requests to API :return: the client API or InactiveClientApi if it is not available """ if api_token: api_type = config.get_string('stasis.client.api.type') if api_type.lower() != 'http': logging.error('Expected [http] API but [{}] found'.format(api_type)) raise Abort() api_config = config.get_config('stasis.client.api.http') api_url = '{}://{}:{}'.format( 'https' if api_config.get_bool('context.enabled') or insecure else 'http', api_config.get_string('interface'), api_config.get_int('port') ) if api_config.get_bool('context.enabled') and not insecure: api_context = CustomHttpsContext( certificate_type=api_config.get_string('context.keystore.type'), certificate_path=api_config.get_string('context.keystore.path'), certificate_password=api_config.get_string('context.keystore.password') ) else: api_context = DefaultHttpsContext(verify=not insecure) default_client = DefaultClientApi( api_url=api_url, api_token=api_token, context=api_context ) if default_client.is_active(): api = default_client else: api = InactiveClientApi() else: api = InactiveClientApi() return api
def test_should_check_if_api_is_active(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success(mock_data.PING) self.assertTrue(client.is_active()) self.assert_valid_request(mock=mock_request, expected_method='get', expected_url='/service/ping') mock_request.return_value = MockResponse.failure() self.assertFalse(client.is_active())
def test_should_get_operation_progress(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success( mock_data.OPERATION_PROGRESS[0]) operation = uuid4() self.assertEqual(client.operation_progress(operation), mock_data.OPERATION_PROGRESS[0]) self.assert_valid_request( mock=mock_request, expected_method='get', expected_url='/operations/{}/progress'.format(operation))
def test_should_get_dataset_entries_for_definition(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success(mock_data.ENTRIES) definition = uuid4() self.assertEqual( client.dataset_entries_for_definition(definition=definition), mock_data.ENTRIES) self.assert_valid_request( mock=mock_request, expected_method='get', expected_url='/datasets/entries/{}'.format(definition))
def test_should_stop_an_active_operation(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.empty() operation = uuid4() self.assertEqual(client.operation_stop(operation), { 'successful': True, 'operation': None }) self.assert_valid_request( mock=mock_request, expected_method='put', expected_url='/operations/{}/stop'.format(operation))
def test_should_define_backups(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success() definition_request = {'a': 1, 'b': 2} self.assertEqual(client.backup_define(request=definition_request), { 'successful': True, 'operation': None }) self.assert_valid_request(mock=mock_request, expected_method='post', expected_url='/datasets/definitions', expected_request_data=definition_request)
def test_should_send_service_termination_requests(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success() self.assertDictEqual(client.stop(), { 'successful': True, 'operation': None }) self.assert_valid_request(mock=mock_request, expected_method='put', expected_url='/service/stop') mock_request.return_value = MockResponse.failure() self.assertDictEqual(client.stop(), {'successful': False})
def test_should_start_backups(self, mock_request): operation = uuid4() client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success( {'operation': operation}) definition = uuid4() self.assertEqual(client.backup_start(definition=definition), { 'successful': True, 'operation': operation }) self.assert_valid_request( mock=mock_request, expected_method='put', expected_url='/operations/backup/{}'.format(definition))
def test_should_search_dataset_metadata(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success( mock_data.METADATA_SEARCH_RESULTS) query = 'test.*' until = '2020-02-02T02:02:02' self.assertEqual( client.dataset_metadata_search(search_query=query, until=until), mock_data.METADATA_SEARCH_RESULTS) self.assert_valid_request(mock=mock_request, expected_method='get', expected_url='/datasets/metadata/search', expected_request_params={ 'query': query, 'until': until })
def test_should_follow_operation_progress(self, mock_request): client = DefaultClientApi(api_url=self.url, api_token=self.token, context=DefaultHttpsContext(verify=False)) def sse_response(): for e in mock_data.OPERATION_PROGRESS: yield 'data: {}\n\n'.format(json.dumps(e)).encode('utf-8') mock_response = MockResponse.success(sse_response()) mock_request.return_value = mock_response operation = uuid4() self.assertEqual(list(client.operation_follow(operation)), mock_data.OPERATION_PROGRESS) self.assertTrue(mock_response.closed) self.assert_valid_streaming_request( mock=mock_request, expected_method='get', expected_url='/operations/{}/follow'.format(operation))