def before_each(self):
db_session_users.query(Subscription).delete()
self.subscriptions = [
Subscription({
'stripe_id': 'sub_BJJGmBDQP5Nblr',
'user_id': self.user.id,
'plan_id': 4,
'payment_type': 'stripe',
'start_date': self.start_date,
'latest': True,
'status': 'active',
'expiration_date': self.expiration_date
}),
Subscription({
'stripe_id': 'free_trial',
'user_id': self.user.id,
'plan_id': 1,
'latest': False,
'start_date': self.start_date,
'end_date': self.end_date,
'modified_by_user_id': 1,
'status': 'active',
'expiration_date': self.expiration_date
})
]
db_session_users.add_all(self.subscriptions)
db_session_users.commit()
def test_mark_document_as_bookmarked(self):
request_body = json.dumps({'document_ids': [3, 4], 'bookmarked': True})
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': [3, 4],
'bookmarked': True
})
user_document = db_session_users.query(UserDocument).filter_by(
doc_id=3, user_id=self.user.id).first()
self.assertIsNotNone(user_document)
self.assertTrue(user_document.bookmarked)
user_document_two = db_session_users.query(UserDocument).filter_by(
doc_id=4, user_id=self.user.id).first()
self.assertIsNotNone(user_document_two)
self.assertTrue(user_document_two.bookmarked)
# now check that it shows up in the get_document route
response = self.client.get(
"/documents/{}".format(3),
headers={'Authorization': self.token},
)
self.assert200(response)
self.assertIn('document', response.json)
for key in ['tags', 'bookmarked', 'read']:
self.assertIn(key, response.json['document'])
self.assertTrue(response.json['document']['bookmarked'])
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_create_rating_new_search_query(self):
self.before_each()
search_args = {"agency_id": 80}
request_body = json.dumps({
'search_args': search_args,
'doc_id': 2,
'is_relevant': True
})
response = self.client.post("/rated_results",
headers={'Authorization': self.token},
data=request_body)
self.assert200(response)
lookup_hash = hashlib.sha1(json.dumps(search_args)).hexdigest()
entry = db_session_users.query(SearchQuery).filter_by(
search_args_hash=lookup_hash).first()
self.assertIsNotNone(entry)
self.assertFalse(entry.is_arbitrary_query)
self.assertEqual(entry.display_name, "Comptroller of the Currency")
user_rated_result = db_session_users.query(
UserSearchResultRating).filter_by(
user_id=self.user.id, doc_id=2,
search_query_id=entry.id).first()
self.assertIsNotNone(user_rated_result)
self.assertTrue(user_rated_result.is_relevant)
def test_create_annotation_task_with_task_group(self):
self.before_each()
# make an AnnotationTaskTopicGroup that contains first two annotation tasks in self.tasks
task_group = AnnotationTaskTopicGroup({
'name': 'task_group_1',
'description': 'first task group',
'annotation_task_ids': [self.tasks[0].id, self.tasks[1].id],
'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 two new annotation tasks that point point to this existing annotation_task_topic_group
request_body_1 = json.dumps({
'name': 'wat_1',
'topics': {
'banking': {'topic_id': 1, 'topic_table': 'topics'},
'lending': {'topic_id': 2, 'topic_table': 'topics'}
},
'user_ids': [self.user.id],
'term_sampling_group_ids': [1],
'annotation_task_topic_group_id': self.task_groups[0].id
})
request_body_2 = json.dumps({
'name': 'wat_2',
'topics': {
'banking': {'topic_id': 1, 'topic_table': 'topics'},
'lending': {'topic_id': 2, 'topic_table': 'topics'}
},
'user_ids': [self.user.id],
'term_sampling_group_ids': [1],
'annotation_task_topic_group_id': self.task_groups[0].id
})
response_1 = self.client.post("/annotation_tasks", headers={'Authorization': self.admin_user_token},
data=request_body_1)
task_result_1 = response_1.json["annotation_task"]
response_2 = self.client.post("/annotation_tasks", headers={'Authorization': self.admin_user_token},
data=request_body_2)
task_result_2 = response_2.json["annotation_task"]
for group in self.task_groups:
db_session_users.refresh(group)
# check that these two tasks point to task group correctly
task_from_db_1 = db_session_users.query(AnnotationTask).filter_by(id=task_result_1['id']).first()
task_from_db_2 = db_session_users.query(AnnotationTask).filter_by(id=task_result_2['id']).first()
self.assertEqual(task_from_db_1.annotation_task_topic_group_id, self.task_groups[0].id)
self.assertEqual(task_from_db_2.annotation_task_topic_group_id, self.task_groups[0].id)
# check that ORM query on the annotation_task_topic_group now gives the these two annotation tasks
task_group_from_db = db_session_users.query(AnnotationTaskTopicGroup)\
.filter_by(id=self.task_groups[0].id)\
.first()
self.assertEqual({task_from_db_1, task_from_db_2}, set(task_group_from_db.annotation_tasks))
def test_follow_multiple_agencies(self):
request_body = json.dumps({
'agencies': [{
'id': 466,
'following': True
}, {
'id': 80,
'following': True
}, {
'id': 538,
'following': True
}],
})
response = self.client.post("/agencies",
headers={'Authorization': self.token},
data=request_body)
self.assert200(response)
self.assertIn('agencies', response.json)
self.assertEquals(
response.json, {
'agencies': [{
'id': 466,
'following': True
}, {
'id': 80,
'following': True
}, {
'id': 538,
'following': True
}],
'success':
True
})
user_agency = db_session_users.query(UserAgency).filter_by(
agency_id=466, user_id=self.user.id).first()
self.assertIsNotNone(user_agency)
self.assertTrue(user_agency.following)
user_agency_two = db_session_users.query(UserAgency).filter_by(
agency_id=80, user_id=self.user.id).first()
self.assertIsNotNone(user_agency_two)
self.assertTrue(user_agency_two.following)
user_agency_three = db_session_users.query(UserAgency).filter_by(
agency_id=538, user_id=self.user.id).first()
self.assertIsNotNone(user_agency_three)
self.assertTrue(user_agency_three.following)
# try to read it back
response = self.client.get('/agencies?following=true',
headers={'Authorization': self.token})
self.assert200(response)
self.assertIn('agencies', response.json)
def before_each(self):
db_session_users.query(InsightsTable).delete()
self.data = [
InsightsTable({
'slug': 'enforcement-action-12months',
'name': 'enforcements_pie',
'raw_data': {"table": [["agency", "count"], ["TREAS", 219], ["OCC", 109], ["NYSE", 63], ["CFPB", 394], ["FRS", 89], ["FDIC", 270], ["FTC", 208], ["SEC", 1885], ["FINRA", 1236]], "tuples": [["TREAS", 219], ["OCC", 109], ["NYSE", 63], ["CFPB", 394], ["FRS", 89], ["FDIC", 270], ["FTC", 208], ["SEC", 1885], ["FINRA", 1236]]},
'csv_table': "agency,count\nTREAS,219\nOCC,109\nNYSE,63\nCFPB,394\nFRS,89\nFDIC,270\nFTC,208\nSEC,1885\nFINRA,1236"
})
]
db_session_users.add_all(self.data)
db_session_users.commit()
def test_mark_document_as_unbookmarked(self):
# first lets mark this document/user pair as bookmarked, so the test can try marking it as unbookmarked
user_documents = [
UserDocument({
'user_id': self.user.id,
'doc_id': 3,
'bookmarked': True
}),
UserDocument({
'user_id': self.user.id,
'doc_id': 4,
'bookmarked': True
}),
UserDocument({
'user_id': self.user.id,
'doc_id': 5,
'bookmarked': True
}),
]
db_session_users.add_all(user_documents)
db_session_users.commit()
request_body = json.dumps({
'document_ids': [3, 4, 5],
'bookmarked': False
})
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': [3, 4, 5],
'bookmarked': False
})
user_document = db_session_users.query(UserDocument).filter_by(
doc_id=3, user_id=self.user.id).first()
self.assertIsNotNone(user_document)
self.assertFalse(user_document.bookmarked)
user_document_two = db_session_users.query(UserDocument).filter_by(
doc_id=4, user_id=self.user.id).first()
self.assertIsNotNone(user_document_two)
self.assertFalse(user_document_two.bookmarked)
user_document_three = db_session_users.query(UserDocument).filter_by(
doc_id=5, user_id=self.user.id).first()
self.assertIsNotNone(user_document_three)
self.assertFalse(user_document_three.bookmarked)
def test_create_contributor_point_weekly(self):
self.before_each()
short_name = 'rateresult'
request_body = json.dumps({"short_name": short_name})
cp = db_session_users.query(ContributorPointType).filter_by(
short_name=short_name).first()
today = dt.datetime.utcnow().date()
beginning_of_today = dt.datetime(today.year,
today.month,
today.day,
tzinfo=tz.tzutc())
week_start = beginning_of_today - dt.timedelta(
days=beginning_of_today.weekday())
for x in range(3, 16):
response = self.client.post("/contributor_points",
headers={'Authorization': self.token},
data=request_body)
self.assert200(response)
self.assertTrue(response.json['added'])
num_entries = db_session_users.query(UserContributorPoint) \
.filter_by(user_id=self.user.id, contributor_point_type_id=cp.id) \
.filter(UserContributorPoint.created_at > week_start).count()
self.assertEqual(num_entries, x)
# now try to add it a 16th time and verify there were no new entries written
response = self.client.post("/contributor_points",
headers={'Authorization': self.token},
data=request_body)
self.assert200(response)
self.assertFalse(response.json['added'])
num_entries = db_session_users.query(UserContributorPoint)\
.filter_by(user_id=self.user.id, contributor_point_type_id=cp.id)\
.filter(UserContributorPoint.created_at > week_start).count()
self.assertEqual(num_entries, 15)
# now try and add it once again for another user
response = self.client.post(
"/contributor_points",
headers={'Authorization': self.new_user_token},
data=request_body)
self.assert200(response)
self.assertTrue(response.json['added'])
num_entries = db_session_users.query(UserContributorPoint)\
.filter_by(user_id=self.new_user.id, contributor_point_type_id=cp.id)\
.filter(UserContributorPoint.created_at > week_start).count()
self.assertEqual(num_entries, 1)
def test_delete_annotation_task_with_topic_annotations(self):
self.before_each(with_annotations=True)
request_body = json.dumps({})
response = self.client.delete("/annotation_tasks/"+str(self.tasks[1].id), headers={'Authorization': self.admin_user_token}, data=request_body)
self.assert400(response)
self.assertIn("errors", response.json)
self.assertEqual(response.json["errors"], "Annotations exist for this task")
self.assertIsNotNone(db_session_users.query(AnnotationTask).filter_by(id=self.tasks[1].id).first())
request_body = json.dumps({"delete_with_annotations": True})
response = self.client.delete("/annotation_tasks/"+str(self.tasks[1].id), headers={'Authorization': self.admin_user_token}, data=request_body)
self.assert200(response)
self.assertTrue(response.json["success"])
self.assertIsNone(db_session_users.query(AnnotationTask).filter_by(id=self.tasks[1].id).first())
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_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_user_emails_by_admin_user(self):
fields = [
User.email, User.enabled, User.first_name, User.last_name,
User.company, User.team_id, User.industry, User.discipline,
User.level, User.properties, User.roles, User.id, User.suspended,
User.suspended_reason, User.created_at
]
all_users = [{
"email": u[0],
"enabled": u[1],
"first_name": u[2],
"last_name": u[3],
"company": u[4],
"team_id": u[5],
"industry": u[6],
"discipline": u[7],
"level": u[8],
"properties": u[9],
"roles": u[10],
'id': u[11],
"suspended": u[12],
"suspended_reason": u[13],
"created_at": unicode(u[14]),
} for u in db_session_users.query(*fields).all()]
response = self.client.get(
"/users", headers={'Authorization': self.admin_user_token})
self.assert200(response)
self.assertIn('users', response.json)
self.assertIsInstance(response.json['users'], list)
self.assertEqual(response.json['users'], all_users)
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_delete_annotation_task_no_topic_annotations(self):
self.before_each()
request_body = json.dumps({})
response = self.client.delete("/annotation_tasks/"+str(self.tasks[1].id), headers={'Authorization': self.admin_user_token}, data=request_body)
self.assert200(response)
self.assertTrue(response.json["success"])
self.assertIsNone(db_session_users.query(AnnotationTask).filter_by(id=self.tasks[1].id).first())
def test_delete_document_from_folder(self):
self.before_each()
# add docs 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,
}),
UserFolderDocument({
"user_folder_id": folder.id,
'doc_id': 2,
}),
]
db_session_users.add_all(user_folder_documents)
db_session_users.commit()
# delete docs in the folder
request_body = json.dumps({'document_ids': [1, 2]})
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_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_delete_saved_search(self):
self.before_each()
delete_id = db_session_users.query(UserSavedSearch).all()[1].id
response = self.client.delete("/saved_searches/" + str(delete_id),
headers={'Authorization': self.token})
self.assert200(response)
self.assertIn("deleted", response.json)
self.assertTrue(response.json["deleted"])
def test_create_contributor_point_anytime(self):
self.before_each()
short_name = 'reportprob'
request_body = json.dumps({"short_name": short_name})
cp = db_session_users.query(ContributorPointType).filter_by(
short_name=short_name).first()
# add up to 25 as a shallow confirmation that there is no limit on this one
for x in range(4, 25):
response = self.client.post("/contributor_points",
headers={'Authorization': self.token},
data=request_body)
self.assert200(response)
self.assertTrue(response.json['added'])
num_entries = db_session_users.query(UserContributorPoint) \
.filter_by(user_id=self.user.id, contributor_point_type_id=cp.id).count()
self.assertEqual(num_entries, x)
def before_each(self):
# n.b. cleaning this out due to other test interference
db_session_users.query(UserDocumentTag).delete()
db_session_users.query(UserTag).delete()
self.user_tags = [
UserTagFactory(user_id=self.user.id),
UserTagFactory(user_id=self.user.id),
]
self.system_tags = [
SystemTagFactory(),
SystemTagFactory(),
SystemTagFactory(active_suggestion=False)
]
db_session_users.add_all(self.system_tags)
db_session_users.add_all(self.user_tags)
db_session_users.commit()
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_create_user_tag_existing_system_name(self):
self.before_each()
system_tag = db_session_users.query(UserTag).filter_by(
user_id=None).first()
request_body = json.dumps({'name': system_tag.name})
response = self.client.post("/tags",
headers={'Authorization': self.token},
data=request_body)
self.assert400(response)
self.assertIn("errors", response.json)
def test_update_user_tag_system_tag(self):
self.before_each()
system_tag = db_session_users.query(UserTag).filter_by(
user_id=None).first()
request_body = json.dumps({'name': "watman"})
response = self.client.post("/tags/" + str(system_tag.id),
headers={'Authorization': self.token},
data=request_body)
self.assert404(response)
self.assertIn("errors", response.json)
def before_each(self):
db_session_users.query(UserFollowedEntity).delete()
self.user_followed_entities = [
UserFollowedEntity({
'user_id': self.user.id,
'entity_id': 1,
'entity_type': 'named_regulations',
'following': True
}),
UserFollowedEntity({
'user_id': self.user.id,
'entity_id': 2,
'entity_type': 'acts',
'following': True
}),
UserFollowedEntity({
'user_id': self.user.id,
'entity_id': 3,
'entity_type': 'acts',
'following': False
}),
UserFollowedEntity({
'user_id': self.user.id,
'entity_id': 1,
'entity_type': 'jurisdictions',
'following': True
}),
UserFollowedEntity({
'user_id': self.user.id,
'entity_id': 2,
'entity_type': 'jurisdictions',
'following': True
}),
UserFollowedEntity({
'user_id': self.user.id,
'entity_id': 1,
'entity_type': 'news_sources',
'following': True
}),
]
self.actually_followed_entities = [f for f in self.user_followed_entities if f.following]
db_session_users.add_all(self.user_followed_entities)
db_session_users.commit()
def test_update_saved_search_existing_name(self):
self.before_each()
update_id = db_session_users.query(UserSavedSearch).all()[1].id
name = self.user_saved_searches[0].name
request_body = json.dumps({'name': name})
response = self.client.post("/saved_searches/" + str(update_id),
headers={'Authorization': self.token},
data=request_body)
self.assertStatus(response, 409)
self.assertIn("errors", response.json)
def test_create_search_query_existing(self):
self.before_each()
search_args = {"agency_id": 268}
request_body = json.dumps({'search_args': search_args})
response = self.client.post("/search_queries",
headers={'Authorization': self.token},
data=request_body)
self.assert200(response)
lookup_hash = hashlib.sha1(json.dumps(search_args)).hexdigest()
entry = db_session_users.query(SearchQuery).filter_by(
search_args_hash=lookup_hash).first()
self.assertIsNotNone(entry)
self.assertEqual(entry.get_search_count(), 18)
response = self.client.post("/search_queries",
headers={'Authorization': self.token},
data=request_body)
self.assert200(response)
lookup_hash = hashlib.sha1(json.dumps(search_args)).hexdigest()
entry = db_session_users.query(SearchQuery).filter_by(
search_args_hash=lookup_hash).first()
self.assertIsNotNone(entry)
self.assertEqual(entry.get_search_count(), 19)
# also test that string values get converted to ints
search_args_str = {"agency_id": '268'}
request_body_str = json.dumps({'search_args': search_args_str})
response = self.client.post("/search_queries",
headers={'Authorization': self.token},
data=request_body_str)
self.assert200(response)
lookup_hash = hashlib.sha1(json.dumps(search_args)).hexdigest()
entry = db_session_users.query(SearchQuery).filter_by(
search_args_hash=lookup_hash).first()
self.assertIsNotNone(entry)
self.assertEqual(entry.get_search_count(), 20)
# and make sure a new entry was not created
lookup_hash_str = hashlib.sha1(json.dumps(search_args_str)).hexdigest()
entry_str = db_session_users.query(SearchQuery).filter_by(
search_args_hash=lookup_hash_str).first()
self.assertIsNone(entry_str)
def before_each(self):
db_session_users.query(UserTopic).delete()
self.user_followed_topics = [
UserTopic({
'user_id': self.user.id,
'topic_id': 1,
'following': True
}),
UserTopic({
'user_id': self.user.id,
'topic_id': 2,
'following': True
}),
UserTopic({
'user_id': self.user.id,
'topic_id': 3,
'following': False
}),
]
db_session_users.add_all(self.user_followed_topics)
db_session_users.commit()
def before_each(self):
db_session_users.query(UserSavedSearch).delete()
self.user_saved_searches = [
UserSavedSearch({
'name': 'test',
'user_id': self.user.id,
'search_args': {
"query": "test"
}
}),
UserSavedSearch({
'user_id': self.user.id,
'search_args': {
"agency": 466
}
}),
UserSavedSearch({
'name': 'bar',
'user_id': self.user.id,
'search_args': {
"act_id": self.acts[0]['id']
}
}),
UserSavedSearch({
'name': 'multy',
'user_id': self.user.id,
'search_args': {
"act_id": [d['id'] for d in self.acts[0:2]]
}
}),
UserSavedSearch({
'name': 'test3',
'user_id': self.new_user.id,
'search_args': {
"query": "test"
}
}),
]
db_session_users.add_all(self.user_saved_searches)
db_session_users.commit()
def before_each(self):
# n.b. cleaning this out due to other test interference
db_session_users.query(TeamMember).delete()
db_session_users.query(Team).delete()
self.teams = [
UserTeamFactory(name='test_team'),
UserTeamFactory(name='foo_team_2')
]
db_session_users.add_all(self.teams)
db_session_users.commit()
for team in self.teams:
db_session_users.refresh(team)
self.teamMembers = [
UserTeamMemberFactory(user_id=self.user.id, team_id=self.teams[0].id),
UserTeamMemberFactory(user_id=self.user.id, team_id=self.teams[1].id),
]
db_session_users.add_all(self.teamMembers)
db_session_users.commit()
for tm in self.teamMembers:
db_session_users.refresh(tm)
def test_delete_folders_with_no_documents(self):
self.before_each()
# delete the folder
folder = db_session_users.query(UserFolder).filter_by(
user_id=self.user.id, name='test_folder').first()
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)
