def test_extend_exp_date_for_inactive_subscription(self): self.before_each() s1 = self.subscriptions[0] s1.status = Subscription.INACTIVE_STATUS db_session_users.add(s1) db_session_users.commit() date_in_future = datetime.datetime.utcnow() + datetime.timedelta( days=20) new_exp_date = date_in_future.date() request_body = json.dumps({ 'expiration_date': str(new_exp_date), }) response = self.client.post( "/subscriptions/" + str(self.subscriptions[0].id), headers={'Authorization': self.admin_user_token}, data=request_body) self.assert200(response) self.assertIn("new_subscription", response.json) self.assertIsInstance(response.json["new_subscription"], dict) result_subscription = response.json["new_subscription"] self.assertEqual(result_subscription['status'], Subscription.ACTIVE_STATUS) self.assertEqual(result_subscription['status_reason'], Subscription.REACTIVATED_STATUS_REASON) res_date = datetime.datetime.strptime( str(result_subscription['expiration_date']), "%a, %d %b %Y %H:%M:%S %Z") self.assertEqual(res_date.date(), date_in_future.date())
def test_update_plan_for_inactive_subscription(self): self.before_each() s1 = self.subscriptions[0] s1.status = Subscription.INACTIVE_STATUS s1.status_reason = Subscription.EXPIRED_STATUS_REASON s1.notes = 'User suspended due to inactivity' db_session_users.add(s1) db_session_users.commit() # non recurring plan plan_id = 1 request_body = json.dumps({'plan_id': plan_id}) response = self.client.post( "/subscriptions/" + str(self.subscriptions[0].id), headers={'Authorization': self.admin_user_token}, data=request_body) self.assert200(response) self.assertIn("new_subscription", response.json) self.assertIsInstance(response.json["new_subscription"], dict) result_subscription = response.json["new_subscription"] self.assertEqual(result_subscription["plan_id"], plan_id) plan = db_session_users().query(Plan).filter_by(id=plan_id).first() self.assertEqual(result_subscription["stripe_id"], plan.stripe_id) self.assertEqual(result_subscription['status'], Subscription.ACTIVE_STATUS) self.assertEqual(result_subscription['status_reason'], Subscription.REACTIVATED_STATUS_REASON) self.assertIsNone(result_subscription['notes']) self.assertIsNotNone(result_subscription['expiration_date'])
def test_delete_document_not_in_folder(self): self.before_each() # add document to folder folder = db_session_users.query(UserFolder).filter_by( user_id=self.user.id, name='test_folder').first() user_folder_documents = UserFolderDocument({ "user_folder_id": folder.id, 'doc_id': 1, }) db_session_users.add(user_folder_documents) db_session_users.commit() # make sure document does not exsist user_folder_document = db_session_users.query( UserFolderDocument).filter_by(user_folder_id=folder.id, doc_id=1872).first() self.assertIsNone(user_folder_document) # delete another non-existent document from the folder request_body = json.dumps({'document_ids': [1872, 2983, 1992]}) response = self.client.delete("/folders/" + str(folder.id), headers={'Authorization': self.token}, data=request_body) self.assert404(response) self.assertIn('errors', response.json)
def test_update_plan_to_recurring_plan(self): self.before_each() s1 = self.subscriptions[0] s1.plan_id = 1 s1.expiration_date = datetime.datetime.utcnow() db_session_users.add(s1) db_session_users.commit() # recurring plan plan_id = 4 request_body = json.dumps({'plan_id': plan_id}) response = self.client.post( "/subscriptions/" + str(self.subscriptions[0].id), headers={'Authorization': self.admin_user_token}, data=request_body) self.assert200(response) self.assertIn("new_subscription", response.json) self.assertIsInstance(response.json["new_subscription"], dict) result_subscription = response.json["new_subscription"] self.assertEqual(result_subscription["plan_id"], plan_id) plan = db_session_users().query(Plan).filter_by(id=plan_id).first() self.assertEqual(result_subscription["stripe_id"], plan.stripe_id) self.assertEqual(result_subscription['status'], Subscription.ACTIVE_STATUS) self.assertEqual(result_subscription['status_reason'], Subscription.REACTIVATED_STATUS_REASON) self.assertIsNone(result_subscription['expiration_date'])
def test_delete_shared_folder_with_documents(self): self.before_each() folder = db_session_users.query(UserFolder).filter_by( user_id=self.user.id, name='test_folder').first() # share folder user_shared_folder = UserSharedFolderFactory(user_id=self.user.id, folder_id=folder.id, owner=True) db_session_users.add(user_shared_folder) db_session_users.commit() # add docs to folder user_folder_documents = [ UserFolderDocFactory(user_folder_id=folder.id, doc_id=1), UserFolderDocFactory(user_folder_id=folder.id, doc_id=2), ] db_session_users.add_all(user_folder_documents) db_session_users.commit() # delete the folder request_body = json.dumps({}) response = self.client.delete("/folders/" + str(folder.id), headers={'Authorization': self.token}, data=request_body) self.assert200(response) self.assertIn('msg', response.json)
def test_update_user_folder_with_new_documents(self): # create a folder user_folder = UserFolderFactory(user_id=self.user.id) db_session_users.add(user_folder) db_session_users.commit() db_session_users.refresh(user_folder) # add single doc to folder folder = db_session_users.query(UserFolder).filter_by( user_id=self.user.id).first() request_body = json.dumps({ 'document_ids': [1, 2, 3], 'folder_id': folder.id, }) response = self.client.post("/documents", headers={'Authorization': self.token}, data=request_body) self.assert200(response) self.assertIn('documents', response.json) self.assertEquals(response.json['documents'], { 'ids': [1, 2, 3], 'documents_added_to_folder': True })
def test_skip_flagged_document(self): doc_id = 3 # first write a doc for review ufd = UserFlaggedDocument({ 'issue_severity': 'review', 'issue_type': 'technical', 'field': 'title', 'notes': 'typo in title', 'user_id': self.user.id, 'doc_id': doc_id }) db_session_users.add(ufd) db_session_users.commit() db_session_users.refresh(ufd) # then post a status update to skipped flagged_data = json.dumps( {'flagged': { 'id': ufd.id, 'status': 'skipped' }}) response = self.client.post( "/documents/{}".format(doc_id), headers={'Authorization': self.qa_user_token}, data=flagged_data) self.assert200(response) self.assertIn('document', response.json) self.assertEquals(response.json['document']['id'], doc_id) self.assertEquals(response.json['document']['issue_severity'], 'review') self.assertEquals(response.json['document']['issue_type'], 'technical') self.assertEquals(response.json['document']['status'], 'skipped') db_session_users.refresh(ufd) self.assertEquals(ufd.status, 'skipped')
def test_remove_positive_tag_from_document(self): doc_id = 3 self.before_each_tags() user_doc_tag = UserDocumentTag({ 'user_tag_id': self.user_tags[0].id, 'is_positive': True, 'display_style': 'modal', 'doc_id': doc_id, 'user_id': self.user.id }) db_session_users.add(user_doc_tag) db_session_users.commit() request_data = { 'tag': { 'id': self.user_tags[0].id, 'is_positive': False, 'display_style': 'modal' } } response = self.client.post("/documents/{}".format(doc_id), headers={'Authorization': self.token}, data=json.dumps(request_data)) self.assert200(response) self.assertIn('document', response.json) for key in [ 'doc_id', 'user_id', 'user_tag_id', 'is_positive', 'display_style' ]: self.assertIn(key, response.json['document']) self.assertEquals(response.json['document']['id'], doc_id) self.assertEquals(response.json['document']['user_tag_id'], self.user_tags[0].id) self.assertEquals(response.json['document']['user_id'], self.user.id) self.assertFalse(response.json['document']['is_positive']) self.assertEquals(response.json['document']['display_style'], 'modal') # make sure it is updated (not new) in the db too db_session_users.refresh(user_doc_tag) self.assertFalse(user_doc_tag.is_positive) # now check that it does not show up in the get_document route response = self.client.get( "/documents/{}".format(doc_id), headers={'Authorization': self.token}, ) self.assert200(response) tag_ids = [t[0] for t in response.json['document']['tags']] self.assertNotIn(self.user_tags[0].id, tag_ids)
def test_update_annotation_task_topics(self): self.before_each() body_hash = { 'topics': { 'banking': {'topic_id': 1, 'topic_table': 'topics'}, 'lending': {'topic_id': 2, 'topic_table': 'topics'}, 'fintech': {'topic_id': 3, 'topic_table': 'topics'}, 'payments': {'topic_id': 4, 'topic_table': 'topics'}, } } request_body = json.dumps(body_hash) response = self.client.post("/annotation_tasks/"+str(self.tasks[1].id), headers={'Authorization': self.admin_user_token}, data=request_body) self.assert200(response) self.assertIn("annotation_task", response.json) self.assertIsInstance(response.json["annotation_task"], dict) task_result = response.json["annotation_task"] self.assertEqual(task_result['name'], 'foo') self.assertEqual(task_result['status'], AnnotationTask.ACTIVE_STATUS) self.assertIsInstance(task_result['topics'], dict) for key in ['banking', 'lending', 'fintech', 'payments']: self.assertIn(key, task_result['topics']) self.assertIsInstance(task_result['user_ids'], list) self.assertIsInstance(task_result['updated_at'], unicode) self.assertIsInstance(task_result['created_at'], unicode) self.assertIsInstance(task_result['config'], dict) self.assertIsInstance(task_result['id'], int) self.assertNotEqual(task_result['id'], self.tasks[0].id) self.assertIsNone(task_result['active_task_id']) self.assertIsInstance(task_result['old_tasks'], list) self.assertEqual(len(task_result['old_tasks']), 1) self.assertEqual(task_result['old_tasks'][0]['active_task_id'], task_result['id']) self.assertEqual(task_result['old_tasks'][0]['status'], AnnotationTask.INACTIVE_STATUS) # now make a second update and make sure they both stack correctly for i in xrange(1, 5): j1 = AnnotationJob({ "doc_id": 1, "priority": 1.0, "status": AnnotationJob.QUEUED_STATUS, "annotation_task_id": task_result['id'] }) db_session_users.add(j1) db_session_users.commit() body_hash["topics"]["foo"] = {'topic_id': 5, 'topic_table': 'topics'} request_body = json.dumps(body_hash) response = self.client.post("/annotation_tasks/" + str(task_result['id']), headers={'Authorization': self.admin_user_token}, data=request_body) self.assert200(response) self.assertEqual(len(response.json["annotation_task"]['old_tasks']), 2) self.assertIsInstance(task_result['term_sampling_group_ids'], list) self.assertEqual(len(task_result['term_sampling_group_ids']), 0)
def before_each(self): # n.b. cleaning this out due to other test interference db_session_users.query(UserSharedFolder).delete() db_session_users.query(UserFolderDocument).delete() db_session_users.query(UserFolder).delete() # create a folder self.user_folder = UserFolder({ "name": 'test_folder', 'user_id': self.user.id, }) db_session_users.add(self.user_folder) db_session_users.commit() db_session_users.refresh(self.user_folder)
def test_get_annotation_tasks_by_contributor_type(self): self.before_each() first_task = self.tasks[0] first_task.type = "contributor" first_task.is_contributor_task = True db_session_users.add(first_task) db_session_users.commit() response = self.client.get("/annotation_tasks", headers={'Authorization': self.contributor_user_token}) self.assert200(response) self.assertIn("annotation_tasks", response.json) result_tasks = response.json["annotation_tasks"] self.assertIsInstance(result_tasks, list) self.assertEqual(len(result_tasks), 1) self.assertEqual(result_tasks[0]['id'], first_task.id)
def before_each(self, skip_user_entries=False): db_session_users.query(UserContributorPoint).delete() db_session_users.query(ContributorPointType).delete() self.contributor_point_types = [] for contributor_type in CONTRIBUTOR_TYPE_TEMPLATES: self.contributor_point_types.append( ContributorPointType(contributor_type)) if not skip_user_entries: # add one event for each type for s in self.contributor_point_types: s.user_contributor_points.append( UserContributorPoint({ "user_id": self.user.id, 'num_points': s.points_per_action })) # for weekly/anytime frequencies, add another basic option if s.frequency != 'onboarding': # add another recent option s.user_contributor_points.append( UserContributorPoint({ "user_id": self.user.id, 'num_points': s.points_per_action })) db_session_users.add_all(self.contributor_point_types) db_session_users.commit() if not skip_user_entries: # add another option from a year ago for anytime/weekly types that will get ignored for weekly but returned for anytime for s in self.contributor_point_types: if s.frequency != 'onboarding': one_year_ago = dt.datetime.now() - dt.timedelta(weeks=52) ucp = UserContributorPoint({ "user_id": self.user.id, 'num_points': s.points_per_action, 'contributor_point_type_id': s.id }) db_session_users.add(ucp) db_session_users.commit() ucp.created_at = one_year_ago # n.b. need to do it like this to fudge the date db_session_users.add(ucp) db_session_users.commit() db_session_users.refresh(ucp)
def test_get_all_subscriptions(self): self.before_each() response = self.client.get( "/subscriptions/all", headers={'Authorization': self.admin_user_token}) self.assert200(response) self.assertIn("all_subscriptions", response.json) self.assertIsInstance(response.json["all_subscriptions"], list) self.assertEqual(len(response.json["all_subscriptions"]), 1) subscription = response.json["all_subscriptions"][0] self.assertEqual(subscription["user_id"], self.user.id) self.assertEqual(subscription["plan_id"], 4) self.assertEqual(subscription["payment_type"], "stripe") expected_user = db_session_users.query(User).filter_by( id=subscription['user_id']).first() expected_plan = db_session_users.query(Plan).filter_by( id=subscription['plan_id']).first() self.assertEqual(subscription["first_name"], expected_user.first_name) self.assertEqual(subscription["last_name"], expected_user.last_name) self.assertEqual(subscription["email"], expected_user.email) self.assertEqual(subscription["roles"], expected_user.roles) self.assertEqual(subscription["plan_name"], expected_plan.name) # add one more subscription new_subscription = Subscription({ 'stripe_id': 'free_trial', 'user_id': self.qa_user.id, 'plan_id': 1, 'latest': True }) db_session_users.add(new_subscription) db_session_users.commit() response = self.client.get( "/subscriptions/all", headers={'Authorization': self.admin_user_token}) self.assert200(response) self.assertIn("all_subscriptions", response.json) self.assertIsInstance(response.json["all_subscriptions"], list) self.assertEqual(len(response.json["all_subscriptions"]), 2)
def test_update_annotation_task_topics_but_no_jobs(self): self.before_each() db_session_users.query(AnnotationJob).delete() db_session_users.add(AnnotationTaskTermSamplingGroup({'annotation_task_id': self.tasks[0].id, 'term_sampling_group_id': 1})) db_session_users.commit() request_body = json.dumps({ 'name': 'watman', 'topics': { 'banking': {'topic_id': 1, 'topic_table': 'topics'}, 'lending': {'topic_id': 2, 'topic_table': 'topics'}, 'fintech': {'topic_id': 3, 'topic_table': 'topics'}, 'payments': {'topic_id': 4, 'topic_table': 'topics'}, }, 'user_ids': [self.user.id], 'term_sampling_group_ids': [2], 'config': { "foo": "bar" } }) response = self.client.post("/annotation_tasks/"+str(self.tasks[0].id), headers={'Authorization': self.admin_user_token}, data=request_body) self.assert200(response) self.assertIn("annotation_task", response.json) self.assertIsInstance(response.json["annotation_task"], dict) task_result = response.json["annotation_task"] self.assertEqual(task_result['name'], 'watman') self.assertEqual(task_result['status'], AnnotationTask.ACTIVE_STATUS) self.assertIsInstance(task_result['topics'], dict) for key in ['banking', 'lending']: self.assertIn(key, task_result['topics']) self.assertIsInstance(task_result['user_ids'], list) self.assertEqual(len(task_result['user_ids']), 1) self.assertIn(self.user.id, task_result['user_ids']) self.assertIsInstance(task_result['updated_at'], unicode) self.assertIsInstance(task_result['created_at'], unicode) self.assertIsInstance(task_result['config'], dict) self.assertIn('foo', task_result['config']) self.assertIsInstance(task_result['id'], int) self.assertEqual(task_result['id'], self.tasks[0].id) self.assertIsNone(task_result['active_task_id']) self.assertIsInstance(task_result['old_tasks'], list) self.assertEqual(len(task_result['old_tasks']), 0) self.assertIsInstance(task_result['term_sampling_group_ids'], list) self.assertEqual(len(task_result['term_sampling_group_ids']), 1) self.assertIn(2, task_result['term_sampling_group_ids']) self.assertNotIn(1, task_result['term_sampling_group_ids'])
def test_share_user_folder_multiple_users(self): self.before_each() # first lets create a shared folder shared_folder = UserSharedFolder({ "user_id": self.user.id, "folder_id": self.user_folder[0].id, "owner": True, "editor": False, "viewer": False }) db_session_users.add(shared_folder) db_session_users.commit() # now lets add users users = [{ "id": 2, "editor": False, "viewer": True }, { "id": 3, "editor": True, "viewer": False }, { "id": 4, "editor": False, "viewer": True }] request_body = json.dumps({"share_add_users": True, "users": users}) # test err response = self.client.post("/folders/" + str(self.user_folder[1].id), headers={'Authorization': self.token}, data=request_body) self.assertIn("errors", response.json) # test success request_body = json.dumps({"share_add_users": True, "users": users}) response = self.client.post("/folders/" + str(self.user_folder[0].id), headers={'Authorization': self.token}, data=request_body) self.assert200(response) self.assertTrue(response.json['folder_shared_with_users'])
def test_get_annotation_tasks_by_annotation_type(self): self.before_each() first_task = self.tasks[0] first_task.type = "contributor" first_task.is_contributor_task = True db_session_users.add(first_task) second_task = self.tasks[1] second_task.type = AnnotationTask.TOPIC_ANNOTATION_TYPE second_task.is_contributor_task = True second_task.user_ids = [self.contributor_user.id] db_session_users.add(second_task) new_task_no_flag = AnnotationTask({ 'name': 'watman', 'topics': { 'banking': {'topic_id': 1, 'topic_table': 'topics'}, 'lending': {'topic_id': 2, 'topic_table': 'topics'}, }, 'type': AnnotationTask.TOPIC_ANNOTATION_TYPE, 'is_contributor_task': False, 'user_ids': [self.contributor_user.id] }) db_session_users.add(new_task_no_flag) db_session_users.commit() db_session_users.refresh(new_task_no_flag) response = self.client.get("/annotation_tasks?type=topic_annotation", headers={'Authorization': self.contributor_user_token}) self.assert200(response) self.assertIn("annotation_tasks", response.json) result_tasks = response.json["annotation_tasks"] self.assertIsInstance(result_tasks, list) self.assertEqual(len(result_tasks), 2) self.assertEqual(result_tasks[0]['id'], second_task.id) self.assertEqual(result_tasks[1]['id'], new_task_no_flag.id)
def test_update_user_folder_with_existing_documents(self): # create a folder user_folder = UserFolderFactory(user_id=self.user.id) db_session_users.add(user_folder) db_session_users.commit() db_session_users.refresh(user_folder) # add a document to the folder folder = db_session_users.query(UserFolder).filter_by( user_id=self.user.id).first() user_folder_documents = [ UserFolderDocument({ "user_folder_id": folder.id, 'doc_id': 1, }), UserFolderDocument({ "user_folder_id": folder.id, 'doc_id': 2, }), UserFolderDocument({ "user_folder_id": folder.id, 'doc_id': 3, }), ] db_session_users.add_all(user_folder_documents) db_session_users.commit() # add the doc that already exists in the folder request_body = json.dumps({ 'document_ids': [1, 2, 3], 'folder_id': folder.id, }) response = self.client.post("/documents", headers={'Authorization': self.token}, data=request_body) self.assertStatus(response, 409) self.assertIn('errors', response.json)
def test_update_share_permissions(self): self.before_each() # first lets create a shared folder shared_folder = UserSharedFolder({ "user_id": self.user.id, "folder_id": self.user_folder[0].id, "owner": True, "editor": False, "viewer": False }) db_session_users.add(shared_folder) db_session_users.commit() # now lets add users users = [{ "id": 2, "editor": False, "viewer": True }, { "id": 3, "editor": False, "viewer": True }, { "id": 4, "editor": True, "viewer": False }] # share folder with users request_body = json.dumps({"share_add_users": True, "users": users}) response = self.client.post("/folders/" + str(self.user_folder[0].id), headers={'Authorization': self.token}, data=request_body) self.assert200(response) self.assertTrue(response.json['folder_shared_with_users']) # test err request_body = json.dumps({ "update_share_permissions": True, "users": users, "removed_users": [] }) response = self.client.post("/folders/" + str(self.user_folder[1].id), headers={'Authorization': self.token}, data=request_body) self.assertIn("errors", response.json) # test success request_body = json.dumps({ "update_share_permissions": True, "users": users, "removed_users": [] }) response = self.client.post("/folders/" + str(self.user_folder[0].id), headers={'Authorization': self.token}, data=request_body) self.assert200(response) self.assertTrue(response.json['shared_folder_updated']) # test add users and update permissions users = [ { "id": 2, "editor": True, "viewer": False }, { "id": 3, "editor": True, "viewer": False }, { "id": 4, "editor": False, "viewer": True }, { "id": 5, # new user "editor": True, "viewer": False } ] request_body = json.dumps({ "update_share_permissions": True, "users": users, "removed_users": [] }) response = self.client.post("/folders/" + str(self.user_folder[0].id), headers={'Authorization': self.token}, data=request_body) self.assert200(response) self.assertTrue(response.json['shared_folder_updated']) # test explict removal of users removed_users = [4, 5] request_body = json.dumps({ "update_share_permissions": True, "users": [], "removed_users": removed_users }) response = self.client.post("/folders/" + str(self.user_folder[0].id), headers={'Authorization': self.token}, data=request_body) self.assert200(response) self.assertTrue(response.json['shared_folder_updated'])
def test_update_research_mode_expanded_view(self): self.before_each() # check initial topic annotation initial_topic_ant = db_session_users.query(TopicAnnotation)\ .filter_by(id=self.topic_annotations[0].id)\ .first() self.assertTrue(initial_topic_ant.is_positive) self.assertIsNone(initial_topic_ant.admin_notes) self.assertEqual(initial_topic_ant.user_id, self.users[0].id) self.assertEqual(initial_topic_ant.details, {}) # make update to topic_annotation request_body = json.dumps({ 'topic_annotation_id': self.topic_annotations[0].id, 'topic_annotation_updates': { "is_positive": False, "user_id": self.users[1].id, "admin_notes": 'this tation was SUPER hard bruh' } }) response = self.client.post( '/aggregated_annotations/research/' + str(self.aggregated_annotations[0].id), headers={'Authorization': self.admin_user_token}, data=request_body) # check response self.assert200(response) self.assertTrue(response.json['success']) # check that update occurred updated_topic_ant = db_session_users.query(TopicAnnotation)\ .filter_by(id=self.topic_annotations[0].id)\ .first() updated_ant_job = db_session_users.query(AnnotationJob)\ .filter_by(id=self.jobs[0].id)\ .first() self.assertFalse(updated_topic_ant.is_positive) self.assertEqual(updated_topic_ant.admin_notes, 'this tation was SUPER hard bruh') self.assertEqual(updated_topic_ant.user_id, self.users[1].id) self.assertEqual(updated_ant_job.user_id, self.users[1].id) self.assertNotEqual(updated_topic_ant.details, {}) self.assertEqual( updated_topic_ant.details['previous_annotators'][0]['is_positive'], True) self.assertEqual( updated_topic_ant.details['previous_annotators'][0]['user_id'], self.users[0].id) # check initial annotation job (gold standard annotation_job) and initial agg_annotation containing this job initial_ant_job = db_session_users.query(AnnotationJob)\ .filter_by(id=self.jobs[0].id)\ .first() self.assertEqual(initial_ant_job.arbitrary_tags, ['tag_0']) self.assertIsNone(initial_ant_job.user_difficulty) self.assertEqual(initial_ant_job.annotation_task_id, self.tasks[0].id) self.assertEqual(self.aggregated_annotations[0].arbitrary_tags, ["tag_1", "tag_2"]) self.assertEqual(self.aggregated_annotations[0].gold_difficulty, 'easy') # make update to annotation job for arbitrary_tags request_body = json.dumps({ 'topic_annotation_id': self.topic_annotations[0].id, 'annotation_job_updates': { 'arbitrary_tags': ['tag2', 'NOT ALLOWED TAG'] } }) response = self.client.post( '/aggregated_annotations/research/' + str(self.aggregated_annotations[0].id), headers={'Authorization': self.admin_user_token}, data=request_body) # check response self.assert200(response) self.assertTrue(response.json['success']) # check that update occurred updated_ant_job = db_session_users.query(AnnotationJob)\ .filter_by(id=self.jobs[0].id)\ .first() self.assertEqual( updated_ant_job.arbitrary_tags, ['tag2']) # since other tag not in AnnotationTaskTopicGroup self.assertIsNone(updated_ant_job.user_difficulty) # check that aggregated_annotation[0] had arbitrary_tags updated as well db_session_users.refresh(self.aggregated_annotations[0]) self.assertEqual(self.aggregated_annotations[0].arbitrary_tags, ['tag2']) # make second update to same annotation job for user_difficulty request_body = json.dumps({ 'topic_annotation_id': self.topic_annotations[0].id, 'annotation_job_updates': { 'user_difficulty': 'medium' } }) response = self.client.post( '/aggregated_annotations/research/' + str(self.aggregated_annotations[0].id), headers={'Authorization': self.admin_user_token}, data=request_body) # check response self.assert200(response) self.assertTrue(response.json['success']) # check that update occurred updated_ant_job = db_session_users.query(AnnotationJob)\ .filter_by(id=self.jobs[0].id)\ .first() self.assertEqual(updated_ant_job.arbitrary_tags, ['tag2']) # same as before self.assertEqual(updated_ant_job.user_difficulty, 'medium') # update that occurred here # check that aggregated_annotation[0] had gold_difficulty updated as well db_session_users.refresh(self.aggregated_annotations[0]) self.assertEqual(self.aggregated_annotations[0].gold_difficulty, 'medium') # make task that contains this job point to new task as its active task (which is in same task group) self.tasks[0].active_task_id = self.tasks[1].id db_session_users.add(self.tasks[0]) db_session_users.commit() db_session_users.refresh(self.tasks[0]) # update task group to no longer contain task that contains initial_ant_job (but does contain its active task) self.task_groups[0].annotation_task_ids = [self.tasks[1].id] db_session_users.add(self.task_groups[0]) db_session_users.commit() db_session_users.refresh(self.task_groups[0]) # do update to tags for job whose parent task no longer in task group (but whose active task is) request_body = json.dumps({ 'topic_annotation_id': self.topic_annotations[0].id, 'annotation_job_updates': { 'arbitrary_tags': ['tag1', 'NOT ALLOWED TAG'] } }) response = self.client.post( '/aggregated_annotations/research/' + str(self.aggregated_annotations[0].id), headers={'Authorization': self.admin_user_token}, data=request_body) # check response self.assert200(response) self.assertTrue(response.json['success']) # check that update occurred updated_ant_job = db_session_users.query(AnnotationJob)\ .filter_by(id=self.jobs[0].id)\ .first() self.assertEqual( updated_ant_job.arbitrary_tags, ['tag1']) # since other tag not in AnnotationTaskTopicGroup
def test_delete_user_with_team_folders(self): # create a team team = UserTeamFactory(name='foo_team_2') db_session_users.add(team) db_session_users.commit() # add user to team request_body = json.dumps({'team_id': team.id}) response = self.client.post( '/users/' + self.new_user.email, headers={'Authorization': self.new_user_token}, data=request_body) self.assert200(response) self.assertDictContainsSubset( { 'email': self.new_user.email, 'first_name': self.new_user.first_name, 'last_name': self.new_user.last_name, 'id': self.new_user.id, 'team_id': team.id }, response.json.get('user')) # add user to folder request_body = json.dumps({'name': 'foo_folder'}) response = self.client.post( '/folders', headers={'Authorization': self.new_user_token}, data=request_body) self.assert200(response) self.assertDictContainsSubset( { 'user_id': self.new_user.id, 'name': 'foo_folder' }, response.json) folder_id = response.json['id'] # share folder with team request_body = json.dumps({ 'share': True, 'owner': True, 'user_id': self.new_user.id }) response = self.client.post( '/folders/' + str(folder_id), headers={'Authorization': self.new_user_token}, data=request_body) self.assert200(response) self.assertDictContainsSubset( { 'user_id': self.new_user.id, 'folder_id': folder_id, 'owner': True, }, response.json) # now delete the user response = self.client.delete( '/delete_user/' + self.new_user.email, headers={'Authorization': self.admin_user_token}) self.assert200(response) self.assertEqual( response.json, {'msg': self.new_user.email + ' successfully deleted'})
def before_each(self, with_annotations=False): db_session_users.query(AnnotationTaskTermSamplingGroup).delete() db_session_users.query(TopicAnnotation).delete() db_session_users.query(AnnotationJob).delete() db_session_users.query(AnnotationTask).delete() db_session_users.query(AnnotationTaskTopicGroup).delete() t1 = AnnotationTask({ 'name': 'bar', 'topics': { 'banking': {'topic_id': 1, 'topic_table': 'topics'}, 'lending': {'topic_id': 2, 'topic_table': 'topics'}, }, 'type': 'topic_annotation' }) t2 = AnnotationTask({ 'name': 'foo', 'topics': { 'fintech': {'topic_id': 3, 'topic_table': 'topics'}, 'payments': {'topic_id': 4, 'topic_table': 'topics'}, }, "user_ids": [self.user.id, self.new_user.id, self.qa_user.id], "config": { "dummy-value": 1 } }) # n.b. add a third task that will be totally ignored t3 = AnnotationTask({ 'name': 'annotate any doc', 'topics': { 'banking': {'topic_id': 1, 'topic_table': 'topics'}, 'lending': {'topic_id': 2, 'topic_table': 'topics'}, }, 'type': AnnotationTask.ANNOTATE_ANY_DOCUMENT_TYPE }) self.tasks = [t1, t2] self.jobs = [] for i in xrange(1, 5): j1 = AnnotationJob({ "doc_id": 1, "priority": 1.0, "status": AnnotationJob.QUEUED_STATUS }) j1.annotation_task = t1 j2 = AnnotationJob({ "doc_id": 1, "priority": 1.0, "status": AnnotationJob.QUEUED_STATUS }) j2.annotation_task = t2 self.jobs.append(j1) self.jobs.append(j2) if with_annotations: ta1 = TopicAnnotation({"doc_id": 1, "topic_name": "test", "is_positive": True, "user_id": self.user.id}) ta1.annotation_job = j1 ta1.annotation_task = t1 ta2 = TopicAnnotation({"doc_id": 3, "topic_name": "test2", "is_positive": True, "user_id": self.user.id}) ta2.annotation_job = j2 ta2.annotation_task = t2 db_session_users.add_all([ta1, ta2]) db_session_users.add_all(self.tasks) db_session_users.add(t3) db_session_users.add_all(self.jobs) db_session_users.commit() for t in self.tasks: db_session_users.refresh(t)
def test_update_annotation_task_is_onboarding_task(self): self.before_each() db_session_users.query(AnnotationJob).delete() # make annotation task group to contain the onboarding task task_group = AnnotationTaskTopicGroup({ 'name': 'task_group_1', 'description': 'onboarding task group', 'arbitrary_tags': ["tag1", "tag2"], 'topic_id': 1, 'gold_annotator_user_ids': [1, 2] }) self.task_groups = [task_group] db_session_users.add_all(self.task_groups) db_session_users.commit() for group in self.task_groups: db_session_users.refresh(group) # create onboarding annotation task onboarding_task = AnnotationTask({ 'name': 'onboarding task', 'topics': { 'lending': {'topic_id': 2, 'topic_table': 'topics'}, }, 'type': AnnotationTask.TOPIC_ANNOTATION_TYPE, 'is_training_task': True, 'annotation_task_topic_group_id': self.task_groups[0].id, 'user_ids': [[self.user.id, self.new_user.id, self.qa_user.id]] }) db_session_users.add(onboarding_task) db_session_users.commit() db_session_users.refresh(onboarding_task) # create job for this onboarding task (so that if this is not an onboarding task, new task will be created) onboarding_job = AnnotationJob({ "doc_id": 1, "priority": 1.0, "status": AnnotationJob.QUEUED_STATUS, "is_gold_evaluation": True }) onboarding_job.annotation_task = onboarding_task db_session_users.add(onboarding_job) db_session_users.commit() db_session_users.refresh(onboarding_job) # make update to users request_body = json.dumps({ 'user_ids': [self.user.id] }) response = self.client.post('/annotation_tasks/' + str(onboarding_task.id), headers={'Authorization': self.admin_user_token}, data=request_body) # check result - no new task should be created, because this is an onboarding task self.assert200(response) self.assertIn('annotation_task', response.json) self.assertIsInstance(response.json['annotation_task'], dict) task_result = response.json['annotation_task'] self.assertEqual(task_result['user_ids'], [self.user.id]) self.assertEqual(task_result['id'], onboarding_task.id) # check that no new annotation_task was created # update task to be not-onboarding onboarding_task.is_training_task = False db_session_users.add(onboarding_task) db_session_users.commit() db_session_users.refresh(onboarding_task) # make another user_ids update request_body = json.dumps({ 'user_ids': [self.user.id, self.new_user.id] }) response = self.client.post('/annotation_tasks/' + str(onboarding_task.id), headers={'Authorization': self.admin_user_token}, data=request_body) # confirm that new task was created this time self.assert200(response) self.assertIn('annotation_task', response.json) self.assertIsInstance(response.json['annotation_task'], dict) task_result = response.json['annotation_task'] self.assertEqual(task_result['user_ids'], [self.user.id, self.new_user.id]) self.assertNotEqual(task_result['id'], onboarding_task.id) # check that new annotation_task was created