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
