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