def test_file_list_exists_api(self):
file1 = data_mocking.create_file({'project_id': self.project.id},
self.session)
file2 = data_mocking.create_file({'project_id': self.project.id},
self.session)
file3 = data_mocking.create_file({'project_id': self.project.id},
self.session)
file_diff = data_mocking.create_file({'project_id': self.project2.id},
self.session)
request_data = {'file_id_list': [file1.id, file2.id, file3.id]}
auth_api = common_actions.create_project_auth(project=self.project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
endpoint = "/api/v1/project/{}/file/exists".format(
self.project.project_string_id)
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(self.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
data = response.json
self.assertEqual(response.status_code, 200)
self.assertTrue(data.get('result').get('exists'))
request_data = {
'file_id_list': [file1.id, file2.id, file3.id, file_diff.id]
}
auth_api = common_actions.create_project_auth(project=self.project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
endpoint = "/api/v1/project/{}/file/exists".format(
self.project.project_string_id)
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(self.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
data = response.json
self.assertEqual(response.status_code, 200)
self.assertFalse(data.get('result').get('exists'))
def test_input_packet_endpoint(self):
# TODO: PENDING
request_data = {
'media': {
'url':
'https://hips.hearstapps.com/hmg-prod.s3.amazonaws.com/images/tesla-model-s-1563301327.jpg',
'type': 'image'
},
'frame_packet_map': None,
'instance_list': None,
'job_id': None,
'video_split_duration': None,
}
endpoint = "/api/walrus/v1/project/" + self.project_string_id + "/input/packet"
auth_api = common_actions.create_project_auth(project=self.project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(self.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
self.assertTrue(response.status_code == 200)
def setUp(self):
# TODO: this test is assuming the 'my-sandbox-project' exists and some object have been previously created.
# For future tests a mechanism of setting up and tearing down the database should be created.
super(TestFileExists, self).setUp()
project_data = data_mocking.create_project_with_context(
{
'users': [{
'username': '******',
'email': '*****@*****.**',
'password': '******',
}]
}, self.session)
self.project = project_data['project']
self.project_data = project_data
self.auth_api = common_actions.create_project_auth(
project=self.project, session=self.session)
self.member = self.auth_api.member
project_data2 = data_mocking.create_project_with_context(
{
'users': [{
'username': '******',
'email': '*****@*****.**',
'password': '******',
}]
}, self.session)
self.project2 = project_data2['project']
def test_job_resync_api(self):
# Create mock job.
job = data_mocking.create_job(
{
'name': 'my-test-job',
'project': self.project
}, self.session)
request_data = {
'task_template_id': job.id,
}
endpoint = "/api/v1/project/" + job.project.project_string_id + "/job/resync"
auth_api = common_actions.create_project_auth(project=job.project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(self.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
data = response.json
self.assertEqual(response.status_code, 200)
self.assertEqual(data['resync_result'], True)
def test_issue_new_web(self):
# Create mock tasks
# Create mock job.
job = data_mocking.create_job(
{
'name': 'my-test-job',
'project': self.project
}, self.session)
file = data_mocking.create_file(
{
'project_id': job.project.id,
'job_id': job.id
}, self.session)
task = data_mocking.create_task(
{
'name': 'task{}'.format(1),
'job': job,
'file': file,
}, self.session)
discussion_title = 'new_issue'
discussion_description = 'new_issue_description'
request_data = {
'title':
discussion_title,
'description':
discussion_description,
'attached_elements': [{
'type': 'job',
'id': job.id
}, {
'type': 'file',
'id': file.id
}, {
'type': 'task',
'id': task.id
}]
}
endpoint = "/api/v1/project/" + job.project.project_string_id + "/issues/new"
auth_api = common_actions.create_project_auth(project=job.project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(job.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
data = response.json
self.assertEqual(response.status_code, 200)
self.assertEqual(data['issue']['title'], discussion_title)
self.assertEqual(data['issue']['description'], discussion_description)
def test_get_video_frame_from_task(self):
# Create mock task
job = data_mocking.create_job({
'name': 'my-test-job-{}'.format(1),
'project': self.project
}, self.session)
video_file = data_mocking.create_file({
'project_id': self.project.id,
'type': 'video'
}, self.session)
frames_list = []
# Mock Frames
for i in range(0, 10):
frame = data_mocking.create_file({
'project_id': self.project.id,
'video_parent_file_id': video_file.id,
'frame_number': i,
'type': 'frame'
}, self.session)
frames_list.append(frame)
task = data_mocking.create_task({
'name': 'tasktest',
'job': job,
'file': video_file
}, self.session)
request_data = {
'frame_list': [1, 2, 3],
'project_string_id': self.project.project_string_id,
'mode_data': 'list'
}
endpoint = "/api/v1/task/{}/video/single/{}/frame-list/".format(task.id, video_file.id)
with self.client.session_transaction() as session:
auth_api = common_actions.create_project_auth(project = self.project, session = self.session)
credentials = b64encode("{}:{}".format(auth_api.client_id, auth_api.client_secret).encode()).decode(
'utf-8')
session['Authorization'] = credentials
common_actions.add_auth_to_session(session, self.project.users[0])
response = self.client.post(
endpoint,
data = json.dumps(request_data),
headers = {
'directory_id': str(job.project.directory_default_id),
'Authorization': 'Basic {}'.format(credentials)
}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.json['url_list']), 3)
i = 1
for elm in response.json['url_list']:
self.assertEqual(elm['frame_number'], i)
i += 1
def test_new_instance_template_api(self):
request_data = {
'instance_list': [{
'type':
'keypoints',
'nodes': [{
'x': 0,
'y': 0,
'id': 'abc'
}, {
'x': 5,
'y': 5,
'id': 'cde'
}],
'edges': [{
'from': 'abc',
'to': 'cde'
}]
}],
'name':
'my instance template',
'reference_width':
600,
'reference_height':
800
}
endpoint = "/api/v1/project/{}/instance-template/new".format(
self.project.project_string_id)
auth_api = common_actions.create_project_auth(project=self.project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(self.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
data = response.json
self.assertEqual(response.status_code, 200)
self.assertTrue('instance_template' in data)
self.assertTrue('instance_list' in data['instance_template'])
self.assertTrue('name' in data['instance_template'])
self.assertTrue('id' in data['instance_template'])
self.assertTrue('reference_width' in data['instance_template'])
self.assertTrue('reference_height' in data['instance_template'])
self.assertEqual(data['instance_template']['reference_height'], 800)
self.assertEqual(data['instance_template']['reference_width'], 600)
self.assertEqual(len(data['instance_template']['instance_list']), 1)
def test_new_web(self):
# Create mock project/job.
project_data = data_mocking.create_project_with_context(
{
'users': [{
'username': '******',
'email': '*****@*****.**',
'password': '******',
}]
}, self.session)
project = project_data['project']
user = project_data['users'][0]
file = data_mocking.create_file({'project_id': project.id},
self.session)
request_data = {
'name': 'new name',
'instance_type': 'polygon',
'share_type': 'project',
'type': 'exam',
'label_file_list': [{
'id': file.id
}],
'file_handling': 'isolate',
'member_list_ids': [user.member.id],
}
endpoint = "/api/v1/project/{}/job/new".format(
project.project_string_id)
auth_api = common_actions.create_project_auth(project=project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
print(response.data)
self.assertEqual(response.status_code, 200)
new_session = sessionMaker.session_factory()
updated_job = Job.get_by_id(new_session, response.json['job']['id'])
self.assertEqual(updated_job.name, request_data['name'])
self.assertEqual(updated_job.instance_type,
request_data['instance_type'])
self.assertEqual(updated_job.share_type, request_data['share_type'])
self.assertEqual(updated_job.type, request_data['type'])
self.assertEqual(updated_job.file_handling,
request_data['file_handling'])
def test_model_run_list_web(self):
model = Model.new(session=self.session,
reference_id='test_model',
project_id=self.project.id,
member_created_id=self.member.id,
add_to_session=True,
flush_session=True)
model_run = ModelRun.new(session=self.session,
reference_id='test_model_run__a',
project_id=self.project.id,
member_created_id=self.member.id,
model_id=model.id,
add_to_session=True,
flush_session=True)
model_run2 = ModelRun.new(session=self.session,
reference_id='test_model_run__b',
project_id=self.project.id,
member_created_id=self.member.id,
model_id=model.id,
add_to_session=True,
flush_session=True)
request_data = {}
auth_api = common_actions.create_project_auth(project=self.project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
endpoint = "/api/v1/project/{}/model-runs/list".format(
self.project.project_string_id)
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(self.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
data = response.json
self.assertIsNotNone(data.get('model_run_list'))
self.assertEqual(len(data.get('model_run_list')), 2)
self.assertIsNotNone(data.get('model_run_list')[0].get('id'))
self.assertIsNotNone(data.get('model_run_list')[0].get('created_time'))
self.assertIsNotNone(data.get('model_run_list')[0].get('model_id'))
self.assertIsNotNone(
data.get('model_run_list')[0].get('member_created_id'))
self.assertIsNotNone(data.get('model_run_list')[0].get('project_id'))
ids = [m['id'] for m in data.get('model_run_list')]
for m in [model_run, model_run2]:
self.assertTrue(m.id in ids)
def test_update_instance_template_api(self):
template_data = {
'name': 'test template1',
'project_id': self.project.id,
'instance_list': [
{
'type': 'keypoints',
'nodes': [{'x': 0, 'y': 0, 'id': 'abc'}, {'x': 5, 'y': 5, 'id': 'cde'}],
'edges': [{'from': 'abc', 'to': 'cde'}]
}
]
}
instance_template1 = data_mocking.create_instance_template(template_data, self.session)
request_data = {
'instance_list': [
{
'type': 'keypoints',
'nodes': [{'x': 0, 'y': 0, 'id': 'abc'}, {'x': 5, 'y': 5, 'id': 'cde'}],
'edges': [{'from': 'abc', 'to': 'cde'}]
}
],
'name': 'my instance template',
'status': 'archived'
}
endpoint = "/api/v1/project/{}/instance-template/{}".format(self.project.project_string_id,
instance_template1.id)
auth_api = common_actions.create_project_auth(project = self.project, session = self.session)
credentials = b64encode("{}:{}".format(auth_api.client_id, auth_api.client_secret).encode()).decode('utf-8')
response = self.client.post(
endpoint,
data = json.dumps(request_data),
headers = {
'directory_id': str(self.project.directory_default_id),
'Authorization': 'Basic {}'.format(credentials)
}
)
data = response.json
self.assertEqual(response.status_code, 200)
self.assertTrue('instance_template' in data)
self.assertEqual(data['instance_template']['instance_list'][0]['nodes'][1]['x'], 5)
self.assertEqual(data['instance_template']['instance_list'][0]['nodes'][0]['x'], 0)
self.assertEqual(data['instance_template']['instance_list'][0]['nodes'][0]['y'], 0)
self.assertEqual(data['instance_template']['instance_list'][0]['nodes'][1]['y'], 5)
self.assertEqual(data['instance_template']['name'], request_data['name'])
self.assertTrue('id' in data['instance_template'])
self.assertEqual(len(data['instance_template']['instance_list']), 1)
self.assertEqual(data['instance_template']['id'], instance_template1.id)
self.assertEqual(data['instance_template']['status'], 'archived')
def test_instance_history_api(self):
request_data = {}
root = data_mocking.create_instance(
{
'previous_id': None,
'project_id': self.project.id
}, self.session)
instance1 = data_mocking.create_instance(
{
'root_id': root.id,
'project_id': self.project.id
}, self.session)
instance2 = data_mocking.create_instance(
{
'root_id': root.id,
'project_id': self.project.id
}, self.session)
instance3 = data_mocking.create_instance(
{
'root_id': root.id,
'project_id': self.project.id
}, self.session)
instance4 = data_mocking.create_instance({'root_id': 0}, self.session)
auth_api = common_actions.create_project_auth(project=self.project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
endpoint = "/api/v1/project/{}/instance/{}/history".format(
self.project.project_string_id, instance1.id)
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(self.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
data = response.json
self.assertEqual(response.status_code, 200)
self.assertEqual(len(data.get('instance_history')), 4)
self.assertEqual(data.get('instance_history')[-1]['id'],
root.id) # careful, order dependent
history_ids = [x['id'] for x in data['instance_history']]
self.assertTrue(instance1.id in history_ids)
self.assertTrue(instance2.id in history_ids)
self.assertTrue(instance3.id in history_ids)
def test_sync_events_list_api(self):
# Create mock tasks
num_events = 5
job = data_mocking.create_job(
{
'name': 'my-test-job-{}'.format(1),
'project': self.project
}, self.session)
all_sync_events = []
for i in range(0, num_events):
sync_event = data_mocking.create_sync_event(
{
'description': 'syncevent{}'.format(i),
'job_id': job.id,
'project': self.project
}, self.session)
all_sync_events.append(sync_event)
request_payload = {
'metadata': {
'job_id': job.id,
'mode_data': 'list',
'project_string_id': self.project.project_string_id
}
}
endpoint = "/api/v1/sync-events/list"
with self.client.session_transaction() as session:
auth_api = common_actions.create_project_auth(project=self.project,
session=self.session)
credentials = b64encode("{}:{}".format(
auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
session['Authorization'] = credentials
common_actions.add_auth_to_session(session, self.project.users[0])
response = self.client.post(endpoint,
data=json.dumps(request_payload),
headers={
'directory_id':
str(job.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
print(response.data)
self.assertEqual(response.status_code, 200)
new_session = sessionMaker.session_factory()
self.assertEqual(len(response.json['sync_events_list']), num_events)
def test_job_resync_core(self):
job = data_mocking.create_job(
{
'name': 'my-test-job',
'project': self.project
}, self.session)
auth_api = common_actions.create_project_auth(project=job.project,
session=self.session)
resync_result, log = job_resync_core(session=self.session,
project=self.project,
member=auth_api.member,
task_template_id=job.id,
log=regular_log.default())
self.assertTrue(resync_result)
self.assertEqual(len(log['error'].keys()), 0)
def test_list_discussion_comment_web(self):
# Create mock discussion
discussion = data_mocking.create_discussion(
{
'title': 'test',
'description': 'test',
'project_id': self.project.id
}, self.session)
comment1 = data_mocking.create_discussion_comment(
{
'discussion_id': discussion.id,
'project_id': self.project.id,
'content': 'test'
}, self.session)
comment2 = data_mocking.create_discussion_comment(
{
'discussion_id': discussion.id,
'project_id': self.project.id,
'content': 'test'
}, self.session)
request_data = {}
endpoint = "/api/v1/project/{}/discussion/{}/comments".format(
self.project.project_string_id, discussion.id)
auth_api = common_actions.create_project_auth(project=self.project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(self.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
data = response.json
self.assertEqual(response.status_code, 200)
self.assertTrue('comments' in data)
self.assertEqual(len(data['comments']), 2)
ids = [comment['id'] for comment in data['comments']]
self.assertTrue(comment1.id in ids)
self.assertTrue(comment2.id in ids)
def test_job_update_api(self):
# Create mock job.
job = data_mocking.create_job({'name': 'my-test-job'}, self.session)
file = data_mocking.create_file(
{
'project_id': job.project.id,
'job_id': job.id
}, self.session)
request_data = {
'name': 'new name',
'instance_type': 'polygon',
'share_type': 'project',
'type': 'exam',
'label_file_list': [{
'id': file.id
}],
'file_handling': 'isolate',
'job_id': job.id,
}
endpoint = "/api/v1/project/" + job.project.project_string_id + "/job/update"
auth_api = common_actions.create_project_auth(project=job.project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(job.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
self.assertEqual(response.status_code, 200)
new_session = sessionMaker.session_factory()
updated_job = Job.get_by_id(new_session, job.id)
self.assertEqual(updated_job.name, request_data['name'])
self.assertEqual(updated_job.instance_type,
request_data['instance_type'])
self.assertEqual(updated_job.share_type, request_data['share_type'])
self.assertEqual(updated_job.type, request_data['type'])
self.assertEqual(updated_job.file_handling,
request_data['file_handling'])
def test_job_pin_api(self):
# Create mock job.
job = data_mocking.create_job(
{
'name': 'my-test-job',
'project': self.project
}, self.session)
request_data = {}
endpoint = "/api/v1/job/{}/pin".format(job.id)
with self.client.session_transaction() as session:
auth_api = common_actions.create_project_auth(project=self.project,
session=self.session)
credentials = b64encode("{}:{}".format(
auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
session['Authorization'] = credentials
common_actions.add_auth_to_session(session, self.project.users[0])
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(job.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
data = response.json
self.assertEqual(response.status_code, 200)
self.assertEqual(data['job']['is_pinned'], True)
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(job.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
data = response.json
self.assertEqual(response.status_code, 200)
self.assertEqual(data['job']['is_pinned'], False)
def test_job_list_api(self):
# Create mock job.
num_jobs = 5
all_jobs = []
for i in range(0, num_jobs):
job = data_mocking.create_job(
{
'name': 'my-test-job-{}'.format(i),
'project': self.project
}, self.session)
all_jobs.append(job)
request_data = {
'metadata': {
'builder_or_trainer': {
'mode': 'builder'
},
'limit': 5,
'project_string_id': self.project.project_string_id
}
}
endpoint = "/api/v1/job/list"
with self.client.session_transaction() as session:
auth_api = common_actions.create_project_auth(project=self.project,
session=self.session)
credentials = b64encode("{}:{}".format(
auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
session['Authorization'] = credentials
common_actions.add_auth_to_session(session, self.project.users[0])
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(job.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
self.assertEqual(response.status_code, 200)
new_session = sessionMaker.session_factory()
self.assertEqual(len(response.json['Job_list']), num_jobs)
def test_batch_new_api(self):
label = data_mocking.create_label({
'name': 'apple',
}, self.session)
label_file = data_mocking.create_label_file(
{
'label': label,
'project_id': self.project.id
}, self.session)
request_data = {
'pre_labeled_data': {
'myfile.jpg': [{
'type': 'box',
'label': 'apple',
'x_min': 1,
'x_max': 18,
'y_min': 1,
'y_max': 17,
}]
}
}
auth_api = common_actions.create_project_auth(project=self.project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
endpoint = "/api/v1/project/{}/input-batch/new".format(
self.project.project_string_id)
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(self.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
data = response.json
self.assertEqual(response.status_code, 200)
self.assertIsNotNone(data.get('input_batch'))
def setUp(self):
# TODO: this test is assuming the 'my-sandbox-project' exists and some object have been previously created.
# For future tests a mechanism of setting up and tearing down the database should be created.
super(TestQueryCreator, self).setUp()
project_data = data_mocking.create_project_with_context(
{
'users': [{
'username': '******',
'email': '*****@*****.**',
'password': '******',
}]
}, self.session)
self.project = project_data['project']
self.project_data = project_data
self.auth_api = common_actions.create_project_auth(
project=self.project, session=self.session)
self.member = self.auth_api.member
self.credentials = b64encode("{}:{}".format(
self.auth_api.client_id,
self.auth_api.client_secret).encode()).decode('utf-8')
def test_new_discussion_comment_web(self):
# Create mock tasks
# Create mock job.
job = data_mocking.create_job({
'name': 'my-test-job',
'project': self.project
}, self.session)
discussion = data_mocking.create_discussion({
'title': 'test',
'description': 'test',
'project_id': self.project.id
}, self.session)
comment_content = 'the comment'
request_data = {
'content': comment_content
}
endpoint = "/api/v1/project/{}/discussion/{}/add-comment".format(self.project.project_string_id, discussion.id)
auth_api = common_actions.create_project_auth(project = job.project, session = self.session)
credentials = b64encode("{}:{}".format(auth_api.client_id, auth_api.client_secret).encode()).decode('utf-8')
response = self.client.post(
endpoint,
data = json.dumps(request_data),
headers = {
'directory_id': str(job.project.directory_default_id),
'Authorization': 'Basic {}'.format(credentials)
}
)
data = response.json
self.assertEqual(response.status_code, 200)
self.assertTrue('comment' in data)
self.assertTrue('content' in data['comment'])
self.assertTrue('user' in data['comment'])
self.assertTrue(data['comment']['content'] == comment_content)
self.assertTrue('member_created_id' in data['comment'])
self.assertTrue('member_updated_id' in data['comment'])
self.assertTrue('time_created' in data['comment'])
self.assertTrue('time_updated' in data['comment'])
self.assertTrue('id' in data['comment'])
def test_update_discussion_comment_web(self):
# Create mock discussion
discussion = data_mocking.create_discussion(
{
'title': 'test',
'description': 'test',
'project_id': self.project.id
}, self.session)
auth_api = common_actions.create_project_auth(project=self.project,
session=self.session)
member = auth_api.member
comment1 = data_mocking.create_discussion_comment(
{
'discussion_id': discussion.id,
'member_created_id': member.id,
'project_id': self.project.id,
'content': 'test'
}, self.session)
new_content = 'new content.'
request_data = {'comment_id': comment1.id, 'content': new_content}
endpoint = "/api/v1/project/{}/discussion/{}/update-comment".format(
self.project.project_string_id, discussion.id)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(self.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
data = response.json
self.assertEqual(response.status_code, 200)
self.assertTrue('comment' in data)
self.assertEqual(data['comment']['content'], new_content)
def test_threaded_job_resync(self):
job = data_mocking.create_job(
{
'name': 'my-test-job',
'status': 'active',
'project': self.project
}, self.session)
auth_api = common_actions.create_project_auth(project=job.project,
session=self.session)
file = data_mocking.create_file({'project_id': self.project.id},
self.session)
file_missing1 = data_mocking.create_file(
{'project_id': self.project.id}, self.session)
file_missing2 = data_mocking.create_file(
{'project_id': self.project.id}, self.session)
directory = data_mocking.create_directory(
{
'project': self.project,
'user': self.project_data['users'][0],
'files': [file, file_missing1, file_missing2]
}, self.session)
job.update_attached_directories(self.session,
[{
'directory_id': directory.id,
'selected': 'sync'
}])
log = regular_log.default()
sync_manager = job_dir_sync_utils.JobDirectorySyncManager(
session=self.session, log=log, job=job)
sync_manager._JobDirectorySyncManager__add_file_into_job(
file, directory, create_tasks=True)
self.session.commit()
result = threaded_job_resync(task_template_id=job.id,
member_id=auth_api.member_id)
self.assertEqual(len(result), 2)
def test_new_userscript_api(self):
external_src_list = ['test', '2']
example = {
'name': 'test',
'code': 'test',
'external_src_list': external_src_list
}
auth_api = common_actions.create_project_auth(project = self.project, session = self.session)
credentials = b64encode("{}:{}".format(auth_api.client_id, auth_api.client_secret).encode()).decode('utf-8')
endpoint = "/api/v1/project/{}/userscript/new".format(self.project.project_string_id)
response = self.client.post(
endpoint,
data = json.dumps(example),
headers = {
'Authorization': 'Basic {}'.format(credentials)
}
)
data = response.json
self.assertEqual(response.status_code, 200)
self.assertTrue('userscript' in data)
userscript = response.json.get('userscript')
self.assertFalse(userscript.get('is_public'))
self.assertIsNotNone(userscript.get('id'))
self.assertIsNotNone(userscript.get('name'))
self.assertIsNotNone(userscript.get('project_id'))
self.assertIsNotNone(userscript.get('time_created'))
self.assertEqual(len(userscript.get('external_src_list')), len(external_src_list))
def test_issue_list_web(self):
# Create mock tasks
# Create mock job.
discussion = data_mocking.create_discussion(
{
'project_id': self.project.id,
'name': 'test',
'title': 'test',
},
self.session,
)
issue2 = data_mocking.create_discussion(
{
'project_id': self.project.id,
'name': 'test',
'title': 'test',
},
self.session,
)
issue3 = data_mocking.create_discussion(
{
'project_id': self.project.id,
'name': 'test',
'title': 'test',
},
self.session,
)
job = data_mocking.create_job({
'name': 'my-test-job',
'project': self.project
}, self.session)
discussion.attach_element(
session = self.session,
element = {'type': 'job', 'id': job.id}
)
issue2.attach_element(
session = self.session,
element = {'type': 'job', 'id': job.id}
)
file = data_mocking.create_file({'project_id': job.project.id, 'job_id': job.id}, self.session)
discussion.attach_element(
session = self.session,
element = {'type': 'file', 'id': file.id}
)
task = data_mocking.create_task({
'name': 'task{}'.format(1),
'job': job,
'file': file,
}, self.session)
discussion.attach_element(
session = self.session,
element = {'type': 'task', 'id': task.id}
)
regular_methods.commit_with_rollback(self.session)
rels = self.session.query(DiscussionRelation).all()
request_data = {
'project_id': self.project.id,
'task_id': task.id,
}
endpoint = "/api/v1/project/" + self.project.project_string_id + "/discussions/list"
auth_api = common_actions.create_project_auth(project=job.project, session=self.session)
credentials = b64encode("{}:{}".format(auth_api.client_id, auth_api.client_secret).encode()).decode('utf-8')
response_with_task_id = self.client.post(
endpoint,
data=json.dumps(request_data),
headers={
'directory_id': str(job.project.directory_default_id),
'Authorization': 'Basic {}'.format(credentials)
}
)
data = response_with_task_id.json
self.assertEqual(response_with_task_id.status_code, 200)
self.assertEqual(len(data['issues']), 1)
request_data = {
'project_id': self.project.id,
'job_id': job.id,
}
response_with_job_id = self.client.post(
endpoint,
data=json.dumps(request_data),
headers={
'directory_id': str(job.project.directory_default_id),
'Authorization': 'Basic {}'.format(credentials)
}
)
data = response_with_job_id.json
self.assertEqual(response_with_task_id.status_code, 200)
self.assertEqual(len(data['issues']), 2)
request_data = {
'project_id': self.project.id,
}
response_project = self.client.post(
endpoint,
data=json.dumps(request_data),
headers={
'directory_id': str(job.project.directory_default_id),
'Authorization': 'Basic {}'.format(credentials)
}
)
data = response_project.json
self.assertEqual(response_with_task_id.status_code, 200)
self.assertEqual(len(data['issues']), 3)
def test_job_output_dir_update(self):
# Create mock job.
project_data = data_mocking.create_project_with_context(
{
'users': [{
'username': '******',
'email': '*****@*****.**',
'password': '******',
}]
}, self.session)
project = project_data['project']
job = data_mocking.create_job(
{
'name': 'my-test-job',
'project': project
}, self.session)
directory = data_mocking.create_directory(
{
'project': project,
'user': project_data['users'][0],
}, self.session)
file = data_mocking.create_file(
{
'project_id': job.project.id,
'job_id': job.id
}, self.session)
request_data = {
'output_dir': str(directory.id),
'output_dir_action': 'copy',
'job_id': job.id,
}
endpoint = "/api/v1/project/" + job.project.project_string_id + "/job/set-output-dir"
auth_api = common_actions.create_project_auth(project=job.project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
response = self.client.post(endpoint,
data=json.dumps(request_data),
headers={
'directory_id':
str(job.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
self.assertEqual(response.status_code, 200)
new_session = sessionMaker.session_factory()
updated_job = Job.get_by_id(new_session, job.id)
self.assertEqual(updated_job.output_dir_action,
request_data['output_dir_action'])
self.assertEqual(str(updated_job.completion_directory_id),
request_data['output_dir'])
# Now test a wrong action
request_data_error = {
'output_dir': 58,
'output_dir_action': 'a_wrong_action',
'job_id': job.id,
}
response_error = self.client.post(
endpoint,
data=json.dumps(request_data_error),
headers={
'directory_id': str(job.project.directory_default_id),
'Authorization': 'Basic {}'.format(credentials)
})
self.assertEqual(response_error.status_code, 400)
def test_api_create_sequence_preview(self):
label = data_mocking.create_label({
'name': 'apple',
}, self.session)
label_file = data_mocking.create_label_file(
{
'label': label,
'project_id': self.project.id
}, self.session)
video_file = data_mocking.create_file(
{
'project_id': self.project.id,
'type': 'video'
}, self.session)
sequence = data_mocking.create_sequence(
{
'label_file_id': label_file.id,
'video_file_id': video_file.id,
'cache_expiry': time.time() + 500000,
'number': 1,
}, self.session)
video_file_bad = data_mocking.create_file(
{
'project_id': self.project2.id,
'type': 'video'
}, self.session)
preview_url = 'https://picsum.photos/200/300'
instance = data_mocking.create_instance(
{
'project_id': self.project.id,
'type': 'box',
'x_min': 0,
'x_max': 0,
'y_min': 0,
'y_max': 0,
'file_id': video_file.id,
'soft_delete': False,
'sequence_id': sequence.id,
'preview_image_url': preview_url,
'preview_image_url_expiry': 900000000,
}, self.session)
sequence.instance_preview_cache = {
'id': instance.id,
'file_id': sequence.video_file.id,
'preview_image_url': preview_url,
}
self.session.commit()
endpoint = "/api/project/{}/sequence/{}/create-preview".format(
self.project.project_string_id,
sequence.id,
)
auth_api = common_actions.create_project_auth(project=self.project,
session=self.session)
credentials = b64encode(
"{}:{}".format(auth_api.client_id,
auth_api.client_secret).encode()).decode('utf-8')
response = self.client.post(endpoint,
data=json.dumps({}),
headers={
'directory_id':
str(self.project.directory_default_id),
'Authorization':
'Basic {}'.format(credentials)
})
data = response.json
self.assertTrue('result' in data)
self.assertTrue('log' in data)
self.assertFalse(len(data['log']['error'].keys()), 0)
self.assertEqual(data['result']['instance_preview']['id'], instance.id)
self.assertEqual(data['result']['instance_preview']['file_id'],
video_file.id)
self.assertEqual(
data['result']['instance_preview']['preview_image_url'],
preview_url)
# Error case
sequence2 = data_mocking.create_sequence(
{
'label_file_id': label_file.id,
'video_file_id': video_file_bad.id,
'cache_expiry': time.time() + 500000,
'number': 1,
}, self.session)
result, log = sequence_preview_create.create_sequence_preview_core(
session=self.session,
log=regular_log.default(),
project=self.project,
sequence_id=sequence2.id)
self.assertEqual(len(log['error'].keys()), 1)
self.assertTrue('project_id' in log['error'])