def setUp(self): super().setUp() self.agency_ein_860 = "0860" uf = UserFactory() self.agency_user_860 = uf.create_agency_user(agency_ein=self.agency_ein_860) self.admin_860 = uf.create_agency_admin(agency_ein=self.agency_ein_860) self.rf = RequestFactory self.rf_agency_860 = RequestFactory(agency_ein=self.agency_ein_860) self.request = self.rf_agency_860.create_request_as_public_user()
def setUp(self): super().setUp() self.agency_ein_860 = "0860" uf = UserFactory() self.admin_860 = uf.create_agency_admin(agency_ein=self.agency_ein_860) self.rf = RequestFactory() self.rf_agency_860 = RequestFactory(agency_ein=self.agency_ein_860) self.request = self.rf_agency_860.create_request_as_public_user() self.email_content = 'test email body' self.closing_reasons = [choice([r.id for r in Reasons.query.filter_by(type=determination_type.CLOSING).all()])] self.denial_reasons = [choice([r.id for r in Reasons.query.filter_by(type=determination_type.DENIAL).all()])]
def setUp(self): super().setUp() self.agency_ein_860 = "0860" self.parent_ein_860 = "860" self.agency_ein_002 = "0002" uf = UserFactory() self.user_860 = uf.create_agency_user(self.agency_ein_860) self.admin_860 = uf.create_agency_admin(self.agency_ein_860) self.rf = RequestFactory() self.rf_agency_860 = RequestFactory(agency_ein=self.agency_ein_860) self.rf_agency_002 = RequestFactory(agency_ein=self.agency_ein_002) self.tz_name = current_app.config["APP_TIMEZONE"]
class ResponseUtilsTests(BaseTestCase, TestHelpers): def setUp(self): super().setUp() self.agency_ein_860 = "0860" uf = UserFactory() self.admin_860 = uf.create_agency_admin(agency_ein=self.agency_ein_860) self.rf = RequestFactory() self.rf_agency_860 = RequestFactory(agency_ein=self.agency_ein_860) self.request = self.rf_agency_860.create_request_as_public_user() self.email_content = 'test email body' self.closing_reasons = [choice([r.id for r in Reasons.query.filter_by(type=determination_type.CLOSING).all()])] self.denial_reasons = [choice([r.id for r in Reasons.query.filter_by(type=determination_type.DENIAL).all()])] @patch('app.response.utils._send_response_email') def test_add_denial(self, send_response_email_patch): with flask_login_user(self.admin_860): add_denial(self.request.id, self.denial_reasons, self.email_content) send_response_email_patch.assert_called_once_with( self.request.id, response_privacy.RELEASE_AND_PUBLIC, self.email_content, 'Request {} Closed'.format(self.request.id) ) response = self.request.responses.join(Determinations).filter( Determinations.dtype == determination_type.DENIAL).one() self.assertEqual( [ response.request_id, response.privacy, response.dtype, response.reason ], [ self.request.id, response_privacy.RELEASE_AND_PUBLIC, determination_type.DENIAL, format_determination_reasons(self.denial_reasons) ] ) self.assert_response_event(self.request.id, event_type.REQ_CLOSED, response, self.admin_860) def test_add_denial_invalid_request(self): with flask_login_user(self.admin_860): with self.assertRaises(NoResultFound): add_denial('FOIL-2017-002-00001', self.denial_reasons, self.email_content) def test_add_denial_already_closed(self): with flask_login_user(self.admin_860): self.request.close() with self.assertRaises(UserRequestException): add_denial(self.request.id, self.denial_reasons, self.email_content) @patch('app.response.utils._send_response_email') def test_add_closing(self, send_response_email_patch): with flask_login_user(self.admin_860): self.request.acknowledge(days=30) self.request.set_agency_request_summary('blah') self.request.set_agency_request_summary_privacy(False) add_closing(self.request.id, self.closing_reasons, self.email_content) send_response_email_patch.assert_called_once_with( self.request.id, response_privacy.RELEASE_AND_PUBLIC, self.email_content, 'Request {} Closed'.format(self.request.id) ) response = self.request.responses.join(Determinations).filter( Determinations.dtype == determination_type.CLOSING).one() self.assertEqual( [ response.request_id, response.privacy, response.dtype, response.reason ], [ self.request.id, response_privacy.RELEASE_AND_PUBLIC, determination_type.CLOSING, format_determination_reasons(self.closing_reasons) ] ) self.assert_response_event(self.request.id, event_type.REQ_CLOSED, response, self.admin_860) def test_add_closing_invalid_request(self): with flask_login_user(self.admin_860): with self.assertRaises(NoResultFound): add_closing('FOIL-2017-002-00001', self.closing_reasons, self.email_content) def test_add_closing_not_acknowledged(self): with flask_login_user(self.admin_860): self.request.close() with self.assertRaises(UserRequestException): add_closing(self.request.id, self.closing_reasons, self.email_content) def test_add_closing_already_closed(self): with flask_login_user(self.admin_860): self.request.close() with self.assertRaises(UserRequestException): add_closing(self.request.id, self.closing_reasons, self.email_content) def test_add_closing_no_agency_request_summary(self): with flask_login_user(self.admin_860): self.request.acknowledge(days=30) with self.assertRaises(UserRequestException): add_closing(self.request.id, self.closing_reasons, self.email_content) def test_add_closing_file_private(self): with flask_login_user(self.admin_860): self.request.acknowledge(days=30) self.request.add_file() with self.assertRaises(UserRequestException): add_closing(self.request.id, self.closing_reasons, self.email_content) @patch('app.response.utils._send_response_email') def test_add_closing_file_release_public(self, send_response_email_patch): request_title_public = self.rf_agency_860.create_request_as_public_user(title_privacy=False) with flask_login_user(self.admin_860): request_title_public.acknowledge(days=30) request_title_public.add_file(privacy=response_privacy.RELEASE_AND_PUBLIC) add_closing(request_title_public.id, self.closing_reasons, self.email_content) send_response_email_patch.assert_called_once_with( request_title_public.id, response_privacy.RELEASE_AND_PUBLIC, self.email_content, 'Request {} Closed'.format(request_title_public.id) ) response = request_title_public.responses.join(Determinations).filter( Determinations.dtype == determination_type.CLOSING).one() self.assertEqual( [ response.request_id, response.privacy, response.dtype, response.reason ], [ request_title_public.id, response_privacy.RELEASE_AND_PUBLIC, determination_type.CLOSING, format_determination_reasons(self.closing_reasons) ] ) self.assert_response_event(request_title_public.id, event_type.REQ_CLOSED, response, self.admin_860) @patch('app.response.utils._send_response_email') def test_add_closing_not_fulfilled_reasons(self, send_response_email_patch): not_fulfilled_reasons = ['7', '8', '9'] with flask_login_user(self.admin_860): self.request.acknowledge(days=30) self.request.set_agency_request_summary('blah') self.request.set_agency_request_summary_privacy(False) add_closing(self.request.id, not_fulfilled_reasons, self.email_content) send_response_email_patch.assert_called_once_with( self.request.id, response_privacy.RELEASE_AND_PUBLIC, self.email_content, 'Request {} Closed'.format(self.request.id) ) response = self.request.responses.join(Determinations).filter( Determinations.dtype == determination_type.CLOSING).one() self.assertEqual( [ response.request_id, response.privacy, response.dtype, response.reason ], [ self.request.id, response_privacy.RELEASE_AND_PUBLIC, determination_type.CLOSING, format_determination_reasons(not_fulfilled_reasons) ] ) self.assert_response_event(self.request.id, event_type.REQ_CLOSED, response, self.admin_860)
def setUp(self): super().setUp() self.rf = RequestFactory() self.uf = UserFactory() self.request = self.rf.create_request_as_anonymous_user() self.tz_name = current_app.config["APP_TIMEZONE"]
class RequestWrapperTests(BaseTestCase, TestHelpers): def setUp(self): super().setUp() self.rf = RequestFactory() self.uf = UserFactory() self.request = self.rf.create_request_as_anonymous_user() self.tz_name = current_app.config["APP_TIMEZONE"] def test_set_title(self): title = "The Time Has Come" self.request.set_title(title) request = Requests.query.get(self.request.id) self.assertEqual(request.title, title) def test_set_agency_request_summary(self): agency_request_summary = "To talk of many things." self.request.set_agency_request_summary(agency_request_summary) request = Requests.query.get(self.request.id) self.assertEqual(request.agency_request_summary, agency_request_summary) def test_set_title_privacy(self): privacy = not self.request.privacy["title"] self.request.set_title_privacy(privacy) request = Requests.query.get(self.request.id) self.assertEqual(request.privacy["title"], privacy) def test_set_agency_request_summary_privacy(self): privacy = not self.request.privacy["agency_request_summary"] self.request.set_agency_request_summary_privacy(privacy) request = Requests.query.get(self.request.id) self.assertEqual(request.privacy["agency_request_summary"], privacy) def test_add_file_default(self): response = self.request.add_file() response = Responses.query.get(response.id) self.assertEqual( [ response.request_id, response.privacy, response.mime_type, type(response.title), type(response.name), type(response.size), type(response.hash) ], [ self.request.id, response_privacy.PRIVATE, 'text/plain', str, # title str, # filename int, # size str, # hash ] ) self.assertTrue(response.size > 0) self.assertTrue( os.path.exists( os.path.join( current_app.config["UPLOAD_DIRECTORY"], self.request.id, response.name ) ) ) self.assert_response_event(self.request.id, event_type.FILE_ADDED, response, self.rf.agency_user) def test_add_file_custom_without_path(self): title = "Having Fun Isn't Hard" name = "libary_card" privacy = response_privacy.RELEASE_AND_PUBLIC response = self.request.add_file( title=title, name=name, privacy=privacy, user=self.rf.public_user, ) response = Responses.query.get(response.id) self.assertEqual( [ response.request_id, response.privacy, response.title, response.name, response.mime_type, type(response.size), type(response.hash) ], [ self.request.id, privacy, title, name, "text/plain", int, # size str, # hash ] ) self.assertTrue(response.size > 0) self.assertTrue( os.path.exists( os.path.join( current_app.config["UPLOAD_DIRECTORY"], self.request.id, response.name ) ) ) self.assert_response_event(self.request.id, event_type.FILE_ADDED, response, self.rf.public_user) def test_add_file_custom_with_path(self): title = "Open Wide" response = self.request.add_file( title=title, name="dont_mind_me", filepath=SCREAM_FILE.path, ) response = Responses.query.get(response.id) self.assertEqual( [ response.request_id, response.privacy, response.title, response.name, response.mime_type, response.size, response.hash ], [ self.request.id, response_privacy.PRIVATE, title, SCREAM_FILE.name, SCREAM_FILE.mime_type, SCREAM_FILE.size, SCREAM_FILE.hash ] ) self.assert_response_event(self.request.id, event_type.FILE_ADDED, response, self.rf.agency_user) def test_add_link(self): response = self.request.add_link() title = "Urlification" url = "http://url.com" privacy = response_privacy.RELEASE_AND_PUBLIC response_custom = self.request.add_link(title, url, privacy, self.rf.public_user) response = Responses.query.get(response.id) self.assertEqual( [ response.request_id, response.privacy, type(response.title), type(response.url) ], [ self.request.id, response_privacy.PRIVATE, str, # title str, # url ] ) self.assert_response_event(self.request.id, event_type.LINK_ADDED, response, self.rf.agency_user) response = Responses.query.get(response_custom.id) self.assertEqual( [ response.request_id, response.privacy, response.title, response.url ], [ self.request.id, privacy, title, url ] ) self.assert_response_event(self.request.id, event_type.LINK_ADDED, response, self.rf.public_user) def test_add_note(self): response = self.request.add_note() content = "I. AM. A. NOTE." privacy = response_privacy.RELEASE_AND_PUBLIC response_custom = self.request.add_note(content, privacy, self.rf.public_user) response = Responses.query.get(response.id) self.assertEqual( [ response.request_id, response.privacy, type(response.content) ], [ self.request.id, response_privacy.PRIVATE, str ] ) self.assert_response_event(self.request.id, event_type.NOTE_ADDED, response, self.rf.agency_user) response = Responses.query.get(response_custom.id) self.assertEqual( [ response.request_id, response.privacy, response.content ], [ self.request.id, privacy, content ] ) self.assert_response_event(self.request.id, event_type.NOTE_ADDED, response, self.rf.public_user) def test_add_instructions(self): response = self.request.add_instructions() content = "I want to play a game. In the room to your left you will find..." privacy = response_privacy.RELEASE_AND_PUBLIC response_custom = self.request.add_instructions(content, privacy, self.rf.public_user) response = Responses.query.get(response.id) self.assertEqual( [ response.request_id, response.privacy, type(response.content) ], [ self.request.id, response_privacy.PRIVATE, str ] ) self.assert_response_event(self.request.id, event_type.INSTRUCTIONS_ADDED, response, self.rf.agency_user) response = Responses.query.get(response_custom.id) self.assertEqual( [ response.request_id, response.privacy, response.content ], [ self.request.id, privacy, content ] ) self.assert_response_event(self.request.id, event_type.INSTRUCTIONS_ADDED, response, self.rf.public_user) def test_acknowledge_days(self): days = 30 info = "Informative information that will inform you." due_date = get_due_date( utc_to_local( self.request.due_date, self.tz_name ), days, self.tz_name ) response = self.request.acknowledge(info=info, days=days) self.__test_extension(response, determination_type.ACKNOWLEDGMENT, info, due_date) def test_acknowledge_date(self): date = calendar.addbusdays(datetime.now(), 100) response = self.request.acknowledge(date=date) due_date = process_due_date(local_to_utc(date, self.tz_name)) self.__test_extension(response, determination_type.ACKNOWLEDGMENT, str, due_date) def test_acknowledge_missing_args(self): with self.assertRaises(AssertionError): self.request.acknowledge() def test_extend_days(self): days = 20 reason = "Reasonable reasoning for the rational reasoner." due_date = get_due_date( utc_to_local( self.request.due_date, self.tz_name ), days, self.tz_name ) response = self.request.extend(reason=reason, days=days) self.__test_extension(response, determination_type.EXTENSION, reason, due_date) def test_extend_date_due_soon(self): request = self.rf.create_request_as_anonymous_user(due_date=datetime.utcnow()) date = calendar.addbusdays(utc_to_local(request.due_date, self.tz_name), 1) due_date = process_due_date(local_to_utc(date, self.tz_name)) response = request.extend(date=date) self.__test_extension( response, determination_type.EXTENSION, str, due_date, request_status.DUE_SOON, request=request) def test_extend_date_overdue(self): request = self.rf.create_request_as_anonymous_user( due_date=calendar.addbusdays(datetime.utcnow(), -2)) date = calendar.addbusdays(utc_to_local(request.due_date, self.tz_name), 1) due_date = process_due_date(local_to_utc(date, self.tz_name)) response = request.extend(date=date) self.__test_extension( response, determination_type.EXTENSION, str, due_date, request_status.OVERDUE, request=request) # TODO: prevent users from extending a request to a date that will still result in an OVERDUE status def test_extend_bad_due_date(self): with self.assertRaises(AssertionError): self.request.extend(date=calendar.addbusdays( utc_to_local(self.request.due_date, self.tz_name), -1)) def test_reopen(self): date = calendar.addbusdays(utc_to_local(self.request.due_date, self.tz_name), 1) response = self.request.reopen(date) due_date = process_due_date(local_to_utc(date, self.tz_name)) self.__test_extension(response, determination_type.REOPENING, None, due_date) self.assertEqual(self.request.agency_request_summary, None) def __test_extension(self, response, type_, reason, due_date, status=request_status.IN_PROGRESS, user=None, request=None): request_id = request.id if request is not None else self.request.id response = Responses.query.get(response.id) self.assertEqual( [ response.request_id, response.privacy, response.dtype, type(response.reason) if isinstance(reason, type) else response.reason, response.date ], [ request_id, response_privacy.RELEASE_AND_PUBLIC, type_, reason, due_date ] ) request = Requests.query.get(request_id) self.assertEqual( [ request.status, request.due_date, ], [ status, due_date ] ) self.assert_response_event(request.id, type_, response, user or self.rf.agency_user) def test_close_default(self): response = self.request.close() response = Responses.query.get(response.id) self.assertEqual( [ response.request_id, response.privacy, response.dtype, type(response.reason) ], [ self.request.id, response_privacy.RELEASE_AND_PUBLIC, determination_type.CLOSING, str ] ) self.assert_response_event(self.request.id, event_type.REQ_CLOSED, response, self.rf.agency_user) def test_close_custom(self): reason_ids = sample(set([r.id for r in Reasons.query.filter_by(type=determination_type.CLOSING).all()]), 3) response_custom = self.request.close(reason_ids, self.rf.public_user) response = Responses.query.get(response_custom.id) response = Responses.query.get(response.id) self.assertEqual( [ response.request_id, response.privacy, response.dtype, response.reason ], [ self.request.id, response_privacy.RELEASE_AND_PUBLIC, determination_type.CLOSING, format_determination_reasons(reason_ids) ] ) self.assert_response_event(self.request.id, event_type.REQ_CLOSED, response, self.rf.public_user) def test_deny_default(self): response = self.request.deny() response = Responses.query.get(response.id) self.assertEqual( [ response.request_id, response.privacy, response.dtype, type(response.reason) ], [ self.request.id, response_privacy.RELEASE_AND_PUBLIC, determination_type.DENIAL, str ] ) self.assert_response_event(self.request.id, event_type.REQ_CLOSED, response, self.rf.agency_user) def test_deny_custom(self): reason_ids = sample(set([r.id for r in Reasons.query.filter_by(type=determination_type.DENIAL).all()]), 3) response_custom = self.request.deny(reason_ids, self.rf.public_user) response = Responses.query.get(response_custom.id) response = Responses.query.get(response.id) self.assertEqual( [ response.request_id, response.privacy, response.dtype, response.reason ], [ self.request.id, response_privacy.RELEASE_AND_PUBLIC, determination_type.DENIAL, format_determination_reasons(reason_ids) ] ) self.assert_response_event(self.request.id, event_type.REQ_CLOSED, response, self.rf.public_user) def test_set_due_soon(self): self.__test_due_soon_or_overdue( request_status.DUE_SOON, calendar.addbusdays( datetime.utcnow(), current_app.config["DUE_SOON_DAYS_THRESHOLD"] ).replace(hour=23, minute=59, second=59, microsecond=0), ) def test_set_due_soon_no_shift(self): self.__test_due_soon_or_overdue(request_status.DUE_SOON, no_shift=True) def test_set_overdue(self): self.__test_due_soon_or_overdue( request_status.OVERDUE, calendar.addbusdays( datetime.utcnow(), -1 ).replace(microsecond=0) ) def test_set_overdue_no_shift(self): self.__test_due_soon_or_overdue(request_status.OVERDUE, no_shift=True) def __test_due_soon_or_overdue(self, status, due_date=None, no_shift=False): if no_shift: due_date = self.request.due_date date_submitted = self.request.date_submitted date_created = self.request.date_created {request_status.DUE_SOON: self.request.set_due_soon, request_status.OVERDUE: self.request.set_overdue }[status](shift_dates=False) request = Requests.query.get(self.request.id) self.assertEqual( [ request.status, request.due_date, request.date_submitted, request.date_created ], [ status, due_date, date_submitted, date_created ] ) else: shift = due_date - self.request.due_date date_submitted = self.request.date_submitted + shift date_created = self.request.date_created + shift old_status = self.request.status {request_status.DUE_SOON: self.request.set_due_soon, request_status.OVERDUE: self.request.set_overdue }[status]() request = Requests.query.get(self.request.id) self.assertEqual( [ request.status, request.due_date, request.date_submitted, request.date_created, # TODO: request.agency_request_summary_release_date ], [ status, due_date, date_submitted, date_created ] ) event = Events.query.filter_by(type=event_type.REQ_STATUS_CHANGED).one() self.assertEqual( [ event.request_id, event.user_guid, event.auth_user_type, event.previous_value, event.new_value, event.response_id ], [ self.request.id, None, # user_guid None, # auth_user_type {"status": old_status}, {"status": status}, None ] ) def test_add_user_anonymous(self): self.__test_add_user_default( self.uf.create_anonymous_user(), user_type_request.REQUESTER, role_name.ANONYMOUS ) def test_add_user_public(self): self.__test_add_user_default( self.uf.create_public_user(), user_type_request.REQUESTER, role_name.PUBLIC_REQUESTER ) def test_add_user_agency_inactive(self): self.__test_add_user_default( self.uf.create_agency_user(agency_ein=self.request.agency.ein), user_type_request.AGENCY, role_name.AGENCY_HELPER ) def test_add_user_agency_active(self): self.__test_add_user_default( self.uf.create_agency_user(agency_ein=self.request.agency.ein, is_agency_active=True), user_type_request.AGENCY, role_name.AGENCY_OFFICER ) def test_add_user_agency_admin(self): self.__test_add_user_default( self.uf.create_agency_admin(agency_ein=self.request.agency.ein), user_type_request.AGENCY, role_name.AGENCY_ADMIN ) def __test_add_user_default(self, user, request_user_type, role): user_request = self.request.add_user(user) user_request = UserRequests.query.filter_by(user_guid=user_request.user_guid).one() self.assertEqual( [ user_request.request_id, user_request.request_user_type, user_request.permissions ], [ self.request.id, request_user_type, Roles.query.filter_by(name=role).one().permissions ] ) self.__assert_user_request_event(event_type.USER_ADDED, user_request, self.rf.agency_user) def test_add_user_custom_agent(self): user = self.uf.create_anonymous_user() agency_user = self.uf.create_agency_user(agency_ein=self.request.agency.ein) user_request = self.request.add_user(user, agent=agency_user) user_request = UserRequests.query.filter_by(user_guid=user_request.user_guid).one() self.__assert_user_request_event(event_type.USER_ADDED, user_request, agency_user) def test_add_user_custom_role(self): user = self.uf.create_anonymous_user() rname = role_name.PUBLIC_REQUESTER user_request = self.request.add_user(user, role=rname) user_request = UserRequests.query.filter_by(user_guid=user_request.user_guid).one() self.assertEqual( user_request.permissions, Roles.query.filter_by(name=rname).one().permissions ) def test_add_user_custom_permissions(self): user = self.uf.create_anonymous_user() permissions = permission.ADD_LINK user_request = self.request.add_user(user, permissions=permissions) user_request = UserRequests.query.filter_by(user_guid=user_request.user_guid).one() self.assertEqual(user_request.permissions, permissions) def test_edit_user_set_permissions(self): user = self.uf.create_public_user() user_request = self.request.add_user(user) old_permissions = user_request.permissions permissions = [permission.ADD_FILE, permission.ADD_OFFLINE_INSTRUCTIONS] self.request.edit_user(user, perms_set=permissions) user_request = UserRequests.query.filter_by(user_guid=user_request.user_guid).one() self.assertEqual(user_request.permissions, reduce(ior, permissions)) self.__assert_user_request_event( event_type.USER_PERM_CHANGED, user_request, self.rf.agency_user, old_permissions) def test_edit_user_add_permissions(self): user = self.uf.create_public_user() user_request = self.request.add_user(user) old_permissions = user_request.permissions permissions = [permission.ADD_OFFLINE_INSTRUCTIONS] self.request.edit_user(user, perms_add=permissions) user_request = UserRequests.query.filter_by(user_guid=user_request.user_guid).one() self.assertEqual(user_request.permissions, permissions[0] | old_permissions) self.__assert_user_request_event( event_type.USER_PERM_CHANGED, user_request, self.rf.agency_user, old_permissions) def test_edit_user_remove_permissions(self): user = self.uf.create_public_user() user_request = self.request.add_user(user) old_permissions = [user_request.permissions] self.request.edit_user(user, perms_remove=old_permissions) user_request = UserRequests.query.filter_by(user_guid=user_request.user_guid).one() self.assertEqual(user_request.permissions, permission.NONE) self.__assert_user_request_event( event_type.USER_PERM_CHANGED, user_request, self.rf.agency_user, old_permissions[0]) def test_edit_user_as_agent(self): user = self.uf.create_anonymous_user() agency_user = self.uf.create_agency_user(agency_ein=self.request.agency.ein) user_request = self.request.add_user(user) old_permissions = user_request.permissions self.request.edit_user(user, perms_set=permission.NONE, agent=agency_user) user_request = UserRequests.query.filter_by(user_guid=user.guid).one() self.__assert_user_request_event( event_type.USER_PERM_CHANGED, user_request, agency_user, old_permissions) def test_edit_user_missing_permissions(self): user = self.uf.create_anonymous_user() with self.assertRaises(AssertionError): self.request.edit_user(user) def test_remove_user(self): user = self.uf.create_anonymous_user() user_request = self.request.add_user(user) user_request = UserRequests.query.filter_by(user_guid=user_request.user_guid).one() self.request.remove_user(user) self.__assert_user_request_event(event_type.USER_REMOVED, user_request, self.rf.agency_user) self.assertTrue(UserRequests.query.filter_by(user_guid=user.guid).first() is None) def test_remove_user_as_agent(self): user = self.uf.create_anonymous_user() agency_user = self.uf.create_agency_user(agency_ein=self.request.agency.ein) user_request = self.request.add_user(user) user_request = UserRequests.query.filter_by(user_guid=user_request.user_guid).one() self.request.remove_user(user, agent=agency_user) self.__assert_user_request_event(event_type.USER_REMOVED, user_request, agency_user) self.assertTrue(UserRequests.query.filter_by(user_guid=user.guid).first() is None) def test_destructor(self): response = self.request.add_file() self.assertTrue( os.path.exists( os.path.join( current_app.config["UPLOAD_DIRECTORY"], self.request.id, response.name ) ) ) request_id = self.request.id del self.request self.assertFalse( os.path.exists( os.path.join( current_app.config["UPLOAD_DIRECTORY"], request_id, response.name ) ) ) def __assert_user_request_event(self, type_, user_request, user, old_permissions=None): # get latest event with type `type_` event = Events.query.filter_by(type=type_).order_by(Events.timestamp.desc()).first() self.assertEqual( [ event.request_id, event.user_guid, event.auth_user_type, event.previous_value, event.new_value ], [ self.request.id, user.guid, user.auth_user_type, {"permissions": old_permissions} if old_permissions is not None else None, user_request.val_for_events ] )
class RequestFactoryTests(BaseTestCase): def setUp(self): super().setUp() self.agency_ein_860 = "0860" self.parent_ein_860 = "860" self.agency_ein_002 = "0002" uf = UserFactory() self.user_860 = uf.create_agency_user(self.agency_ein_860) self.admin_860 = uf.create_agency_admin(self.agency_ein_860) self.rf = RequestFactory() self.rf_agency_860 = RequestFactory(agency_ein=self.agency_ein_860) self.rf_agency_002 = RequestFactory(agency_ein=self.agency_ein_002) self.tz_name = current_app.config["APP_TIMEZONE"] def test_create_request_default(self): request = self.rf.create_request(self.user_860) self.__assert_request_data_correct( self.user_860, request, self.parent_ein_860, default=True, ) # check associated users requester = Users.query.filter_by(auth_user_type=user_type_auth.ANONYMOUS_USER).one() self.assertEqual(request.requester, requester) self.assertFalse(self.user_860 in request.agency_users) self.assertTrue(self.admin_860 in request.agency_users) def test_create_request_custom(self): title = "Where did all the fish go?" description = "I demand to know where all of my fish ran off to." agency_request_summary = "Inquiry into the disappearance local marine life." category = "Fishies" title_privacy = False agency_request_summary_privacy = False submission = submission_methods.IN_PERSON status = request_status.IN_PROGRESS date_created = datetime.utcnow() due_date = date_created + timedelta(days=90) request = self.rf.create_request( self.user_860, title, description, agency_request_summary, self.user_860.agency_ein, date_created, due_date=due_date, category=category, title_privacy=title_privacy, agency_request_summary_privacy=agency_request_summary_privacy, submission=submission, status=status ) self.__assert_request_data_correct( self.user_860, request, self.parent_ein_860, title=title, description=description, agency_request_summary=agency_request_summary, agency_ein=self.agency_ein_860, date_created=date_created, due_date=due_date, category=category, title_privacy=title_privacy, agency_request_summary_privacy=agency_request_summary_privacy, submission=submission, status=status ) # check associated users requester = Users.query.filter_by(auth_user_type=user_type_auth.ANONYMOUS_USER).one() self.assertEqual(request.requester, requester) self.assertFalse(self.user_860 in request.agency_users) self.assertTrue(self.admin_860 in request.agency_users) def test_create_request_agency_ein(self): request = self.rf_agency_860.create_request_as_public_user() self.__assert_request_data_correct( self.rf_agency_860.public_user, request, self.parent_ein_860, default=True ) self.assertTrue(self.admin_860 in request.agency_users) def test_create_request_as_anonymous_user(self): request = self.rf.create_request_as_anonymous_user() user = Users.query.filter_by(auth_user_type=user_type_auth.ANONYMOUS_USER).one() self.__assert_request_data_correct( user, request, request.agency.parent_ein, default=True ) self.assertEqual(request.requester, user) def test_create_request_as_agency_user(self): request = self.rf.create_request_as_agency_user() self.__assert_request_data_correct( self.rf.agency_user, request, self.rf.agency_user.agency.parent_ein, default=True ) self.assertFalse(self.rf.agency_user in request.agency_users) def test_create_request_as_public_user(self): request = self.rf.create_request_as_public_user() self.__assert_request_data_correct( self.rf.public_user, request, request.agency.parent_ein, default=True ) self.assertEqual(request.requester, self.rf.public_user) def test_create_request_wrong_dates(self): now = datetime.utcnow() tomorrow = now + timedelta(days=1) with self.assertRaises(AssertionError): self.rf.create_request(self.user_860, due_date=now, date_created=now) with self.assertRaises(AssertionError): self.rf.create_request(self.user_860, due_date=now, date_submitted=now) with self.assertRaises(AssertionError): self.rf.create_request(self.user_860, due_date=now, date_created=tomorrow) with self.assertRaises(AssertionError): self.rf.create_request(self.user_860, due_date=now, date_submitted=tomorrow) def test_create_request_wrong_agency_ein(self): with self.assertRaises(AssertionError): self.rf.create_request(self.user_860, agency_ein=self.agency_ein_002) with self.assertRaises(AssertionError): self.rf_agency_002.create_request(self.user_860) def __assert_request_data_correct(self, user, request, agency_parent_ein, default=False, title=None, description=None, agency_request_summary=None, agency_ein=None, date_created=None, due_date=None, category='All', title_privacy=True, agency_request_summary_privacy=True, submission=None, status=request_status.OPEN): request = Requests.query.get(request.id) privacy = {"title": title_privacy, "agency_request_summary": agency_request_summary_privacy} agency_ein = agency_ein or user.agency_ein or request.agency_ein date_created_local = utc_to_local(date_created or request.date_created, self.tz_name) date_submitted_local = get_following_date(date_created_local) if default: self.assertTrue(request.submission in submission_methods.ALL) request_list = [ type(request.title), type(request.description), ] check_list = [ str, str, ] else: request_list = [ request.title, request.description, request.agency_request_summary, request.date_created, request.submission, ] check_list = [ title, description, agency_request_summary, date_created, submission, ] request_list += [ request.id, request.category, request.privacy, request.agency_ein, request.status, request.date_submitted, request.due_date, ] check_list += [ "FOIL-{}-{}-00001".format(datetime.today().year, agency_parent_ein), category, privacy, agency_ein, status, local_to_utc(date_submitted_local, self.tz_name), due_date or get_due_date(date_submitted_local, ACKNOWLEDGMENT_DAYS_DUE, self.tz_name) ] self.assertEqual(request_list, check_list) # check associated events event_req_created = Events.query.filter_by(type=event_type.REQ_CREATED).one() self.assertEqual( [ event_req_created.user_guid, event_req_created.auth_user_type, event_req_created.request_id, event_req_created.response_id, event_req_created.previous_value, event_req_created.new_value, ], [ user.guid, user.auth_user_type, request.id, None, # response_id None, # previous_value request.val_for_events # new_value ] ) if user.is_agency: event_agency_req_created = Events.query.filter_by(type=event_type.AGENCY_REQ_CREATED).one() self.assertEqual( [ event_agency_req_created.user_guid, event_agency_req_created.auth_user_type, event_agency_req_created.request_id, event_agency_req_created.response_id, event_agency_req_created.previous_value, event_agency_req_created.new_value, ], [ user.guid, user.auth_user_type, request.id, None, # response_id None, # previous_value None, # new_value ] )
def setUp(self): super().setUp() uf = UserFactory() self.agency_admin = uf.create_agency_admin() self.request = RequestFactory().create_request_as_anonymous_user()
def setUp(self): super().setUp() uf = UserFactory() self.rf = RequestFactory()
class RequestUtilsTests(BaseTestCase): def setUp(self): super().setUp() uf = UserFactory() self.rf = RequestFactory() @patch('app.request.utils.send_contact_email') def test_create_contact_record_anon(self, send_contact_email_patch): request = self.rf.create_request_as_anonymous_user() first_name = 'John' last_name = 'Doris' subject = 'Inquire about {}'.format(request.id) email = '*****@*****.**' message = 'I need more information about my request.' body = "Name: {} {}\n\nEmail: {}\n\nSubject: {}\n\nMessage:\n{}".format( first_name, last_name, email, subject, message) agency_emails = get_agency_emails(request.id) create_contact_record(request, first_name, last_name, email, subject, message) send_contact_email_patch.assert_called_once_with( subject, agency_emails, message, email ) user = Users.query.filter_by(email=email).one() self.assertEqual( [ user.first_name, user.last_name, user.auth_user_type, user.email ], [ first_name, last_name, user_type_auth.ANONYMOUS_USER, email ] ) user_created_event = Events.query.filter(Events.request_id == request.id, Events.type == event_type.USER_CREATED).one() self.assertEqual(user.val_for_events, user_created_event.new_value) email_obj = Emails.query.filter(Emails.request_id == request.id, Emails.subject == subject).one() self.assertEqual( [ [email_obj.to], email_obj.body ], [ agency_emails, body ] ) contact_event = Events.query.filter_by(response_id=email_obj.id).one() self.assertEqual( [ contact_event.request_id, contact_event.user_guid, contact_event.auth_user_type, contact_event.type, contact_event.new_value ], [ request.id, user.guid, user.auth_user_type, event_type.CONTACT_EMAIL_SENT, email_obj.val_for_events ] ) @patch('app.request.utils.send_contact_email') def test_create_contact_record_public(self, send_contact_email_patch): request = self.rf.create_request_as_public_user() user = self.rf.public_user subject = 'Inquire about {}'.format(request.id) message = 'I need more information about my request.' body = "Name: {} {}\n\nEmail: {}\n\nSubject: {}\n\nMessage:\n{}".format( user.first_name, user.last_name, user.email, subject, message) agency_emails = get_agency_emails(request.id) with flask_login_user(user): create_contact_record(request, user.first_name, user.last_name, user.email, subject, message) send_contact_email_patch.assert_called_once_with( subject, agency_emails, message, user.email ) email_obj = Emails.query.filter(Emails.request_id == request.id, Emails.subject == subject).one() self.assertEqual( [ [email_obj.to], email_obj.body ], [ agency_emails, body ] ) contact_event = Events.query.filter_by(response_id=email_obj.id).one() self.assertEqual( [ contact_event.request_id, contact_event.user_guid, contact_event.auth_user_type, contact_event.type, contact_event.new_value ], [ request.id, user.guid, user.auth_user_type, event_type.CONTACT_EMAIL_SENT, email_obj.val_for_events ] )
class ResponseViewsTests(BaseTestCase, TestHelpers): def setUp(self): super().setUp() self.agency_ein_860 = "0860" uf = UserFactory() self.agency_user_860 = uf.create_agency_user(agency_ein=self.agency_ein_860) self.admin_860 = uf.create_agency_admin(agency_ein=self.agency_ein_860) self.rf = RequestFactory self.rf_agency_860 = RequestFactory(agency_ein=self.agency_ein_860) self.request = self.rf_agency_860.create_request_as_public_user() def test_response_denial(self): with self.client as client: login_user_with_client(client, self.admin_860.get_id()) response = self.client.post( '/response/denial/' + self.request.id, data={ "reasons": ['1', '2', '3'], "email-summary": 'This is a email summary' } ) self.assertEqual(response.status_code, 302) self.assertEqual(urlparse(response.location).path, url_for('request.view', request_id=self.request.id)) def test_response_denial_missing_reasons(self): with self.client as client: login_user_with_client(client, self.admin_860.get_id()) response = self.client.post( '/response/denial/' + self.request.id, data={ "email-summary": 'This is a email summary' } ) self.assert_flashes(expected_message='Uh Oh, it looks like the denial reasons is missing! ' 'This is probably NOT your fault.', expected_category='danger') self.assertEqual(response.status_code, 302) self.assertEqual(urlparse(response.location).path, url_for('request.view', request_id=self.request.id)) def test_response_closing(self): self.request.acknowledge(days=30) self.request.set_agency_request_summary(agency_request_summary='blah') self.request.set_agency_request_summary_privacy(privacy=False) with self.client as client: login_user_with_client(client, self.admin_860.get_id()) response = self.client.post( '/response/closing/' + self.request.id, data={ "reasons": ['1', '2', '3'], "email-summary": 'This is a email summary' } ) self.assertEqual(response.status_code, 302) self.assertEqual(urlparse(response.location).path, url_for('request.view', request_id=self.request.id)) def test_response_closing_missing_reasons(self): self.request.acknowledge(days=30) with self.client as client: login_user_with_client(client, self.admin_860.get_id()) response = self.client.post( '/response/closing/' + self.request.id, data={ "email-summary": 'This is a email summary' } ) self.assert_flashes(expected_message='Uh Oh, it looks like the closing reasons is missing! ' 'This is probably NOT your fault.', expected_category='danger') self.assertEqual(response.status_code, 302) self.assertEqual(urlparse(response.location).path, url_for('request.view', request_id=self.request.id)) def test_response_closing_no_agency_request_summary(self): self.request.acknowledge(days=30) with self.client as client: login_user_with_client(client, self.admin_860.get_id()) response = self.client.post( '/response/closing/' + self.request.id, data={ "reasons": ['1', '2', '3'], "email-summary": 'This is a email summary' } ) self.assert_flashes(expected_message='Unable to close request:', expected_category='danger') self.assertEqual(response.status_code, 302) self.assertEqual(urlparse(response.location).path, url_for('request.view', request_id=self.request.id))