def setUp(self):
"""
Must call setUp() on BaseTestClass to setup the test application
:return: N/A
"""
super(BookingTest, self).setUp()
self.booking_url = "http://localhost:5000/booking"
self.patient_id = "16"
self.availability_id = "20"
cache.reset_cache()
""" Log in user """
self.login_url = "http://localhost:5000/login"
self.valid_health_card_nb = "DRSJ 9971 0157"
self.password = "******"
valid_health_card_and_pw = {
"health_card_nb": self.valid_health_card_nb,
"password": self.password
}
response = self.send_post(self.login_url, valid_health_card_and_pw)
self.assert_status_code(response, 200)
""" Create and store patient in cache"""
PatientService().test_and_set_patient_into_cache(self.patient_id)
patient = cache.get_from_cache(self.patient_id)
availability = Availability(self.availability_id, "20", "32400", "881",
"1", "2019", "4", "8",
AppointmentRequestType.WALKIN)
appointment = Appointment(self.patient_id, availability)
patient.add_walkin_to_cart(appointment)
def test_notify(self):
patient = Patient(1, "Samuel", "Gosselin", "bla", "2000", 'male', "21",
"21", "222")
set_to_cache(1, patient)
patient2 = Patient(2, "Samuel", "Gosselin", "bla", "2000", 'male',
"21", "21", "222")
set_to_cache(2, patient2)
observable = AvailabilityCanceledObservable()
availability1 = Availability(2, 2, 32400, 53, 0, 2019, 3, 31,
AppointmentRequestType.ANNUAL.value)
patient_availability_pair = {1: availability1}
patient_availability_pair2 = {2: availability1}
observable.attach(patient_availability_pair)
observable.attach(patient_availability_pair2)
observable.notify()
patient = get_from_cache(1)
patient2 = get_from_cache(2)
assert (len(patient.get_login_messages()) == 1)
assert (len(patient2.get_login_messages()) == 1)
assert (False, observable.patient_id_availabilities.__contains__(1))
assert (False, observable.patient_id_availabilities.__contains__(2))
def validate_availability_and_reserve(self, availability_id):
select_stmt = '''SELECT * FROM Availability
WHERE id = ?
AND free = 1'''
update_stmt = '''UPDATE Availability
SET free = 0
WHERE id = ?'''
params = (availability_id,)
result = self.db.read_one(select_stmt, params)
if result is None:
print("Cannot validate availability.")
return None
else:
self.db.write_one(update_stmt, params)
return Availability(
result['id'],
result['doctor_id'],
result['start'],
result['room'],
result['free'],
result['year'],
result['month'],
result['day'],
uber_sante.models.scheduler.AppointmentRequestType(result['booking_type']),
result['clinic_id'])
def get_availability_by_clinic_id(self, clinic_id):
""" Queries the Availability db by availability_id and returns an Availability object """
select_stmt = '''SELECT * FROM Availability
WHERE clinic_id = ?'''
params = (clinic_id,)
results = self.db.read_all(select_stmt, params)
if len(results) == 0:
return AvailabilityStatus.NO_AVAILABILITIES
list_of_availabilities = []
for result in results:
list_of_availabilities.append(
Availability(
result['id'],
result['doctor_id'],
convert_time.get_start_time_string(result['start']),
result['room'],
result['free'],
result['year'],
result['month'],
result['day'],
uber_sante.models.scheduler.AppointmentRequestType(result['booking_type']),
result['clinic_id']))
return list_of_availabilities
def get_availabilities(self, schedule_request, clinic_id):
"""
Queries the Availability table according to the schedule_request object
which specifies to query for the month or for a specific day only,
and for annual, walkin, or all booking types.
"""
date = schedule_request.get_request_date()
year = date.get_year()
month = date.get_month()
appointment_request_type = schedule_request.get_appointment_request_type_value()
if schedule_request.is_daily_request():
day = date.get_day()
# If the booking_type is BookingType.ALL (which has value ""), it will select all rows
select_stmt = '''SELECT * FROM Availability
WHERE year = ?
AND month = ?
AND day = ?
AND free = 1
AND (? = "ALL" OR booking_type = ?)
AND clinic_id = ?'''
params = (year, month, day, appointment_request_type, appointment_request_type, clinic_id)
elif schedule_request.is_monthly_request():
# If the booking_type is BookingType.ALL (which has value ""), it will select all rows
select_stmt = '''SELECT * FROM Availability
WHERE year = ?
AND month = ?
AND free = 1
AND (? = "ALL" OR booking_type = ?)
AND clinic_id = ?'''
params = (year, month, appointment_request_type, appointment_request_type, clinic_id)
results = self.db.read_all(select_stmt, params)
list_of_availabilities = []
for result in results:
list_of_availabilities.append(
Availability(
result['id'],
result['doctor_id'],
convert_time.get_start_time_string(result['start']),
result['room'],
result['free'],
result['year'],
result['month'],
result['day'],
result['booking_type'],
result['clinic_id']))
return list_of_availabilities
def test_detach(self):
observable = AvailabilityCanceledObservable()
availability1 = Availability(2, 2, 32400, 53, 0, 2019, 3, 31,
AppointmentRequestType.ANNUAL.value)
patient_availability_pair = {1: availability1}
observable.attach(patient_availability_pair)
observable.detach(1)
assert (False, observable.patient_id_availabilities.__contains__(1))
def test_attach(self):
""" testing all the cases of the attach method"""
# case where the observable does not hold the patient_id
observable = AvailabilityCanceledObservable()
availability1 = Availability(2, 2, 32400, 53, 0, 2019, 3, 31,
AppointmentRequestType.ANNUAL.value)
patient_availability_pair = {1: availability1}
observable.attach(patient_availability_pair)
assert (observable.patient_id_availabilities.__contains__(1))
assert (False, isinstance(observable.patient_id_availabilities[1],
list))
# now testing the case where the observable already holds the patient_id
availability2 = Availability(3, 3, 32400, 103, 0, 2019, 3, 2,
AppointmentRequestType.WALKIN.value)
patient_availability_pair2 = {1: availability2}
observable.attach(patient_availability_pair2)
assert (isinstance(observable.patient_id_availabilities[1], list))
# now testing that we append a availability to the list for the patient_id
availability3 = Availability(4, 3, 3200, 100, 0, 1990, 1, 10,
AppointmentRequestType.ANNUAL.value)
patient_availability_pair3 = {1: availability3}
observable.attach(patient_availability_pair3)
assert (len(observable.patient_id_availabilities[1]) == 3)
def get_availability(self, availability_id):
""" Queries the Availability db by availability_id and returns an Availability object """
select_stmt = '''SELECT * FROM Availability
WHERE id = ?'''
params = (availability_id,)
result = self.db.read_one(select_stmt, params)
if result is None:
return False
return Availability(
result['id'],
result['doctor_id'],
convert_time.get_start_time_string(result['start']),
result['room'],
result['free'],
result['year'],
result['month'],
result['day'],
uber_sante.models.scheduler.AppointmentRequestType(result['booking_type']),
result['clinic_id'])
Date(2018, DateEnum.APRIL, 16))
sr_monthly = ScheduleRequest(RequestEnum.MONTHLY_REQUEST,
AppointmentRequestType.ALL,
Date(2019, DateEnum.APRIL, 16))
monthly_avails = []
# Get availabilities for a single month
for repetitions in range(1, 12 + 1):
for day in range(1, 27 + 1):
for num_avails in range(1, 15 + 1):
monthly_avails.append(
Availability(
-1, -1, num_avails * 3600 +
(num_avails + repetitions) * 20, "RM", True, 2018,
7, day, AppointmentRequestType.ALL))
# Get availabilities for a single day
daily_avails = []
for num_avails in range(1, 15 + 1):
daily_avails.append(
Availability(
-1, -1,
num_avails * 3600 + (num_avails + repetitions) * 20, "RM",
True, 2019, DateEnum.APRIL.value, 16,
AppointmentRequestType.ALL))
# create a monthly schedule
monthly_schedule = Scheduler.get_instance().get_schedule(
sr_monthly, monthly_avails)
def as_dict(self):
dict = {}
for day in range(self.min_date_key, self.max_date_key + 1):
dict[day] = self.daily_schedules[day].as_dict()
return dict
if __name__ == "__main__":
avails = []
for repetitions in range(1, 12 + 1):
for day in range(1, 27 + 1):
for num_avails in range(1, 15 + 1):
avails.append(
Availability(
-1, -1,
num_avails * 3600 + (num_avails + repetitions) * 20,
"RM", True, 2018, 7, day, uber_sante.models.scheduler.
AppointmentRequestType.ALL))
m = MonthlySchedule(avails, Date(2018, 7))
for sched in m.get_list_of_daily_schedules():
print("{}, avail?{}".format(sched.get_schedule_date_string(),
sched.availability_exists_today()))