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