Index: shared/scripts/names.py =================================================================== diff -u -rc178841263d7366f577776e63b59bd562e5d4d72 -r48849c79a27af51cb7c8c580b26694b3a880c603 --- shared/scripts/names.py (.../names.py) (revision c178841263d7366f577776e63b59bd562e5d4d72) +++ shared/scripts/names.py (.../names.py) (revision 48849c79a27af51cb7c8c580b26694b3a880c603) @@ -2,6 +2,7 @@ from objectmaphelper import * + o_Gui_MainView = {"type": "Gui::MainView", "unnamed": 1, "visible": True} o_Overlay = {"container": o_Gui_MainView, "type": "Overlay", "unnamed": 1, "visible": True} o_borderRect_Rectangle = {"container": o_Overlay, "gradient": 0, "id": "_borderRect", "type": "Rectangle", "unnamed": 1, "visible": True} @@ -30,9 +31,32 @@ o_PreTreatmentBase_confirmButton_TouchRect = {"container": o_PreTreatmentCreateStack_PreTreatmentBase_TreatmentFlowBase, "gradient": 0, "objectName": "_confirmButton", "type": "TouchRect", "visible": True} +#standbymode patient_id = {"container": o_PreTreatmentCreateStack_PreTreatmentBase_TreatmentFlowBase, "echoMode": 0, "id": "_input", "type": "TextInput", "unnamed": 1, "visible": True} o_MainHome_MainHome = {"container": o_Gui_MainView, "objectName": "_MainHome", "type": "MainHome", "visible": True} standby_page = {"container": o_MainHome_MainHome, "type": "Column", "unnamed": 1, "visible": True} displayed_time = {"container": o_Gui_MainView, "text": "01/06/2022 02:22:07", "type": "Text", "unnamed": 1, "visible": True} create_treatment_rectangle = {"container": o_MainHome_MainHome, "gradient": 0, "id": "_createTreatmentRect", "type": "TouchRect", "unnamed": 1, "visible": True} +treatmentStack_TreatmentStack = {"container": o_Gui_MainView, "objectName": "TreatmentStack", "type": "TreatmentStack", "visible": True} +treatmentStack_TreatmentBloodPrime_ScreenItem = {"container": treatmentStack_TreatmentStack, "objectName": "_TreatmentBloodPrime", "type": "ScreenItem", "visible": True} + +#in-treatment +blood_priming = {"container": treatmentStack_TreatmentBloodPrime_ScreenItem, "text": "Blood Priming", "type": "Text", "unnamed": 1, "visible": True} +blood_priming_value_by_default = {"container": treatmentStack_TreatmentBloodPrime_ScreenItem, "text": "0 mL", "type": "Text", "unnamed": 1, "visible": True} +treatmentStack_treatmentHome_TreatmentHome = {"container": treatmentStack_TreatmentStack, "id": "_treatmentHome", "type": "TreatmentHome", "unnamed": 1, "visible": True} +uf_minimum_value = {"container": treatmentStack_treatmentHome_TreatmentHome, "text": "0.000", "type": "Text", "unnamed": 1, "visible": True} +uf_maximum_value = {"container": treatmentStack_treatmentHome_TreatmentHome, "text": "0.600", "type": "Text", "unnamed": 1, "visible": True} +uf_minimum_value_pop_up = {"container": o_Overlay, "text": "0.000", "type": "Text", "unnamed": 1, "visible": True} +uf_maximum_value_pop_up = {"container": o_Overlay, "text": "0.600", "type": "Text", "unnamed": 1, "visible": True} +edit_uf_value = {"container": o_Overlay, "text": "EDIT ULTRAFILTRATION VOLUME", "type": "Text", "unnamed": 1, "visible": True} +uf_maximum_title = {"container": o_Overlay, "text": "0.600", "type": "Text", "unnamed": 1, "visible": True} +uf_back_button = {"container": o_Overlay, "text": "BACK", "type": "Text", "unnamed": 1, "visible": True} +uf_close_button = {"container": o_Overlay, "id": "_image", "source": "qrc:/images/iClose", "type": "Image", "unnamed": 1, "visible": True} +fluid_text = {"container": treatmentStack_treatmentHome_TreatmentHome, "text": "Volume Delivered", "type": "Text", "unnamed": 1, "visible": True} +cumulative_fluid_text = {"container": treatmentStack_treatmentHome_TreatmentHome, "text": "Cumulative Delivered", "type": "Text", "unnamed": 1, "visible": True} + + + + + Index: tst_In_treatment/test.py =================================================================== diff -u --- tst_In_treatment/test.py (revision 0) +++ tst_In_treatment/test.py (revision 48849c79a27af51cb7c8c580b26694b3a880c603) @@ -0,0 +1,191 @@ +# -*- coding: utf-8 -*- + +## +# Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved. +# copyright +# THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, +# IN PART OR IN WHOLE, +# WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +# +# file tst_In_treatment +# date 2020/01/11 +# author Joseph Varghese +# +# NOTE: +# This test contradicts verification of saline bolus data and ultrafilteration(uf) of In-treatment +# section + +import names +import squish +import re +from time import sleep +from dialin.ui import utils +from dialin.ui import unittests + +from dialin.ui.hd_simulator import HDSimulator +from builtins import str as pyStr +from builtins import int as pyInt + + +BLOOD_PRIMING_TEXT = "Blood Priming" +SALINE_UNIT = "mL" +BLOOD_PRIMING_DEFAULT_VALUE = "0 mL" +UF_MINIMUM_VALUE = 0.000 +UF_MAXIMUM_VALUE = 0.600 +UF_DEFAULT_VALUE = 0.000 +SALINE_BOLUS_TARGET = [0, 25, 30, 50, 100, 70, 220, 300] +SALINE_BOLUS_CUMULATIVE = [0, 150, 180, 25, 35, 88, 180, 280] +SALINE_BOLUS_DELIVERED = [0, 220, 852, 98, 758, 862, 752, 564] + + +def verification_of_blood_prime_from_dialysis_state(): + """ + Tests for verification of blood prime UI section. + + @return: N/A + """ + blood_priming_page = waitForObject(names.blood_priming) + blood_priming_text = blood_priming_page.text + test.compare(blood_priming_text, BLOOD_PRIMING_TEXT) + blood_priming_value = waitForObject(names.blood_priming_value_by_default) + blood_priming_text = blood_priming_value.text + test.compare(blood_priming_text, BLOOD_PRIMING_DEFAULT_VALUE) + + +def verification_of_uf_from_dialysis_state(): + """ + Tests to verify components of ultrafilteration from dialysis section. + + @return: N/A + """ + uf_minimum = waitForObject(names.uf_minimum_value) + uf_minimum_value = uf_minimum.text + test.compare(format(UF_MINIMUM_VALUE, ".3f"), uf_minimum_value) + uf_maximum = waitForObject(names.uf_maximum_value) + uf_maximum_value = uf_maximum.text + test.compare(format(UF_MAXIMUM_VALUE,".3f"), uf_maximum_value) + + +def verification_of_target_value(expected_target_value): + """ + Tests to verify target values from saline bolus section. + + @input: expected target value. + """ + saline_value = waitForObject(names.fluid_text) + saline_target = object.children(saline_value)[0] + target_value = saline_target.text + target_value_displayed = re.findall(r'\d+', pyStr(target_value)) + test.compare(pyStr(expected_target_value), pyStr(target_value_displayed[0])) + + +def verification_of_cumulative_value(expected_cumulative_value): + """ + Tests to verify cumulative values from saline bolus section. + + @input: expected cumulative value. + """ + saline_text = waitForObject(names.cumulative_fluid_text) + saline_unit = object.children(saline_text)[0] + if saline_unit.text == SALINE_UNIT: + saline_cumulative = object.children(saline_text)[1] + test.compare(pyStr(expected_cumulative_value), pyStr(saline_cumulative.text)) + else: + test.fail("Deviation observed in unit of saline (fluid)") + + +def verification_of_delivered_value(expected_delivered_value): + """ + Tests to verify delivered values from saline bolus section. + + @input: expected delivered value. + """ + saline_text = waitForObject(names.fluid_text) + saline_unit = object.children(saline_text)[1] + if saline_unit.text == SALINE_UNIT: + saline_cumulative = object.children(saline_text)[2] + test.compare(pyStr(expected_delivered_value), pyStr(saline_cumulative.text)) + else: + test.fail("Deviation observed in unit of saline (fluid)") + + +def verification_of_uf_pop_up(): + """ + Tests to verify ultrafilter pop-up UI section. + + @return: N/A + """ + #user clicks on ultra filteration section + uf_maximum = waitForObject(names.uf_maximum_value) + mouseClick(uf_maximum) + utils.waitForGUI(0.5) + uf_minimum = waitForObject(names.uf_minimum_value_pop_up) + uf_minimum_value = uf_minimum.text + test.compare(format(UF_MINIMUM_VALUE, ".3f"), uf_minimum_value) + test.log(f"Uf minimum value should be {format(UF_MINIMUM_VALUE,'.3f')}") + + uf_maximum = waitForObject(names.uf_maximum_value_pop_up) + uf_maximum_value = uf_maximum.text + test.compare(format(UF_MAXIMUM_VALUE,".3f"), uf_maximum_value) + test.log(f"Uf maximum value should be {format(UF_MAXIMUM_VALUE,'.3f')}") + + tapObject(waitForObject(names.edit_uf_value)) + uf_maximum_displayed = waitForObject(names.uf_maximum_value) + test.compare(format(UF_MAXIMUM_VALUE,".3f"), uf_maximum_displayed.text) + test.log(f"Uf maximum value displayed on uf_edit section should be " +\ + f"{format(UF_MAXIMUM_VALUE,'.3f')} by default") + + utils.waitForGUI(1) + tapObject(waitForObject(names.uf_back_button)) + tapObject(waitForObject(names.uf_close_button)) + + +def main(): + utils.tstStart("Verification of In-Treatment section of application") + startApplication("denaliSquish") + + hd = HDSimulator() + + unittests.test_python_version() + hd.cmd_send_power_on_self_test_version_request() + + #navigate to blood prime state + utils.waitForGUI(2) + hd.cmd_send_hd_operation_mode(6, 0) + verification_of_blood_prime_from_dialysis_state() + utils.waitForGUI(2) + + #navigate to dialysis state + hd.cmd_set_treatment_states_data(sub_mode= 2, uf_state= 0, saline_state=0, heparin_state= 0, + rinseback_state= 0, recirculate_state= 0, blood_prime_state= 0, + treatment_end_state=0, treatment_stop_state= 0) + + verification_of_uf_from_dialysis_state() + verification_of_uf_pop_up() + hd.cmd_send_uf_treatment_response(accepted = 1, reason = 0, volume = 0.300) + utils.waitForGUI(2) + + for index in range(8): + target_value = SALINE_BOLUS_TARGET[index] + cumulative_value = SALINE_BOLUS_CUMULATIVE[index] + delivered_value = SALINE_BOLUS_DELIVERED[index] + hd.cmd_set_treatment_saline_bolus_data(target = target_value, + cumulative = cumulative_value, + delivered = delivered_value) + test.log(f"Verification of saline values from dialysis state for target value : {target_value}"+\ + f" cumulative value : {cumulative_value} and delivered value : {delivered_value}") + verification_of_target_value(expected_target_value = target_value) + utils.waitForGUI(0.5) + verification_of_delivered_value(expected_delivered_value = delivered_value) + utils.waitForGUI(0.5) + verification_of_cumulative_value(expected_cumulative_value = cumulative_value) + utils.waitForGUI(0.5) + + #hd.cmd_set_saline_bolus_response(accepted= 1, reason=0, target=150, state= 1) + + + utils.tstDone() + + + + Index: tst_In_treatment/verificationPoints/VP1 =================================================================== diff -u --- tst_In_treatment/verificationPoints/VP1 (revision 0) +++ tst_In_treatment/verificationPoints/VP1 (revision 48849c79a27af51cb7c8c580b26694b3a880c603) @@ -0,0 +1,8 @@ + + + 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 + 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 + +