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)