def test_get_all_queued_events(self): patient = Patient() patient.save() sendable = InfoMessage(text="Test Message", way_of_communication = get_woc("sms")) sendable.recipient = patient sendable.save() self.assertEquals(scheduler.get_all_queued_events().count(), 0) schedule1 = ScheduledEvent(sendable=sendable, send_time=datetime.now(), state = "queued") schedule1.save() self.assertEquals(scheduler.get_all_queued_events().count(), 1) schedule2 = ScheduledEvent(sendable=sendable, send_time=(datetime.now() - timedelta(days=1)), state = "sent") schedule2.save() self.assertTrue(schedule1 in scheduler.get_all_queued_events()) self.assertFalse(schedule2 in scheduler.get_all_queued_events()) self.assertEquals(scheduler.get_all_queued_events().count(), 1) schedule2.state = "queued" schedule2.save() self.assertEquals(scheduler.get_all_queued_events().count(), 2) schedule1.delete() schedule2.delete()
def manage_groups(self, infoservice_type, table_head, member_button, remove_button, remove_patient_button, group_name): info = InfoService(name = "testgroup", type = infoservice_type) info.save() patient = Patient(phone_number = "012345") patient.save() subscription = Subscription(infoservice = info, patient = patient, way_of_communication = get_woc("voice")) subscription.save() response = self.client.get(reverse("infoservices_index", kwargs = {'infoservice_type': infoservice_type})) self.assertContains(response, member_button) self.assertContains(response, remove_button) self.assertContains(response, table_head) response = self.client.get(reverse("infoservices_members", kwargs={"id": info.id, })) self.assertContains(response, patient.phone_number) self.assertContains(response, remove_patient_button) self.assertContains(response, group_name)
def create_and_save_notification(self, way_of_communication, phone_number): self.create_notification(way_of_communication) patient = Patient() patient.phone_number = phone_number self.client.post(reverse('web_authenticate_phonenumber'), \ {'patient': patient}) return self.client.get(reverse("notifications_save"))
def set_session_variables_for_register(request): ''' session variables way_of_communication and patient are filled ''' woc = WayOfCommunication.objects.get(pk = request.POST['way_of_communication']) request.session['way_of_communication'] = woc patient = Patient() patient.phone_number = request.POST['phone_number'] request.session['patient'] = patient
def test_get_all_due_events(self): patient = Patient() patient.save() # The fixtures already contain two due events self.assertEquals(scheduler.get_all_due_events().count(), 2) sendable = InfoMessage(text="Test Message", way_of_communication = get_woc("sms")) sendable.recipient = patient sendable.save() schedule1 = ScheduledEvent(sendable=sendable, send_time=datetime.now()) schedule1.save() schedule2 = ScheduledEvent(sendable=sendable, send_time=(datetime.now() - timedelta(days=1))) schedule2.save() schedule3 = ScheduledEvent(sendable=sendable, send_time=(datetime.now() + timedelta(days=1))) schedule3.save() self.assertEquals(scheduler.get_all_due_events().count(), 4) self.assertTrue(schedule1 in scheduler.get_all_due_events()) self.assertTrue(schedule2 in scheduler.get_all_due_events()) self.assertFalse(schedule3 in scheduler.get_all_due_events()) schedule4 = ScheduledEvent(sendable=sendable, send_time=datetime.now(), state = "failed") schedule4.save() schedule5 = ScheduledEvent(sendable=sendable, send_time=(datetime.now() - timedelta(days=1)), state = "sent") schedule5.save() self.assertEquals(scheduler.get_all_due_events().count(), 4) schedule1.delete() schedule2.delete() schedule3.delete() schedule4.delete() schedule5.delete()
def setUp(self): self.info = InfoService(name = "testinfoservice", type="information") self.info.save() self.patient = Patient(name="eu",phone_number = "01234") self.patient.save() self.subscription = Subscription(infoservice = self.info, way_of_communication = get_woc("sms"), patient = self.patient) self.subscription.save()
class InfoServiceModelTest(TestCase): def setUp(self): self.infoservice = InfoService(name = "Gruppe", type="information") self.infoservice.save() self.patient = Patient() self.patient.save() def test_no_infoservices_with_same_name(self): first_infoservice = InfoService(name ="Hospitalinfos", type="information") first_infoservice.save() second_infoservice = InfoService(name ="Hospitalinfos", type="information") self.assertRaises(IntegrityError, second_infoservice.save) def test_no_infoservices_with_no_name(self): self.assertRaises(IntegrityError, InfoService(name = None).save) self.assertRaises(IntegrityError, InfoService().save) def test_no_infoservices_with_empty_type(self): an_infoservice = InfoService(name = "Hospitalinfos") self.assertRaises(IntegrityError, an_infoservice.save)
class SubscriptionTest(TestCase): fixtures = ["backend_test"] def setUp(self): self.woc = get_woc("sms") self.infoservice = InfoService(name = "Gruppe", type = "information") self.infoservice.save() self.patient = Patient() self.patient.save() self.subscription = Subscription(patient = self.patient, infoservice = self.infoservice, way_of_communication = self.woc) self.subscription.save() def test_infoservice_member_relation_add(self): self.assertTrue(self.patient in self.infoservice.members.all()) def test_infoservice_member_relation_delete(self): self.subscription.delete() self.assertTrue(self.patient not in self.infoservice.members.all()) def test_subscription_creation(self): subscription = Subscription() self.assertRaises(IntegrityError, subscription.save) infoservice = InfoService(name = "information", type="information") infoservice.save() subscription.patient = self.patient subscription.infoservice = infoservice subscription.way_of_communication = self.woc subscription.save() self.assertEquals(self.infoservice.members.all().count(), 1) self.assertEquals(self.infoservice.members.all()[0], self.patient) self.assertTrue(subscription in Subscription.objects.all())
def setUp(self): self.woc = get_woc("sms") self.infoservice = InfoService(name = "Gruppe", type = "information") self.infoservice.save() self.patient = Patient() self.patient.save() self.subscription = Subscription(patient = self.patient, infoservice = self.infoservice, way_of_communication = self.woc) self.subscription.save()
class WebInfoServiceTest(TestCase): fixtures = ['backend_test'] def setUp(self): self.info = InfoService(name = "testinfoservice", type="information") self.info.save() self.patient = Patient(name="eu",phone_number = "01234") self.patient.save() self.subscription = Subscription(infoservice = self.info, way_of_communication = get_woc("sms"), patient = self.patient) self.subscription.save() def create_register_form(self): response = self.client.get(reverse('groups_register', kwargs={'group_id': self.info.id})) self.failUnlessEqual(response.status_code, 200) self.assertContains(response, 'name="phone_number"') self.assertContains(response, 'name="way_of_communication"') return response def test_infoservices_on_main_page(self): response = self.client.get(reverse('web_index')) infoservices = InfoService.objects.all() for infoservice in infoservices: if infoservice.type == "information": self.assertContains(response, infoservice.name) self.assertContains(response, reverse('groups_register', kwargs={'group_id': infoservice.id})) else: self.assertNotContains(response, infoservice.name) @disable_authentication def test_register(self): redirection_path = reverse('groups_register_save', \ kwargs = {'group_id': self.info.id}) self.create_register_form() response = self.client.post(reverse('groups_register', kwargs={'group_id': self.info.id}), {'way_of_communication': 1, 'phone_number':'01234 / 56789012'}) self.assertTrue(self.client.session.has_key('way_of_communication')) self.assertTrue(self.client.session.has_key('authenticate_phonenumber')) self.assertEquals(response.status_code, 302) self.assertRedirects(response, redirection_path) return response @disable_authentication def test_register_submit_validations(self): response = self.client.post(reverse('groups_register', kwargs={'group_id': self.info.id}), {'way_of_communication': 1, 'phone_number':'01234 / 56789012'}) self.assertEquals(response.status_code, 302) response = self.client.post(reverse('groups_register', kwargs={'group_id': self.info.id}), {'way_of_communication': 1, 'phone_number':'0123afffg789012'}) self.assertContains(response, 'Please enter numbers only') response = self.client.post(reverse('groups_register', kwargs={'group_id': self.info.id}), {'way_of_communication': 1, 'phone_number':'234 / 56789012'}) self.assertContains(response, 'Please enter a cell phone number.') def test_register_save(self): subscription_count = Subscription.objects.all().count() self.client.post(reverse('groups_register', kwargs={'group_id': self.info.id}), {"way_of_communication": 1, "phone_number": "0123456"}) response = self.client.get(reverse('groups_register_save', kwargs={'group_id': self.info.id})) self.assertEquals(Subscription.objects.all().count(), subscription_count + 1) new_subscription = last(Subscription) self.assertEquals(new_subscription.patient.phone_number, "0123456") self.assertEquals(new_subscription.infoservice, self.info) self.assertEquals(new_subscription.way_of_communication, get_woc("sms")) def test_remove_subscription(self): subscription_count = Subscription.objects.all().count() self.subscription.delete() self.assertEquals(Subscription.objects.all().count(), subscription_count - 1) self.assertTrue(Subscription.objects.filter(pk = self.info.id).count() == 0)
def setUp(self): self.infoservice = InfoService(name = "Gruppe", type="information") self.infoservice.save() self.patient = Patient() self.patient.save()
def create_notification(request, notification_type_name = None): ''' Display the form and creates a new notification, but does not save it yet. Redirect to authentication if switched on ''' notification_type = NotificationType.objects. \ filter(name = notification_type_name)[0] nexturl = "" backurl = reverse('web_index') ways_of_communication = get_ways_of_communication( notification_type.notify_immediately) if request.method == "POST": data = deepcopy(request.POST) if notification_type.notify_immediately: data['date'] = date.today().strftime('%Y-%m-%d') + \ ' ' + DEFAULT_SEND_TIME else: data['date'] = data.get('date', '') + ' ' + DEFAULT_SEND_TIME form = NotificationValidationForm(data) woc = get_woc_by_id( request.POST['way_of_communication'] ) if not woc.can_send_immediately: form = NotificationValidationFormBluetooth(data) if form.is_valid(): notification = Notification() patient = Patient() if woc.can_send_immediately: patient.phone_number = form.cleaned_data['phone_number'] notification.date = form.cleaned_data['date'] notification.notification_type = notification_type notification.hospital = Hospital.get_current_hospital() notification.way_of_communication = \ form.cleaned_data['way_of_communication'] request.session['notification'] = notification request.session['patient'] = patient logger.info("Create notification via %s" % notification.way_of_communication.verbose_name) if notification.way_of_communication == get_woc('bluetooth'): return HttpResponseRedirect(reverse("web_list_devices") + \ "?next=" + reverse("notifications_send")) elif notification.way_of_communication.name in ('sms', 'voice' ): return redirect_to_authentication_or( reverse("notifications_save")) else: logger.error("Unknown way of communication selected.") raise Exception ("Unknown way of communication %s " \ %notification.way_of_communication.\ verbose_name + "(this is neither " + \ "bluetooth nor sms or voice)") else: logger.info("create_notification: Invalid form.") return render_to_response('notifications/create.html', locals(), context_instance=RequestContext(request))
def test_check_spool_files(self): def get_mock_status(filename): """ This is a mock method to represent check_spoolfile_status It is told which status to return by using the (in this case useless) filename parameter """ return filename original_get_spoolfile_status = scheduler.get_spoolfile_status scheduler.get_spoolfile_status = get_mock_status patient = Patient() patient.save() sendable = InfoMessage(text="Test Message", way_of_communication = get_woc("sms")) sendable.recipient = patient sendable.save() event1 = ScheduledEvent(sendable=sendable, send_time=datetime.now(), state = "queued", filename = "Completed") event1.save() event2 = ScheduledEvent(sendable=sendable, send_time=datetime.now(), state = "queued", filename = "Expired") event2.save() # now: the real testing scheduler.check_spool_files() self.assertEquals(ScheduledEvent.objects.get(pk = event1.pk).state, \ "done") self.assertEquals(ScheduledEvent.objects.get(pk = event2.pk).state, \ "new") event2.filename = "Expired" event2.save() scheduler.check_spool_files() self.assertEquals(ScheduledEvent.objects.get(pk = event2.pk).state, \ "new") self.assertEquals(ScheduledEvent.objects.get(pk = event2.pk).retry, 1) event2.retry = settings.ASTERISK_RETRY event2.filename = "Expired" event2.save() scheduler.check_spool_files() self.assertEquals(ScheduledEvent.objects.get(pk = event2.pk).state, \ "failed") event3 = ScheduledEvent(sendable=sendable, send_time=datetime.now(), state = "queued", filename = "Failed") event3.save() scheduler.check_spool_files() self.assertEquals(ScheduledEvent.objects.get(pk = event3.pk).state, \ "failed") # change everything back to normal event1.delete() event2.delete() event3.delete() scheduler.get_spoolfile_status = original_get_spoolfile_status