def test_cancel_permissions(self): application = ApplicationFactory.create( owner=self.resident, shift=self.shift, state=ApplicationStateEnum.APPROVED) # Resident can cancel approved application self.assertTrue( has_transition_perm(application.cancel, self.resident.user_ptr)) # Scheduler can cancel approved applications self.assertTrue( has_transition_perm(application.cancel, self.scheduler.user_ptr)) application = ApplicationFactory.create( owner=self.resident, shift=self.shift, state=ApplicationStateEnum.CONFIRMED) # Resident can cancel confirmed application self.assertTrue( has_transition_perm(application.cancel, self.resident.user_ptr)) # Scheduler can cancel confirmed applications self.assertTrue( has_transition_perm(application.cancel, self.scheduler.user_ptr))
def test_cancel_started(self, mock_process_renewing, mock_process_cancelling): """ Checks that cancelling an application for the started shift makes the application failed and doesn't renew all postponed applications """ self.shift.date_start = timezone.now() - timedelta(hours=1) self.shift.save() postponed_application = ApplicationFactory.create( shift=self.shift, state=ApplicationStateEnum.POSTPONED) application = ApplicationFactory.create( shift=self.shift, state=ApplicationStateEnum.APPROVED) data = self.get_transition_data() application.cancel(data) application.save() application.refresh_from_db() self.assertEqual(application.state, ApplicationStateEnum.FAILED) postponed_application.refresh_from_db() self.assertEqual(postponed_application.state, ApplicationStateEnum.POSTPONED) mock_process_cancelling.assert_called_with(application, data['user'], data['text']) self.assertFalse(mock_process_renewing.called)
def test_approve(self, mock_process_postponing, mock_process_approving): # New applications first_application = ApplicationFactory.create(shift=self.shift) second_application = ApplicationFactory.create(shift=self.shift) another_shift_application = ApplicationFactory.create() # Cancelled applications cancelled_application = ApplicationFactory.create( shift=self.shift, state=ApplicationStateEnum.CANCELLED) data = self.get_transition_data() first_application.approve(data) first_application.save() first_application.refresh_from_db() self.assertEqual(first_application.state, ApplicationStateEnum.APPROVED) second_application.refresh_from_db() self.assertEqual(second_application.state, ApplicationStateEnum.POSTPONED) cancelled_application.refresh_from_db() self.assertEqual(cancelled_application.state, ApplicationStateEnum.CANCELLED) another_shift_application.refresh_from_db() self.assertEqual(another_shift_application.state, ApplicationStateEnum.NEW) mock_process_approving.assert_called_with(first_application, data['user'], data['text']) mock_process_postponing.assert_called_with(second_application)
def test_daily_make_confirmed_applications_completed_for_ended_shifts( self, mock_process_completing): not_ended_shift = ShiftFactory.create() confirmed_application_for_not_ended_shift = ApplicationFactory.create( shift=not_ended_shift, state=ApplicationStateEnum.CONFIRMED) ended_shift = ShiftFactory.create( date_start=timezone.now() - timedelta(days=3), date_end=timezone.now() - timedelta(days=2)) new_application = ApplicationFactory.create( shift=ended_shift, state=ApplicationStateEnum.NEW) confirmed_application = ApplicationFactory.create( shift=ended_shift, state=ApplicationStateEnum.CONFIRMED) completed_application = ApplicationFactory.create( shift=ended_shift, state=ApplicationStateEnum.COMPLETED) daily_make_confirmed_applications_completed_for_ended_shifts() confirmed_application_for_not_ended_shift.refresh_from_db() self.assertEqual(confirmed_application_for_not_ended_shift.state, ApplicationStateEnum.CONFIRMED) new_application.refresh_from_db() self.assertEqual(new_application.state, ApplicationStateEnum.NEW) completed_application.refresh_from_db() self.assertEqual(completed_application.state, ApplicationStateEnum.COMPLETED) confirmed_application.refresh_from_db() self.assertEqual(confirmed_application.state, ApplicationStateEnum.COMPLETED) mock_process_completing.assert_called_once_with( confirmed_application, ended_shift.owner.user_ptr, '')
def test_cancel_approved_not_started(self, mock_process_renewing, mock_process_cancelling): """ Checks that cancelling an application for the not started shift makes the application cancelled and renews all postponed applications """ self.shift.date_start = timezone.now() + timedelta(hours=1) self.shift.save() another_shift_postponed_application = ApplicationFactory( state=ApplicationStateEnum.POSTPONED) postponed_application = ApplicationFactory.create( shift=self.shift, state=ApplicationStateEnum.POSTPONED) application = ApplicationFactory.create( shift=self.shift, state=ApplicationStateEnum.APPROVED) data = self.get_transition_data() application.cancel(data) application.save() application.refresh_from_db() self.assertEqual(application.state, ApplicationStateEnum.CANCELLED) postponed_application.refresh_from_db() self.assertEqual(postponed_application.state, ApplicationStateEnum.NEW) another_shift_postponed_application.refresh_from_db() self.assertEqual(another_shift_postponed_application.state, ApplicationStateEnum.POSTPONED) mock_process_cancelling.assert_called_with(application, data['user'], data['text']) mock_process_renewing.assert_called_with(postponed_application)
def test_order_by_without_messages_first(self): def assert_applications_pks_equal_to(pks): applications = Application.objects \ .order_by_without_messages_first() \ .values_list('pk', flat=True) self.assertListEqual(list(applications), pks) # Create fourths applications without messages # They should be ordered by date first_application = ApplicationFactory.create() second_application = ApplicationFactory.create() third_application = ApplicationFactory.create() fourth_application = ApplicationFactory.create() assert_applications_pks_equal_to([ fourth_application.pk, third_application.pk, second_application.pk, first_application.pk, ]) # Create a message for third application. So, the third application # should be places after all application without messages MessageFactory.create(owner=self.resident, application=third_application) assert_applications_pks_equal_to([ fourth_application.pk, second_application.pk, first_application.pk, third_application.pk, ]) # Create a message for first application. So, the first application # should be places after all application without messages and # ordered by date MessageFactory.create(owner=self.resident, application=first_application) assert_applications_pks_equal_to([ fourth_application.pk, second_application.pk, third_application.pk, first_application.pk, ]) # Create a message for fourth application. So, the fourth application # should be places after all application without messages and # ordered by date MessageFactory.create(owner=self.resident, application=fourth_application) assert_applications_pks_equal_to([ second_application.pk, fourth_application.pk, third_application.pk, first_application.pk, ])
def test_has_already_applied_for_resident_equals_true(self): # Create an application by our resident ApplicationFactory.create(shift=self.shift, owner=self.resident) self.request.user = self.resident.user_ptr serializer = ShiftSerializer(instance=self.shift, context={'request': self.request}) self.assertTrue(serializer.data['has_already_applied'])
def test_invite_for_covered_completed_shift_by_scheduler_failed(self): self.authenticate_as_scheduler() ApplicationFactory.create(shift=self.first_shift, state=ApplicationStateEnum.APPROVED) data = self.get_invite_data() resp = self.client.post('/api/shifts/application/invite/', data, format='json') self.assertBadRequest(resp) self.assertEqual( resp.data['shift'], ['You can not create an application for coverage completed shift'])
def test_list_by_scheduler_success(self): self.authenticate_as_scheduler() application = ApplicationFactory.create(owner=self.approved_resident, shift=self.first_shift) ApplicationFactory.create(owner=self.approved_resident, shift=self.second_shift) resp = self.client.get('/api/shifts/application/') self.assertSuccessResponse(resp) data = resp.data self.assertEqual(len(data), 1) self.assertEqual(data[0]['pk'], application.pk)
def setUp(self): super(MessageViewSetTestCase, self).setUp() self.first_shift.owner = self.scheduler self.first_shift.save() self.first_application = ApplicationFactory.create( owner=self.approved_resident, shift=self.first_shift) self.second_application = ApplicationFactory.create( owner=self.approved_resident, shift=self.second_shift) self.third_application = ApplicationFactory.create( shift=self.second_shift) self.first_application_message = MessageFactory.create( application=self.first_application, owner=self.scheduler) self.second_application_message = MessageFactory.create( application=self.second_application, owner=self.approved_resident)
def test_can_confirm_not_started_shift(self): application = ApplicationFactory.create( owner=self.resident, shift=self.shift, state=ApplicationStateEnum.APPROVED) self.assertTrue(can_proceed(application.confirm))
def test_can_not_complete_not_ended_shift(self): application = ApplicationFactory.create( owner=self.resident, shift=self.shift, state=ApplicationStateEnum.CONFIRMED) self.assertFalse(can_proceed(application.complete))
def test_state_for_ended_shift(self): self.shift.date_end = timezone.now() - timedelta(hours=1) self.shift.save() self.assertEqual(self.shift.state, ShiftStateEnum.FAILED) application = ApplicationFactory.create(shift=self.shift, state=ApplicationStateEnum.NEW) self.assertEqual(self.shift.state, ShiftStateEnum.FAILED) application.state = ApplicationStateEnum.CANCELLED application.save() self.assertEqual(self.shift.state, ShiftStateEnum.FAILED) application.state = ApplicationStateEnum.APPROVED application.save() self.assertEqual(self.shift.state, ShiftStateEnum.FAILED) application.state = ApplicationStateEnum.CONFIRMED application.save() self.assertEqual(self.shift.state, ShiftStateEnum.COMPLETED) application.state = ApplicationStateEnum.COMPLETED application.save() self.assertEqual(self.shift.state, ShiftStateEnum.COMPLETED)
def test_invite_second_time_by_approved_resident_failed(self): self.authenticate_as_scheduler() # Create an early-created application ApplicationFactory.create(owner=self.approved_resident, shift=self.first_shift) data = self.get_invite_data() resp = self.client.post('/api/shifts/application/invite/', data, format='json') self.assertBadRequest(resp) self.assertEqual( resp.data['non_field_errors'], ['There is an already created application for the shift'])
def test_approve_permissions(self): application = ApplicationFactory.create(owner=self.resident, shift=self.shift) # Resident can't approve application self.assertFalse( has_transition_perm(application.approve, self.resident.user_ptr)) # Scheduler can accept own shift's applications self.assertTrue( has_transition_perm(application.approve, self.scheduler.user_ptr)) another_application = ApplicationFactory.create() # Scheduler can't approve now own shift's applications self.assertFalse( has_transition_perm(another_application.approve, self.scheduler.user_ptr))
def test_last_message_when_have_messages_equals_to_last_message(self): application = ApplicationFactory.create(owner=self.resident) # The first message MessageFactory.create(owner=self.resident, application=application) # The second (last) message last_message = MessageFactory.create(owner=self.resident, application=application) self.assertEqual(application.last_message, last_message)
def test_can_not_reject_started_shift(self): self.shift.date_start = timezone.now() - timedelta(hours=2) self.shift.date_end = timezone.now() - timedelta(hours=1) self.shift.save() application = ApplicationFactory.create(owner=self.resident, shift=self.shift, state=ApplicationStateEnum.NEW) self.assertFalse(can_proceed(application.reject))
def test_can_complete_ended_shift(self): self.shift.date_start = timezone.now() - timedelta(hours=2) self.shift.date_end = timezone.now() - timedelta(hours=1) self.shift.save() application = ApplicationFactory.create( owner=self.resident, shift=self.shift, state=ApplicationStateEnum.CONFIRMED) self.assertTrue(can_proceed(application.complete))
def test_reject_permissions(self): application = ApplicationFactory.create(owner=self.resident, shift=self.shift) # Resident can't reject application self.assertFalse( has_transition_perm(application.reject, self.resident.user_ptr)) # Scheduler can reject own shift's applications self.assertTrue( has_transition_perm(application.reject, self.scheduler.user_ptr))
def test_reject(self, mock_process_rejecting): data = self.get_transition_data() application = ApplicationFactory.create() application.reject(data) application.save() application.refresh_from_db() self.assertEqual(application.state, ApplicationStateEnum.REJECTED) mock_process_rejecting.assert_called_with(application, data['user'], data['text'])
def test_confirm(self, mock_process_confirming): data = self.get_transition_data() application = ApplicationFactory.create( state=ApplicationStateEnum.APPROVED) application.confirm(data) application.save() application.refresh_from_db() self.assertEqual(application.state, ApplicationStateEnum.CONFIRMED) mock_process_confirming.assert_called_with(application, data['user'], data['text'])
def test_state_for_not_started_shift(self): self.assertEqual(self.shift.state, ShiftStateEnum.WITHOUT_APPLIES) application = ApplicationFactory.create(shift=self.shift, state=ApplicationStateEnum.NEW) self.assertEqual(self.shift.state, ShiftStateEnum.REQUIRE_APPROVAL) application.state = ApplicationStateEnum.APPROVED application.save() self.assertEqual(self.shift.state, ShiftStateEnum.COVERAGE_COMPLETED) application.state = ApplicationStateEnum.CANCELLED application.save() self.assertEqual(self.shift.state, ShiftStateEnum.WITHOUT_APPLIES)
def setUp(self): self.request = ExtendedRequestFactory() self.scheduler = SchedulerFactory.create() self.resident = ResidentFactory.create() self.shift = ShiftFactory.create(owner=self.scheduler) self.application = ApplicationFactory.create(shift=self.shift) self.message = MessageFactory.create(owner=self.resident, application=self.application, text='test text') self.message2 = MessageFactory.create(owner=self.resident, application=self.application, text='see attachment', attachment=SimpleUploadedFile( 'text.txt', b'Some text in file'))
def test_complete_permissions(self): self.shift.date_start = timezone.now() - timedelta(hours=2) self.shift.date_end = timezone.now() - timedelta(hours=1) self.shift.save() application = ApplicationFactory.create( owner=self.resident, shift=self.shift, state=ApplicationStateEnum.CONFIRMED) # Resident can't complete confirmed application self.assertFalse( has_transition_perm(application.complete, self.resident.user_ptr)) # Scheduler can complete confirmed applications self.assertTrue( has_transition_perm(application.complete, self.scheduler.user_ptr))
def test_complete(self, mock_process_completing): self.shift.date_start = timezone.now() - timedelta(hours=2) self.shift.date_end = timezone.now() - timedelta(hours=1) self.shift.save() application = ApplicationFactory.create( shift=self.shift, state=ApplicationStateEnum.CONFIRMED) data = self.get_transition_data() application.complete(data) application.save() application.refresh_from_db() self.assertEqual(application.state, ApplicationStateEnum.COMPLETED) mock_process_completing.assert_called_with(application, data['user'], data['text'])
def test_can_reject_not_started_shift(self): application = ApplicationFactory.create(owner=self.resident, shift=self.shift, state=ApplicationStateEnum.NEW) self.assertTrue(can_proceed(application.reject))
def setUp(self): self.scheduler = SchedulerFactory.create() self.resident = ResidentFactory.create() self.shift = ShiftFactory.create(owner=self.scheduler) self.application = ApplicationFactory.create(shift=self.shift, owner=self.resident)
def test_aggregate_count_by_state(self): ApplicationFactory.create(state=ApplicationStateEnum.CANCELLED) ApplicationFactory.create(state=ApplicationStateEnum.APPROVED) ApplicationFactory.create(state=ApplicationStateEnum.REJECTED) ApplicationFactory.create(state=ApplicationStateEnum.REJECTED) ApplicationFactory.create(state=ApplicationStateEnum.POSTPONED) ApplicationFactory.create(state=ApplicationStateEnum.POSTPONED) applications_count = Application.objects.aggregate_count_by_state() self.assertDictEqual( applications_count, { ApplicationStateEnum.CANCELLED: 1, ApplicationStateEnum.APPROVED: 1, ApplicationStateEnum.REJECTED: 2, ApplicationStateEnum.POSTPONED: 2, })
def test_last_message_when_do_not_have_messages_is_none(self): application = ApplicationFactory.create() self.assertIsNone(application.last_message)