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'])