def test_create_build(self):
project_uuid = uuid.uuid4().hex
obj = BuildJobConfig(project=project_uuid)
httpretty.register_uri(
httpretty.POST,
BaseApiHandler.build_url(
self.api_config.base_url,
'/',
'user',
'project',
'builds'),
body=json.dumps(obj.to_dict()),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.create_build('user', 'project', obj)
assert result.to_dict() == obj.to_dict()
# Raw response
self.set_raw_response()
result = self.api_handler.create_build('user', 'project', obj)
assert result == obj.to_dict()
# Async
self.assert_async_call(
api_handler_call=lambda: self.api_handler.create_build(
'user', 'project', obj, background=True),
method='post')
# Test create experiment with dict
httpretty.register_uri(
httpretty.POST,
BaseApiHandler.build_url(
self.api_config.base_url,
'/',
'user',
'project',
'builds'),
body=json.dumps(obj.to_dict()),
content_type='application/json',
status=200)
# Schema response
self.set_schema_response()
result = self.api_handler.create_build('user', 'project', obj.to_dict())
assert result.to_dict() == obj.to_dict()
# Raw response
self.set_raw_response()
result = self.api_handler.create_build('user', 'project', obj.to_dict())
assert result == obj.to_dict()
# Async
self.assert_async_call(
api_handler_call=lambda: self.api_handler.create_build(
'user', 'project', obj.to_dict(), background=True),
method='post')
def test_list_experiments(self):
experiments = [
ExperimentConfig(config={}).to_dict() for _ in range(10)
]
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/',
'experiments'),
body=json.dumps({
'results': experiments,
'count': 10,
'next': None
}),
content_type='application/json',
status=200)
# Schema response
response = self.api_handler.list_experiments()
assert len(response['results']) == 10
assert isinstance(response['results'][0], ExperimentConfig)
# Raw response
self.set_raw_response()
response = self.api_handler.list_experiments()
assert len(response['results']) == 10
assert isinstance(response['results'][0], Mapping)
def test_update_project(self):
obj = ProjectConfig('proj').to_dict()
httpretty.register_uri(httpretty.PATCH,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'user',
'project'),
body=json.dumps(obj),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.update_project('user', 'project',
{'name': 'new'})
assert result.to_dict() == obj
# Raw response
self.set_raw_response()
result = self.api_handler.update_project('user', 'project',
{'name': 'new'})
assert result == obj
# Async
self.assert_async_call(
api_handler_call=lambda: self.api_handler.update_project(
'user', 'project', {'name': 'new'}, background=True),
method='patch')
def test_resume_experiment_with_config(self):
exp = ExperimentConfig(config={}).to_dict()
config = {'config': {'declarations': {'lr': 0.1}}}
httpretty.register_uri(httpretty.POST,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'experiments', 1, 'resume'),
body=json.dumps(exp),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.resume('username', 'project_name', 1, config)
assert result.to_dict() == exp
# Raw response
self.set_raw_response()
result = self.api_handler.resume('username', 'project_name', 1, config)
assert result == exp
# Async
self.assert_async_call(
api_handler_call=lambda: self.api_handler.resume(
'username', 'project_name', 1, config, background=True),
method='post')
def test_list_projects(self):
projects = [
ProjectConfig('proj_{}'.format(i)).to_dict() for i in range(10)
]
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'user'),
body=json.dumps({
'results': projects,
'count': 10,
'next': None
}),
content_type='application/json',
status=200)
# Schema response
response = self.api_handler.list_projects('user')
assert len(response['results']) == 10
assert isinstance(response['results'][0], ProjectConfig)
assert response['count'] == 10
assert response['next'] is None
assert response['previous'] is None
# Raw response
self.set_raw_response()
response = self.api_handler.list_projects('user')
assert len(response['results']) == 10
assert isinstance(response['results'][0], Mapping)
assert response['count'] == 10
assert response['next'] is None
assert response['previous'] is None
def test_get_experiment_statuses_and_latest_code(self):
exp = ExperimentStatusConfig(id=1,
uuid=uuid.uuid4().hex,
experiment=1,
created_at=datetime.datetime.now(),
status='Running').to_dict()
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'experiments', 1,
'statuses'),
body=json.dumps({
'results': [exp],
'count': 1,
'next': None
}),
content_type='application/json',
status=200)
# Schema response
response = self.api_handler.get_statuses('username', 'project_name', 1)
assert len(response['results']) == 1
assert isinstance(response['results'][0], ExperimentStatusConfig)
# Raw response
self.set_raw_response()
response = self.api_handler.get_statuses('username', 'project_name', 1)
assert len(response['results']) == 1
assert isinstance(response['results'][0], Mapping)
def test_upload_and_sync_repo(self):
httpretty.register_uri(httpretty.PUT,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'user',
'project', 'repo', 'upload'),
content_type='application/json',
status=200)
files = [('code', ('repo',
open('./tests/fixtures_static/repo.tar.gz',
'rb'), 'text/plain'))]
result = self.api_handler.upload_repo('user',
'project',
files=files,
files_size=10,
sync=True)
assert result.status_code == 200
# Async
self.assert_async_call(api_handler_call=lambda: self.api_handler.
upload_repo('user',
'project',
files=files,
files_size=10,
sync=True,
background=True),
method='upload')
def test_update_experiment(self):
exp = ExperimentConfig(config={}).to_dict()
httpretty.register_uri(httpretty.PATCH,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'experiments', 1),
body=json.dumps(exp),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.update_experiment('username', 'project_name',
1, {'name': 'new'})
assert result.to_dict() == exp
# Raw response
self.set_raw_response()
result = self.api_handler.update_experiment('username', 'project_name',
1, {'name': 'new'})
assert result == exp
# Async
self.assert_async_call(api_handler_call=lambda: self.api_handler.
update_experiment('username',
'project_name',
1, {'name': 'new'},
background=True),
method='patch')
def test_login_notebook_impersonate_token(self):
token = uuid.uuid4().hex
httpretty.register_uri(httpretty.POST,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'user',
'project', 'notebook', 'impersonatetoken'),
body=json.dumps({'token': token}),
content_type='application/json',
status=200)
# Login without updating the token and without persistence
if os.path.exists(settings.CONTEXT_AUTH_TOKEN_PATH):
os.remove(settings.CONTEXT_AUTH_TOKEN_PATH)
assert self.api_config.token == 'token'
assert token == self.api_handler.login_notebook_impersonate_token(
username='******',
project_name='project',
internal_token='foo',
set_token=False,
persist_token=False)
assert self.api_config.token == 'token'
assert os.path.exists(settings.CONTEXT_AUTH_TOKEN_PATH) is False
# Login and update the token and persistence
if os.path.exists(settings.CONTEXT_AUTH_TOKEN_PATH):
os.remove(settings.CONTEXT_AUTH_TOKEN_PATH)
assert self.api_config.token == 'token'
assert token == self.api_handler.login_notebook_impersonate_token(
username='******',
project_name='project',
internal_token='foo',
set_token=True,
persist_token=True)
assert self.api_config.token == token
assert os.path.exists(settings.CONTEXT_AUTH_TOKEN_PATH) is True
def test_get_node(self):
obj = ClusterNodeConfig(uuid=uuid.uuid4().hex,
name='name',
hostname='hostname',
role='Master',
docker_version='v1',
kubelet_version='v1',
os_image='image',
kernel_version='v1',
schedulable_taints=True,
schedulable_state=True,
memory=10,
cpu=2,
n_gpus=1,
status=1).to_dict()
httpretty.register_uri(
httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url,
'/nodes',
1),
body=json.dumps(obj),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.get_node(1)
assert result.to_dict() == obj
# Raw response
self.set_raw_response()
result = self.api_handler.get_node(1)
assert result == obj
def test_get_job(self):
obj = ExperimentJobConfig(uuid=uuid.uuid4().hex,
experiment=1,
created_at=datetime.datetime.now(),
updated_at=datetime.datetime.now(),
definition={}).to_dict()
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'experiments', 1, 'jobs',
'uuid'),
body=json.dumps(obj),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.get_job('username', 'project_name', 1,
'uuid')
assert result.to_dict() == obj
# Raw response
self.set_raw_response()
result = self.api_handler.get_job('username', 'project_name', 1,
'uuid')
assert result == obj
def test_update_experiment_group(self):
obj = ExperimentGroupConfig(content=faker.word(),
uuid=uuid.uuid4().hex,
project=uuid.uuid4().hex).to_dict()
httpretty.register_uri(httpretty.PATCH,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'groups', 1),
body=json.dumps(obj),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.update_experiment_group(
'username', 'project_name', 1, {'content': 'new'})
assert result.to_dict() == obj
# Raw response
self.set_raw_response()
result = self.api_handler.update_experiment_group(
'username', 'project_name', 1, {'content': 'new'})
assert result == obj
# Async
self.assert_async_call(api_handler_call=lambda: self.api_handler.
update_experiment_group('username',
'project_name',
1, {'content': 'new'},
background=True),
method='patch')
def test_get_bookmarked_projects(self):
projects = [{
'content_object': ProjectConfig('proj').to_dict()
} for _ in range(10)]
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/bookmarks',
'user', 'projects'),
body=json.dumps({
'results': projects,
'count': 10,
'next': None
}),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.projects('user')
assert len(result['results']) == 10
assert isinstance(result['results'][0], ProjectConfig)
# Raw response
self.set_raw_response()
result = self.api_handler.projects('user')
assert len(result['results']) == 10
assert isinstance(result['results'][0], Mapping)
def test_list_experiment_groups(self):
project_uuid = uuid.uuid4().hex
experiment_groups = [
GroupConfig(content='text', project=project_uuid).to_dict()
for _ in range(10)
]
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'user',
'project', 'groups'),
body=json.dumps({
'results': experiment_groups,
'count': 10,
'next': None
}),
content_type='application/json',
status=200)
# Schema response
response = self.api_handler.list_experiment_groups('user', 'project')
assert len(response['results']) == 10
assert isinstance(response['results'][0], GroupConfig)
# Raw response
self.set_raw_response()
response = self.api_handler.list_experiment_groups('user', 'project')
assert len(response['results']) == 10
assert isinstance(response['results'][0], Mapping)
def test_get_log_handler(self):
obj = LogHandlerConfig(dsn='test',
environment='staging',
tags={
'cli_min_version': '0.0.1',
'cli_latest_version': '0.0.2',
'platform_min_version': '0.0.1',
'platform_latest_version': '0.0.1',
'chart_version': '0.0.1'
}).to_dict()
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/log_handler'),
body=json.dumps(obj),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.get_log_handler()
assert result.to_dict() == obj
# Raw response
self.set_raw_response()
result = self.api_handler.get_log_handler()
assert result == obj
def test_get_bookmarked_experiments(self):
project_uuid = uuid.uuid4().hex
obj_uuid = uuid.uuid4().hex
objs = [{
'content_object':
ExperimentConfig(config={}, uuid=obj_uuid,
project=project_uuid).to_dict()
} for _ in range(10)]
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/bookmarks',
'user', 'experiments'),
body=json.dumps({
'results': objs,
'count': 10,
'next': None
}),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.experiments('user')
assert len(result['results']) == 10
assert isinstance(result['results'][0], ExperimentConfig)
# Raw response
self.set_raw_response()
result = self.api_handler.experiments('user')
assert len(result['results']) == 10
assert isinstance(result['results'][0], Mapping)
def test_resume_job_with_config(self):
job = JobConfig(config={}).to_dict()
config = {'config': {'logging': {'level': 'error'}}}
httpretty.register_uri(httpretty.POST,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'jobs', 1, 'resume'),
body=json.dumps(job),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.resume('username', 'project_name', 1, config)
assert result.to_dict() == job
# Raw response
self.set_raw_response()
result = self.api_handler.resume('username', 'project_name', 1, config)
assert result == job
# Async
self.assert_async_call(
api_handler_call=lambda: self.api_handler.resume(
'username', 'project_name', 1, config, background=True),
method='post')
def test_get_experiment_metrics(self):
exp = ExperimentMetricConfig(id=1,
uuid=uuid.uuid4().hex,
experiment=1,
created_at=datetime.datetime.now(),
values={
'accuracy': 0.9,
'loss': np.float64(0.34),
'step': 1
}).to_dict()
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'experiments', 1,
'metrics'),
body=json.dumps({
'results': [exp],
'count': 1,
'next': None
}),
content_type='application/json',
status=200)
# Schema response
response = self.api_handler.get_metrics('username', 'project_name', 1)
assert len(response['results']) == 1
assert isinstance(response['results'][0], ExperimentMetricConfig)
# Raw response
self.set_raw_response()
response = self.api_handler.get_metrics('username', 'project_name', 1)
assert len(response['results']) == 1
assert isinstance(response['results'][0], Mapping)
def test_revoke_superuser(self):
httpretty.register_uri(httpretty.POST,
BaseApiHandler.build_url(
self.api_config.base_url, '/superusers',
'revoke', 'test-username'),
content_type='application/json',
status=200)
response = self.api_handler.revoke_superuser('test-username')
assert response.status_code == 200
def test_delete_user(self):
httpretty.register_uri(httpretty.DELETE,
BaseApiHandler.build_url(
self.api_config.base_url, '/users',
'delete', 'test-username'),
content_type='application/json',
status=204)
response = self.api_handler.delete_user('test-username')
assert response.status_code == 204
def test_stop_experiment(self):
httpretty.register_uri(httpretty.POST,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'experiments', 1, 'stop'),
content_type='application/json',
status=200)
result = self.api_handler.stop('username', 'project_name', 1)
assert result.status_code == 200
# Async
self.assert_async_call(api_handler_call=lambda: self.api_handler.stop(
'username', 'project_name', 1, background=True),
method='post')
def test_disable_ci(self):
httpretty.register_uri(httpretty.DELETE,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'ci'),
content_type='application/json',
status=204)
result = self.api_handler.disable_ci('username', 'project_name')
assert result.status_code == 204
# Async
self.assert_async_call(api_handler_call=lambda: self.api_handler.
disable_ci('user', 'project', background=True),
method='delete')
def test_experiment_logs(self):
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'experiments', 1, 'logs'),
body='some text',
content_type='text/plain',
status=200)
response = self.api_handler.logs('username',
'project_name',
1,
stream=False)
assert response.content.decode() == 'some text'
def test_unbookmark_job(self):
httpretty.register_uri(httpretty.DELETE,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'jobs', 1, 'unbookmark'),
content_type='application/json',
status=200)
result = self.api_handler.unbookmark('username', 'project_name', 1)
assert result.status_code == 200
# Async
self.assert_async_call(
api_handler_call=lambda: self.api_handler.unbookmark(
'username', 'project_name', 1, background=True),
method='delete')
def test_get_user(self):
user = UserConfig('user', '*****@*****.**').to_dict()
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/users'),
body=json.dumps(user),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.get_user('token_value')
assert result.to_dict() == user
# Raw response
self.set_raw_response()
result = self.api_handler.get_user('token_value')
assert result == user
def test_set_git_repo(self):
obj = {'git': 'https://github.com/foo/bar'}
httpretty.register_uri(httpretty.POST,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'repo', 'external'),
body=json.dumps(obj),
content_type='application/json',
status=201)
result = self.api_handler.set_repo('username', 'project_name', obj)
assert result.status_code == 201
# Async
self.assert_async_call(
api_handler_call=lambda: self.api_handler.set_repo(
'user', 'project', obj, background=True),
method='post')
def test_create_project(self):
obj = ProjectConfig('proj').to_dict()
httpretty.register_uri(httpretty.POST,
BaseApiHandler.build_url(
self.api_config.base_url, 'projects'),
body=json.dumps(obj),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.create_project(obj)
assert result.to_dict() == obj
# Raw response
self.set_raw_response()
result = self.api_handler.create_project(obj)
assert result == obj
def test_get_experiment(self):
exp = ExperimentConfig(config={}).to_dict()
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'experiments', 1),
body=json.dumps(exp),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.get_experiment('username', 'project_name', 1)
assert result.to_dict() == exp
# Raw response
self.set_raw_response()
result = self.api_handler.get_experiment('username', 'project_name', 1)
assert result == exp
def test_get_job(self):
job = JobConfig().to_dict()
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/', 'username',
'project_name', 'jobs', 1),
body=json.dumps(job),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.get_job('username', 'project_name', 1)
assert result.to_dict() == job
# Raw response
self.set_raw_response()
result = self.api_handler.get_job('username', 'project_name', 1)
assert result == job
def test_get_chart_version(self):
obj = ChartVersionConfig(version='1.0').to_dict()
httpretty.register_uri(httpretty.GET,
BaseApiHandler.build_url(
self.api_config.base_url, '/versions/',
'chart'),
body=json.dumps(obj),
content_type='application/json',
status=200)
# Schema response
result = self.api_handler.get_chart_version()
assert result.to_dict() == obj
# Raw response
self.set_raw_response()
result = self.api_handler.get_chart_version()
assert result == obj
