class TestPatientPageVisualisationWithNoObsData(TestCommon):
"""
Test that the No observation data available for patient message
is shown on no obs being available
"""
def setUp(self):
self.driver.get(MOB_LOGIN)
self.login_page = LoginPage(self.driver)
self.list_page = ListPage(self.driver)
self.patient_page = PatientPage(self.driver)
self.login_page.login(NURSE_USERNM1, NURSE_PWD1)
self.list_page.go_to_patient_list()
patients = self.list_page.get_list_items()
patient_to_test = patients[0]
self.patient_url = patient_to_test.get_attribute('href')
patient_id = self.patient_url.replace(
PATIENT_PAGE, ''
)
self.patient_page.remove_observations_for_patient(int(patient_id))
self.driver.get(self.patient_url)
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located(GRAPH_CHART)
)
def test_shows_message_when_no_obs(self):
"""
Test that the No observation data available for patient message is
shown on no obs being available
"""
self.assertTrue(self.patient_page.has_no_patient_data(),
'No Observation Data Available message not found')
class TestPatientPageVisualisationWithNoObsData(TestCommon):
"""
Test that the No observation data available for patient message
is shown on no obs being available
"""
def setUp(self):
self.driver.get(MOB_LOGIN)
self.login_page = LoginPage(self.driver)
self.list_page = ListPage(self.driver)
self.patient_page = PatientPage(self.driver)
self.login_page.login(NURSE_USERNM1, NURSE_PWD1)
self.list_page.go_to_patient_list()
patients = self.list_page.get_list_items()
patient_to_test = patients[0]
self.patient_url = patient_to_test.get_attribute('href')
patient_id = self.patient_url.replace(PATIENT_PAGE, '')
self.patient_page.remove_observations_for_patient(int(patient_id))
self.driver.get(self.patient_url)
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located(GRAPH_CHART))
def test_shows_message_when_no_obs(self):
"""
Test that the No observation data available for patient message is
shown on no obs being available
"""
self.assertTrue(self.patient_page.has_no_patient_data(),
'No Observation Data Available message not found')
def test_gcs_obs(self):
"""
Test that a GCS observation can be submitted
"""
gcs_inputs = GCS_SCORE_15_DATA
patients = self.patient_list_page.get_list_items()
PatientPage(self.driver).select_patient(patients)
PatientPage(self.driver).open_form(OPEN_OBS_MENU_GCS)
PatientPage(self.driver).enter_obs_data(gcs_inputs)
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located(CONFIRM_SUBMIT)
)
self.driver.find_element(*CONFIRM_SUBMIT).click()
success = 'Successfully Submitted GCS Observation'
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located((
SUCCESSFUL_SUBMIT))
)
response = self.driver.find_element(*SUCCESSFUL_SUBMIT)
self.assertEqual(success, response.text,
'GCS observation unsuccessful')
def setUp(self):
self.driver.get(MOB_LOGIN)
self.login_page = LoginPage(self.driver)
self.list_page = ListPage(self.driver)
self.patient_page = PatientPage(self.driver)
self.login_page.login(NURSE_USERNM1, NURSE_PWD1)
self.list_page.go_to_patient_list()
patients = self.list_page.get_list_items()
patient_to_test = patients[0]
self.patient_url = patient_to_test.get_attribute('href')
self.driver.get(self.patient_url)
def setUp(self):
self.driver.get(MOB_LOGIN)
self.login_page = LoginPage(self.driver)
self.list_page = ListPage(self.driver)
self.patient_page = PatientPage(self.driver)
self.login_page.login(NURSE_USERNM1, NURSE_PWD1)
self.list_page.go_to_patient_list()
patients = self.list_page.get_list_items()
patient_to_test = patients[0]
self.patient_url = patient_to_test.get_attribute('href')
patient_id = self.patient_url.replace(PATIENT_PAGE, '')
self.patient_page.remove_observations_for_patient(int(patient_id))
self.driver.get(self.patient_url)
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located(GRAPH_CHART))
def test_shows_patient_data(self):
"""
Test that a patient record shows data (graph/table) for the patient
"""
patients = self.patient_list_page.get_list_items()
PatientPage(self.driver).select_patient(patients)
ui.WebDriverWait(self.driver, 1).until(
ec.visibility_of_element_located(patient_page_locators.GRAPH_CHART)
)
patient_graph = self.driver.find_element(*
patient_page_locators
.GRAPH_CHART)
self.assertEqual(patient_graph.is_displayed(), True, 'Graph not found')
self.driver.find_element(*patient_page_locators
.TABLE_TAB_BUTTON).click()
ui.WebDriverWait(self.driver, 1).until(
ec.visibility_of_element_located
(patient_page_locators.TABLE_CONTAINER_TABLE))
patient_table = self.driver.find_element(*
patient_page_locators
.TABLE_CONTAINER_TABLE)
self.assertEqual(patient_table.is_displayed(), True, 'Table not found')
def setUp(self):
self.driver.get(MOB_LOGIN)
self.login_page = LoginPage(self.driver)
self.list_page = ListPage(self.driver)
self.patient_page = PatientPage(self.driver)
self.patient_page_graph = PatientPageGraphs(self.driver)
risk_mapping = {
'none': self.patient_page.add_no_risk_observation,
'low': self.patient_page.add_low_risk_observation,
'medium': self.patient_page.add_medium_risk_observation,
'high': self.patient_page.add_high_risk_observation,
'3in1': self.patient_page.add_three_in_one_observation
}
self.login_page.login(NURSE_USERNM1, NURSE_PWD1)
self.list_page.go_to_patient_list()
patients = self.list_page.get_list_items()
patient_to_test = patients[0]
patient_id = patient_to_test.get_attribute('href').replace(
PATIENT_PAGE, '')
self.patient_page.remove_observations_for_patient(int(patient_id))
risk_mapping[self.risk](int(patient_id))
self.driver.get(patient_to_test.get_attribute('href'))
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located((By.CSS_SELECTOR, '#chart svg')))
self.patient_page.change_to_table()
obs_table = self.patient_page.get_obs_table()
rows = self.patient_page.get_table_rows(obs_table)[1:]
self.row_data = []
for row in rows:
self.row_data.append(self.patient_page.get_table_data(row))
self.patient_page_graph.change_to_chart()
# Focus Graphs
focus_graphs = self.patient_page_graph.get_focus_graphs()
self.assertEqual(len(focus_graphs), 5, 'Incorrect number of graphs')
self.graph_list = []
for graph in focus_graphs:
self.graph_list.append(graph)
self.graph_data = self.get_graph_data()
def open_clinical(self, task_id, patient_list_page):
"""
Create a clinical notification for a patient, and then open it
"""
PatientPage(self.driver).add_medium_risk_observation(int(task_id))
patient_list_page.go_to_task_list()
tasks = patient_list_page.get_list_items()
clinical_task = tasks[0]
clinical_task.click()
def test_blood_sugar_obs(self):
"""
Test that a blood sugar observation can be submitted
"""
blood_sugar_input = BLOOD_SUGAR_DATA
patients = self.patient_list_page.get_list_items()
PatientPage(self.driver).select_patient(patients)
PatientPage(self.driver).open_form(OPEN_OBS_MENU_BLOOD_SUGAR)
PatientPage(self.driver).enter_obs_data(blood_sugar_input)
success = 'Successfully Submitted Blood Sugar Observation'
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located((SUCCESSFUL_SUBMIT)))
response = self.driver.find_element(*SUCCESSFUL_SUBMIT)
self.assertEqual(success, response.text,
'Blood sugar observation unsuccessful')
def test_pbp_obs(self):
"""
Test that a postural blood pressure observation can be submitted
"""
postural_pressure_inputs = POSTURAL_BLOOD_PRESSURE_DATA
patients = self.patient_list_page.get_list_items()
PatientPage(self.driver).select_patient(patients)
PatientPage(self.driver).open_form(OPEN_OBS_MENU_POSTURAL_PRESSURE)
PatientPage(self.driver).enter_obs_data(postural_pressure_inputs)
success = 'Successfully Submitted Postural Blood Pressure Observation'
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located((SUCCESSFUL_SUBMIT)))
response = self.driver.find_element(*SUCCESSFUL_SUBMIT)
self.assertEqual(success, response.text,
'Postural blood pressure observation unsuccessful')
def test_bristol_stool_obs(self):
"""
Test that a Bristol Stool Scale observation can be submitted
"""
bristol_stool_inputs = BRISTOL_STOOL_DATA
patients = self.patient_list_page.get_list_items()
PatientPage(self.driver).select_patient(patients)
PatientPage(self.driver).open_form(OPEN_OBS_MENU_BS_SCALE)
PatientPage(self.driver).enter_obs_data(bristol_stool_inputs)
success = 'Successfully Submitted Bristol Stool Scale Observation'
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located((SUCCESSFUL_SUBMIT)))
response = self.driver.find_element(*SUCCESSFUL_SUBMIT)
self.assertEqual(success, response.text,
'Bristol Stool Scale observation unsuccessful')
def test_height_obs(self):
"""
Test that a height observation can be submitted
"""
height_input = HEIGHT_DATA
patients = self.patient_list_page.get_list_items()
PatientPage(self.driver).select_patient(patients)
PatientPage(self.driver).open_form(OPEN_OBS_MENU_HEIGHT)
PatientPage(self.driver).enter_obs_data(height_input)
success = 'Successfully Submitted Height Observation'
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located((SUCCESSFUL_SUBMIT)))
response = self.driver.find_element(*SUCCESSFUL_SUBMIT)
self.assertEqual(success, response.text,
'Height observation unsuccessful')
def setUp(self):
self.driver.get(MOB_LOGIN)
self.login_page = LoginPage(self.driver)
self.list_page = ListPage(self.driver)
self.patient_page = PatientPage(self.driver)
self.login_page.login(NURSE_USERNM1, NURSE_PWD1)
self.list_page.go_to_patient_list()
patients = self.list_page.get_list_items()
patient_to_test = patients[0]
self.patient_url = patient_to_test.get_attribute('href')
self.driver.get(self.patient_url)
def test_up_trend(self):
"""
Test that the trend is increased after submitting a low risk ob,
followed by a high risk ob
"""
tasks = self.patient_list_page.get_list_items()
patient_to_test = tasks[0]
task_id = patient_to_test.get_attribute('href').replace(
PATIENT_PAGE, ''
)
PatientPage(self.driver).add_low_risk_observation(int(task_id))
PatientPage(self.driver).add_high_risk_observation(int(task_id))
self.driver.refresh()
patient_trend = self.driver.find_element(
*list_page_locators.LIST_ITEM_PATIENT_TREND
)
self.assertEqual(patient_trend.get_attribute('class'), 'icon-up-arrow',
'Incorrect trend')
def test_same_trend(self):
"""
Test that the trend stays the same after submitting two of the same ob
"""
tasks = self.patient_list_page.get_list_items()
patient_to_test = tasks[0]
task_id = patient_to_test.get_attribute('href').replace(
PATIENT_PAGE, ''
)
PatientPage(self.driver).add_medium_risk_observation(int(task_id))
PatientPage(self.driver).add_medium_risk_observation(int(task_id))
self.driver.refresh()
patient_trend = self.driver.find_element(
*list_page_locators.LIST_ITEM_PATIENT_TREND
)
self.assertEqual(patient_trend.get_attribute('class'),
'icon-same-arrow',
'Incorrect trend')
def test_news_error(self):
"""
Test that entering incorrect data into a NEWS ob will cause an error
"""
incorrect_score = INCORRECT_EWS_DATA
patients = self.patient_list_page.get_list_items()
PatientPage(self.driver).select_patient(patients)
PatientPage(self.driver).open_form(OPEN_OBS_MENU_NEWS_ITEM)
PatientPage(self.driver).enter_obs_data(incorrect_score)
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located(TASK_FORM_INVALID_SUBMIT)
)
response = self.driver.find_element(
*TASK_FORM_INVALID_SUBMIT).is_displayed()
self.assertEqual(response, True,
'Incorrect error handling on NEWS form')
def test_news_obs(self):
"""
Test that a NEWS observation can be submitted
"""
score = NO_RISK_EWS_DATA
patients = self.patient_list_page.get_list_items()
PatientPage(self.driver).select_patient(patients)
PatientPage(self.driver).open_form(OPEN_OBS_MENU_NEWS_ITEM)
PatientPage(self.driver).enter_obs_data(score)
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located(CONFIRM_SUBMIT))
self.driver.find_element(*CONFIRM_SUBMIT).click()
success = 'Successfully Submitted NEWS Observation'
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located((SUCCESSFUL_SUBMIT)))
response = self.driver.find_element(*SUCCESSFUL_SUBMIT)
self.assertEqual(success, response.text,
'NEWS observation unsuccessful')
def submit_observation(context, clinical_risk):
risk_dict = {
'no': NO_RISK_EWS_DATA,
'a low': LOW_RISK_SCORE_1_EWS_DATA,
'a medium': MEDIUM_RISK_SCORE_5_EWS_DATA,
'a high': HIGH_RISK_SCORE_7_EWS_DATA
}
risk_score = risk_dict.get(clinical_risk)
if not risk_score:
raise ValueError('No risk score available')
page_confirm = PageConfirm(context.browser)
patient_list_page = ListPage(context.browser)
patient_list_page.go_to_patient_list()
assert(page_confirm.is_patient_list_page())
patients = patient_list_page.get_list_items()
PatientPage(context.browser).select_patient(patients)
PatientPage(context.browser).open_form(OPEN_OBS_MENU_NEWS_ITEM)
ObservationFormPage(context.browser).enter_obs_data(risk_score)
def test_medium_risk_obs(self):
"""
Test that an 'urgently inform medical team' task
is triggered after a medium NEWS score
"""
medium_score = MEDIUM_RISK_SCORE_3_THREE_IN_ONE_EWS_DATA
patients = self.patient_list_page.get_list_items()
PatientPage(self.driver).select_patient(patients)
PatientPage(self.driver).open_form(OPEN_OBS_MENU_NEWS_ITEM)
PatientPage(self.driver).enter_obs_data(medium_score)
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located(CONFIRM_SUBMIT))
self.driver.find_element(*CONFIRM_SUBMIT).click()
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located(RELATED_TASK))
response = self.driver.find_element(*RELATED_TASK)
self.assertEqual(MEDIUM_SCORE_RESPONSE, response.text,
'Incorrect triggered action for medium risk ob')
def test_low_risk_obs(self):
"""
Test that an 'assess patient' task is triggered after a low NEWS score
"""
low_score = LOW_RISK_SCORE_1_EWS_DATA
patients = self.patient_list_page.get_list_items()
PatientPage(self.driver).select_patient(patients)
PatientPage(self.driver).open_form(OPEN_OBS_MENU_NEWS_ITEM)
PatientPage(self.driver).enter_obs_data(low_score)
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located(CONFIRM_SUBMIT)
)
self.driver.find_element(*CONFIRM_SUBMIT).click()
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located(RELATED_TASK)
)
response = self.driver.find_element(*RELATED_TASK)
self.assertEqual(LOW_SCORE_RESPONSE, response.text,
'Incorrect triggered action for low risk ob')
def setUp(self):
self.driver.get(MOB_LOGIN)
self.login_page = LoginPage(self.driver)
self.list_page = ListPage(self.driver)
self.patient_page = PatientPage(self.driver)
self.patient_page_graph = PatientPageGraphs(self.driver)
risk_mapping = {
'none': self.patient_page.add_no_risk_observation,
'low': self.patient_page.add_low_risk_observation,
'medium':
self.patient_page.add_medium_risk_observation,
'high': self.patient_page.add_high_risk_observation,
'3in1': self.patient_page.add_three_in_one_observation
}
self.login_page.login(NURSE_USERNM1, NURSE_PWD1)
self.list_page.go_to_patient_list()
patients = self.list_page.get_list_items()
patient_to_test = patients[0]
patient_id = patient_to_test.get_attribute('href').replace(
PATIENT_PAGE, ''
)
self.patient_page.remove_observations_for_patient(int(patient_id))
risk_mapping[self.risk](int(patient_id))
self.driver.get(patient_to_test.get_attribute('href'))
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located((By.CSS_SELECTOR, '#chart svg')))
self.patient_page.change_to_table()
obs_table = self.patient_page.get_obs_table()
rows = self.patient_page.get_table_rows(obs_table)[1:]
self.row_data = []
for row in rows:
self.row_data.append(self.patient_page.get_table_data(row))
self.patient_page_graph.change_to_chart()
# Focus Graphs
focus_graphs = self.patient_page_graph.get_focus_graphs()
self.assertEqual(len(focus_graphs), 5, 'Incorrect number of graphs')
self.graph_list = []
for graph in focus_graphs:
self.graph_list.append(graph)
self.graph_data = self.get_graph_data()
def setUp(self):
self.driver.get(MOB_LOGIN)
self.login_page = LoginPage(self.driver)
self.list_page = ListPage(self.driver)
self.patient_page = PatientPage(self.driver)
self.login_page.login(NURSE_USERNM1, NURSE_PWD1)
self.list_page.go_to_patient_list()
patients = self.list_page.get_list_items()
patient_to_test = patients[0]
self.patient_url = patient_to_test.get_attribute('href')
patient_id = self.patient_url.replace(
PATIENT_PAGE, ''
)
self.patient_page.remove_observations_for_patient(int(patient_id))
self.driver.get(self.patient_url)
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located(GRAPH_CHART)
)
class TestVisualisationCommon(TestCommon):
"""
Setup a session and ensure that patient data displays correctly
"""
risk = 'none'
def setUp(self):
self.driver.get(MOB_LOGIN)
self.login_page = LoginPage(self.driver)
self.list_page = ListPage(self.driver)
self.patient_page = PatientPage(self.driver)
self.patient_page_graph = PatientPageGraphs(self.driver)
risk_mapping = {
'none': self.patient_page.add_no_risk_observation,
'low': self.patient_page.add_low_risk_observation,
'medium': self.patient_page.add_medium_risk_observation,
'high': self.patient_page.add_high_risk_observation,
'3in1': self.patient_page.add_three_in_one_observation
}
self.login_page.login(NURSE_USERNM1, NURSE_PWD1)
self.list_page.go_to_patient_list()
patients = self.list_page.get_list_items()
patient_to_test = patients[0]
patient_id = patient_to_test.get_attribute('href').replace(
PATIENT_PAGE, '')
self.patient_page.remove_observations_for_patient(int(patient_id))
risk_mapping[self.risk](int(patient_id))
self.driver.get(patient_to_test.get_attribute('href'))
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located((By.CSS_SELECTOR, '#chart svg')))
self.patient_page.change_to_table()
obs_table = self.patient_page.get_obs_table()
rows = self.patient_page.get_table_rows(obs_table)[1:]
self.row_data = []
for row in rows:
self.row_data.append(self.patient_page.get_table_data(row))
self.patient_page_graph.change_to_chart()
# Focus Graphs
focus_graphs = self.patient_page_graph.get_focus_graphs()
self.assertEqual(len(focus_graphs), 5, 'Incorrect number of graphs')
self.graph_list = []
for graph in focus_graphs:
self.graph_list.append(graph)
self.graph_data = self.get_graph_data()
def get_graph_data(self):
"""
Helper function to get an dict of the focus chart data
:return: dict of strings from focus chart data
"""
rr_mes = \
self.patient_page_graph.get_graph_measurement(self.graph_list[0])
os_mes = \
self.patient_page_graph.get_graph_measurement(self.graph_list[1])
bt_mes = \
self.patient_page_graph.get_graph_measurement(self.graph_list[2])
hr_mes = \
self.patient_page_graph.get_graph_measurement(self.graph_list[3])
bp_mes = \
self.patient_page_graph.get_graph_measurements(self.graph_list[4])
return {
'resp_rate': rr_mes,
'oxy_sat': os_mes,
'body_temp': bt_mes,
'pulse_rate': hr_mes,
'blood_press': bp_mes
}
def get_focus_chart_labels(self):
"""
Helper function to get an dict of the focus chart labels
:return: dict of strings from focus chart labels
"""
rr_label = self.patient_page_graph.get_graph_label(self.graph_list[0])
os_label = self.patient_page_graph.get_graph_label(self.graph_list[1])
bt_label = self.patient_page_graph.get_graph_label(self.graph_list[2])
hr_label = self.patient_page_graph.get_graph_label(self.graph_list[3])
bp_label = self.patient_page_graph.get_graph_label(self.graph_list[4])
return {
'resp_rate': rr_label,
'oxy_sat': os_label,
'body_temp': bt_label,
'pulse_rate': hr_label,
'blood_press': bp_label
}
def get_tabular_values_value(self, row, column):
"""
Helper function to get the value from a row and column in the tabular
values table
:param row: Row to get value from
:param column: Column to get value from
:return: String from row/column combo
"""
tabular_values_table = self.patient_page.get_tabular_values()
tabular_values_rows = \
self.patient_page.get_table_rows(tabular_values_table)
tabular_values = \
self.patient_page.get_table_data(tabular_values_rows[row])
self.assertEqual(len(tabular_values), 4, 'Incorrect number of data')
return tabular_values[column]
def test_take_task_news_obs(self):
"""
Submit adhoc observation which creates News observation task
and Take task NEWS Observation from task list, submit news score
"""
# Enter high risk observation to create News Observation task in task
# list
self.patient_list_page.go_to_patient_list()
high_score = HIGH_RISK_SCORE_9_EWS_DATA
no_risk = NO_RISK_EWS_DATA
news_task = []
success = 'Successfully Submitted NEWS Observation'
patients = self.patient_list_page.get_list_items()
PatientPage(self.driver).select_patient(patients)
PatientPage(self.driver).open_form(OPEN_OBS_MENU_NEWS_ITEM)
PatientPage(self.driver).enter_obs_data(high_score)
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located(CONFIRM_SUBMIT)
)
self.driver.find_element(*CONFIRM_SUBMIT).click()
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located((
SUCCESSFUL_SUBMIT))
)
response = self.driver.find_element(*SUCCESSFUL_SUBMIT)
self.assertEqual(success, response.text,
'NEWS observation unsuccessful')
self.driver.find_element(*GO_TO_MY_TASK).click()
# Click on the first news score task from Task list
self.task_list_page.go_to_task_list()
self.driver.refresh()
for task in self.task_list_page.get_list_task():
# print(task.text)
if task.text == 'NEWS Observation':
news_task.append(task)
news_task[0].click()
# enter low risk observation
PatientPage(self.driver).enter_obs_data(no_risk)
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located(CONFIRM_SUBMIT)
)
self.driver.find_element(*CONFIRM_SUBMIT).click()
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located((
SUCCESSFUL_SUBMIT))
)
response = self.driver.find_element(*SUCCESSFUL_SUBMIT)
self.assertEqual(success, response.text,
'NEWS observation unsuccessful')
class TestPatientPageAdhocObs(TestCommon):
"""
Test to ensure that the adhoc observation work correctly
"""
def setUp(self):
self.driver.get(MOB_LOGIN)
self.login_page = LoginPage(self.driver)
self.list_page = ListPage(self.driver)
self.patient_page = PatientPage(self.driver)
self.login_page.login(NURSE_USERNM1, NURSE_PWD1)
self.list_page.go_to_patient_list()
patients = self.list_page.get_list_items()
patient_to_test = patients[0]
self.patient_url = patient_to_test.get_attribute('href')
self.driver.get(self.patient_url)
def test_can_logout(self):
"""
Test that the title of the login page is Open-eObs
"""
self.patient_page.logout()
self.assertTrue(
PageConfirm(self.driver).is_login_page(),
'Did not get to the logout page correctly')
def test_can_go_to_task_list_page(self):
"""
Test that can go to task list page
"""
self.patient_page.go_to_task_list()
self.assertTrue(
PageConfirm(self.driver).is_task_list_page(),
'Did not get to the task list page correctly')
def test_go_to_patient_list_page(self):
"""
Test that can go to the patient list page
"""
self.patient_page.go_to_patient_list()
self.assertTrue(
PageConfirm(self.driver).is_patient_list_page(),
'Did not get to patient list page correctly')
def test_can_go_to_stand_in_page(self):
"""
Test that can navigate to the stand in page
"""
self.patient_page.go_to_standin()
self.assertTrue(
PageConfirm(self.driver).is_stand_in_page(),
'Did not get to stand in page correctly')
def test_can_carry_out_barcode_scan(self):
"""
Test that can do a barcode scan
"""
task_id = self.patient_url.replace(PATIENT_PAGE, '')
id_to_use = self.patient_page.patient_scan_helper(int(task_id))
self.patient_page.do_barcode_scan(id_to_use['other_identifier'])
def test_can_open_adhoc_menu(self):
"""
Test that can see and open a menu to select an adhoc observation to
carry out for the patient
"""
menu = self.patient_page.open_adhoc_obs_menu()
menu_title = menu.find_element(*OPEN_OBS_MENU_TITLE)
observations = menu.find_elements(*OPEN_OBS_MENU_LIST_ITEMS)
self.assertGreater(len(observations), 0,
'Incorrect number of adhoc obs')
task_id = self.patient_url.replace(PATIENT_PAGE, '')
data = self.patient_page.patient_helper(int(task_id))[0]
patient_name = data['full_name']
self.assertEqual(menu_title.text,
'Pick an observation for {0}'.format(patient_name),
'Incorrect menu title')
def test_adhoc_news_ob_deadline(self):
"""
Test that the NEWS observation in the adhoc observation list shows
the deadline to the next scheduled NEWS observation
"""
menu = self.patient_page.open_adhoc_obs_menu()
news_item = menu.find_element(*OPEN_OBS_MENU_NEWS_ITEM)
deadline = news_item.find_element(*OPEN_OBS_MENU_NEWS_DEADLINE)
task_id = self.patient_url.replace(PATIENT_PAGE, '')
data = self.patient_page.patient_helper(int(task_id))[0]
ews_deadline = data['next_ews_time']
self.assertEqual(deadline.text, ews_deadline,
'Incorrect NEWS deadline')
class TestPatientPageAdhocObs(TestCommon):
"""
Test to ensure that the adhoc observation work correctly
"""
def setUp(self):
self.driver.get(MOB_LOGIN)
self.login_page = LoginPage(self.driver)
self.list_page = ListPage(self.driver)
self.patient_page = PatientPage(self.driver)
self.login_page.login(NURSE_USERNM1, NURSE_PWD1)
self.list_page.go_to_patient_list()
patients = self.list_page.get_list_items()
patient_to_test = patients[0]
self.patient_url = patient_to_test.get_attribute('href')
self.driver.get(self.patient_url)
def test_can_logout(self):
"""
Test that the title of the login page is Open-eObs
"""
self.patient_page.logout()
self.assertTrue(PageConfirm(self.driver).is_login_page(),
'Did not get to the logout page correctly')
def test_can_go_to_task_list_page(self):
"""
Test that can go to task list page
"""
self.patient_page.go_to_task_list()
self.assertTrue(PageConfirm(self.driver).is_task_list_page(),
'Did not get to the task list page correctly')
def test_go_to_patient_list_page(self):
"""
Test that can go to the patient list page
"""
self.patient_page.go_to_patient_list()
self.assertTrue(PageConfirm(self.driver).is_patient_list_page(),
'Did not get to patient list page correctly')
def test_can_go_to_stand_in_page(self):
"""
Test that can navigate to the stand in page
"""
self.patient_page.go_to_standin()
self.assertTrue(PageConfirm(self.driver).is_stand_in_page(),
'Did not get to stand in page correctly')
def test_can_carry_out_barcode_scan(self):
"""
Test that can do a barcode scan
"""
task_id = self.patient_url.replace(
PATIENT_PAGE, ''
)
id_to_use = self.patient_page.patient_scan_helper(int(task_id))
self.patient_page.do_barcode_scan(id_to_use['other_identifier'])
def test_can_open_adhoc_menu(self):
"""
Test that can see and open a menu to select an adhoc observation to
carry out for the patient
"""
menu = self.patient_page.open_adhoc_obs_menu()
menu_title = menu.find_element(
*OPEN_OBS_MENU_TITLE
)
observations = menu.find_elements(
*OPEN_OBS_MENU_LIST_ITEMS
)
self.assertGreater(len(observations), 0,
'Incorrect number of adhoc obs')
task_id = self.patient_url.replace(
PATIENT_PAGE, ''
)
data = self.patient_page.patient_helper(int(task_id))[0]
patient_name = data['full_name']
self.assertEqual(menu_title.text,
'Pick an observation for {0}'.format(patient_name),
'Incorrect menu title')
def test_adhoc_news_ob_deadline(self):
"""
Test that the NEWS observation in the adhoc observation list shows
the deadline to the next scheduled NEWS observation
"""
menu = self.patient_page.open_adhoc_obs_menu()
news_item = menu.find_element(
*OPEN_OBS_MENU_NEWS_ITEM
)
deadline = news_item.find_element(
*OPEN_OBS_MENU_NEWS_DEADLINE
)
task_id = self.patient_url.replace(
PATIENT_PAGE, ''
)
data = self.patient_page.patient_helper(int(task_id))[0]
ews_deadline = data['next_ews_time']
self.assertEqual(deadline.text, ews_deadline,
'Incorrect NEWS deadline')
class TestVisualisationCommon(TestCommon):
"""
Setup a session and ensure that patient data displays correctly
"""
risk = 'none'
def setUp(self):
self.driver.get(MOB_LOGIN)
self.login_page = LoginPage(self.driver)
self.list_page = ListPage(self.driver)
self.patient_page = PatientPage(self.driver)
self.patient_page_graph = PatientPageGraphs(self.driver)
risk_mapping = {
'none': self.patient_page.add_no_risk_observation,
'low': self.patient_page.add_low_risk_observation,
'medium':
self.patient_page.add_medium_risk_observation,
'high': self.patient_page.add_high_risk_observation,
'3in1': self.patient_page.add_three_in_one_observation
}
self.login_page.login(NURSE_USERNM1, NURSE_PWD1)
self.list_page.go_to_patient_list()
patients = self.list_page.get_list_items()
patient_to_test = patients[0]
patient_id = patient_to_test.get_attribute('href').replace(
PATIENT_PAGE, ''
)
self.patient_page.remove_observations_for_patient(int(patient_id))
risk_mapping[self.risk](int(patient_id))
self.driver.get(patient_to_test.get_attribute('href'))
ui.WebDriverWait(self.driver, 5).until(
ec.visibility_of_element_located((By.CSS_SELECTOR, '#chart svg')))
self.patient_page.change_to_table()
obs_table = self.patient_page.get_obs_table()
rows = self.patient_page.get_table_rows(obs_table)[1:]
self.row_data = []
for row in rows:
self.row_data.append(self.patient_page.get_table_data(row))
self.patient_page_graph.change_to_chart()
# Focus Graphs
focus_graphs = self.patient_page_graph.get_focus_graphs()
self.assertEqual(len(focus_graphs), 5, 'Incorrect number of graphs')
self.graph_list = []
for graph in focus_graphs:
self.graph_list.append(graph)
self.graph_data = self.get_graph_data()
def get_graph_data(self):
"""
Helper function to get an dict of the focus chart data
:return: dict of strings from focus chart data
"""
rr_mes = \
self.patient_page_graph.get_graph_measurement(self.graph_list[0])
os_mes = \
self.patient_page_graph.get_graph_measurement(self.graph_list[1])
bt_mes = \
self.patient_page_graph.get_graph_measurement(self.graph_list[2])
hr_mes = \
self.patient_page_graph.get_graph_measurement(self.graph_list[3])
bp_mes = \
self.patient_page_graph.get_graph_measurements(self.graph_list[4])
return {
'resp_rate': rr_mes,
'oxy_sat': os_mes,
'body_temp': bt_mes,
'pulse_rate': hr_mes,
'blood_press': bp_mes
}
def get_focus_chart_labels(self):
"""
Helper function to get an dict of the focus chart labels
:return: dict of strings from focus chart labels
"""
rr_label = self.patient_page_graph.get_graph_label(self.graph_list[0])
os_label = self.patient_page_graph.get_graph_label(self.graph_list[1])
bt_label = self.patient_page_graph.get_graph_label(self.graph_list[2])
hr_label = self.patient_page_graph.get_graph_label(self.graph_list[3])
bp_label = self.patient_page_graph.get_graph_label(self.graph_list[4])
return {
'resp_rate': rr_label,
'oxy_sat': os_label,
'body_temp': bt_label,
'pulse_rate': hr_label,
'blood_press': bp_label
}
def get_tabular_values_value(self, row, column):
"""
Helper function to get the value from a row and column in the tabular
values table
:param row: Row to get value from
:param column: Column to get value from
:return: String from row/column combo
"""
tabular_values_table = self.patient_page.get_tabular_values()
tabular_values_rows = \
self.patient_page.get_table_rows(tabular_values_table)
tabular_values = \
self.patient_page.get_table_data(tabular_values_rows[row])
self.assertEqual(len(tabular_values), 4, 'Incorrect number of data')
return tabular_values[column]
