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_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_handle_unexpected_responses_when_retrieving_init_state( self, mock_request): client = DefaultInitApi(api_url=self.url, connect_retries=1, backoff_factor=2, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.empty() with self.assertRaises(Abort): client.state()
def test_should_handle_init_state_retrieval_failures(self, mock_request): client = DefaultInitApi(api_url=self.url, connect_retries=1, backoff_factor=2, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.failure( response='test failure') with self.assertRaises(Abort): client.state()
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_retrieve_init_state(self, mock_request): client = DefaultInitApi(api_url=self.url, connect_retries=1, backoff_factor=2, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success( mock_data.INIT_STATE_PENDING) self.assertDictEqual(client.state(), mock_data.INIT_STATE_PENDING) mock_request.assert_called_once()
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_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_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 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_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_handle_failures_when_providing_init_credentials( self, mock_request): client = DefaultInitApi(api_url=self.url, connect_retries=1, backoff_factor=2, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.failure( response='test failure') username = '******' password = '******' with self.assertRaises(Abort): client.provide_credentials(username=username, password=password)
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 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_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_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_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_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_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_provide_init_credentials(self, mock_request): client = DefaultInitApi(api_url=self.url, connect_retries=1, backoff_factor=2, context=DefaultHttpsContext(verify=False)) mock_request.return_value = MockResponse.success() username = '******' password = '******' self.assertDictEqual( client.provide_credentials(username=username, password=password), {'successful': True}) mock_request.assert_called_once_with(method='post', url='{}/init'.format(self.url), data={ 'username': username, 'password': password }, verify=False)
def create_init_api(config, insecure, client_api) -> InitApi: """ Creates a new initialization API with the provided configuration. If the client API is reported as active (i.e. initialization is already done) then an instance of :class:`InactiveInitApi` is returned instead. :param config: client configuration :param insecure: set to `True` to not verify TLS certificate when making requests to API :param client_api: client API to use for determining API state :return: the init API or InactiveInitApi if it is not available """ if not client_api.is_active(): api_config = config.get_config('stasis.client.api.init') 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) api = DefaultInitApi( api_url=api_url, context=api_context, connect_retries=10, backoff_factor=0.1 ) else: api = InactiveInitApi() return api
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))