From 5e2afa2e9c20a5c9887707753d02ed68dbc3f56e Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Fri, 19 Mar 2021 14:26:24 +0000 Subject: [PATCH 01/28] hlx503: test setting of RECONDENSE pv --- tests/hlx503.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/hlx503.py b/tests/hlx503.py index ee3cdfe28..dac4ab0f8 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -187,3 +187,6 @@ def test_WHEN_temp_set_AND_lookup_table_off_THEN_pids_not_set(self, _, temp, p, self.ca.assert_that_pv_is("P", 0) self.ca.assert_that_pv_is("I", 0) self.ca.assert_that_pv_is("D", 0) + + def test_WHEN_condense_set_THEN_condensing_is_true(self): + self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") From 57f9c60849a06d026642a5ffae5277fd0bdef3dc Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Fri, 19 Mar 2021 14:52:28 +0000 Subject: [PATCH 02/28] hlx503: Test setting of status for recondensing, recondense part and recondense timing out --- tests/hlx503.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index dac4ab0f8..7184f9cb2 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -188,5 +188,14 @@ def test_WHEN_temp_set_AND_lookup_table_off_THEN_pids_not_set(self, _, temp, p, self.ca.assert_that_pv_is("I", 0) self.ca.assert_that_pv_is("D", 0) - def test_WHEN_condense_set_THEN_condensing_is_true(self): - self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") + @parameterized.expand(parameterized_list(["YES", "NO"])) + def test_WHEN_condense_set_THEN_condensing_is_true(self, _, status): + self.ca.assert_setting_setpoint_sets_readback(status, "RECONDENSING") + + @parameterized.expand(parameterized_list(["SETUP", "PART 1", "PART 2", "PART 3", "FINISHING", "NOT RECONDENSING"])) + def test_WHEN_set_part_THEN_part_set(self, _, part): + self.ca.assert_setting_setpoint_sets_readback(part, "RECONDENSE:PART") + + @parameterized.expand(parameterized_list(["YES", "NO"])) + def test_WHEN_set_timed_THEN_timed_out_set(self, _, timed_out): + self.ca.assert_setting_setpoint_sets_readback(timed_out, "RECONDENSE:TIMED_OUT") From 2224ddad19ca301e4a9d50bbdc23c50490c954fb Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Fri, 19 Mar 2021 16:05:04 +0000 Subject: [PATCH 03/28] Test setting skipped and post-recondense setpoints --- tests/hlx503.py | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index 7184f9cb2..c1a67cdbb 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -197,5 +197,30 @@ def test_WHEN_set_part_THEN_part_set(self, _, part): self.ca.assert_setting_setpoint_sets_readback(part, "RECONDENSE:PART") @parameterized.expand(parameterized_list(["YES", "NO"])) - def test_WHEN_set_timed_THEN_timed_out_set(self, _, timed_out): + def test_WHEN_set_timed_out_THEN_timed_out_set(self, _, timed_out): self.ca.assert_setting_setpoint_sets_readback(timed_out, "RECONDENSE:TIMED_OUT") + + @parameterized.expand(parameterized_list(["YES", "NO"])) + def test_WHEN_set_skipped_THEN_skipped_set(self, _, skipped): + self.ca.assert_setting_setpoint_sets_readback(skipped, "RECONDENSE:SKIPPED") + + @parameterized.expand(parameterized_list([0.5, 1.2])) + def test_WHEN_set_post_recondense_temp_AND_setpoint_is_less_than_max_he3_cooling_temp_THEN_post_recondense_set( + self, _, temp): + self.ca.assert_setting_setpoint_sets_readback(temp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP") + + @parameterized.expand(parameterized_list([2.8, 12.2])) + def test_WHEN_set_post_recondense_temp_AND_setpoint_is_greater_than_max_he3_cooling_temp_THEN_post_recondense_not_set( + self, _, temp): + self.ca.assert_setting_setpoint_sets_readback( + temp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP", expected_value=0.3 + ) + self.ca.assert_that_pv_alarm_is("RECONDENSE:TEMP:SP", self.ca.Alarms.MINOR) + + @parameterized.expand(parameterized_list([20.8, 100.2])) + def test_WHEN_set_post_recondense_temp_AND_setpoint_is_greater_than_max_heliox_op_temp_THEN_post_recondense_not_set( + self, _, temp): + self.ca.assert_setting_setpoint_sets_readback( + temp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP", expected_value=0.3 + ) + self.ca.assert_that_pv_alarm_is("RECONDENSE:TEMP:SP", self.ca.Alarms.MAJOR) From 631d65a46f7d0295a735a981c0f6b663038f282b Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Fri, 19 Mar 2021 16:38:05 +0000 Subject: [PATCH 04/28] hlx503: Test forward of post-condense temp setpoint to device --- tests/hlx503.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/tests/hlx503.py b/tests/hlx503.py index c1a67cdbb..5a0add14d 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -224,3 +224,12 @@ def test_WHEN_set_post_recondense_temp_AND_setpoint_is_greater_than_max_heliox_o temp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP", expected_value=0.3 ) self.ca.assert_that_pv_alarm_is("RECONDENSE:TEMP:SP", self.ca.Alarms.MAJOR) + + @parameterized.expand(parameterized_list([0.5, 1.2])) + @skip_if_recsim("Comes back via record redirection which recsim can't handle easily") + def test_WHEN_forward_post_condense_temp_setpoint_THEN_temp_set(self, _, temp): + self.ca.assert_setting_setpoint_sets_readback(temp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP") + self.ca.process_pv("RECONDENSE:TEMP:_FORWARD") + self.ca.assert_that_pv_is("CTRLCHANNEL", "1KPOTHE3POTLO") + self.ca.assert_that_pv_is("TEMP:HE3POT:SP", temp) + self.ca.assert_that_pv_is("TEMP:HE3POT", temp) From ebff2b70cab0a22264b40ce511a3053bf9c9d969 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Mon, 22 Mar 2021 14:29:40 +0000 Subject: [PATCH 05/28] hlx503: Test snl setting recondensse status --- tests/hlx503.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index 5a0add14d..3ac1242a7 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -188,9 +188,9 @@ def test_WHEN_temp_set_AND_lookup_table_off_THEN_pids_not_set(self, _, temp, p, self.ca.assert_that_pv_is("I", 0) self.ca.assert_that_pv_is("D", 0) - @parameterized.expand(parameterized_list(["YES", "NO"])) - def test_WHEN_condense_set_THEN_condensing_is_true(self, _, status): - self.ca.assert_setting_setpoint_sets_readback(status, "RECONDENSING") + def test_WHEN_condense_started_THEN_condensing_is_started(self): + self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") + self.ca.assert_that_pv_is("RECONDENSE:PART", "SETUP") @parameterized.expand(parameterized_list(["SETUP", "PART 1", "PART 2", "PART 3", "FINISHING", "NOT RECONDENSING"])) def test_WHEN_set_part_THEN_part_set(self, _, part): From a2fdea418482e262f1fee007d5095f06ff4798be Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Mon, 22 Mar 2021 15:01:43 +0000 Subject: [PATCH 06/28] Test skipping steps --- tests/hlx503.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index 3ac1242a7..1dfcc7e95 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -188,9 +188,17 @@ def test_WHEN_temp_set_AND_lookup_table_off_THEN_pids_not_set(self, _, temp, p, self.ca.assert_that_pv_is("I", 0) self.ca.assert_that_pv_is("D", 0) - def test_WHEN_condense_started_THEN_condensing_is_started(self): + def test_WHEN_condense_started_THEN_condensing_is_started_WHEN_steps_skipped_THEN_skipped(self): self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") self.ca.assert_that_pv_is("RECONDENSE:PART", "SETUP") + self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") + self.ca.assert_that_pv_is("RECONDENSE:PART", "PART 1") + self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") + self.ca.assert_that_pv_is("RECONDENSE:PART", "PART 2") + self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") + self.ca.assert_that_pv_is("RECONDENSE:PART", "PART 3") + self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") + self.ca.assert_that_pv_is("RECONDENSE:PART", "FINISHING") @parameterized.expand(parameterized_list(["SETUP", "PART 1", "PART 2", "PART 3", "FINISHING", "NOT RECONDENSING"])) def test_WHEN_set_part_THEN_part_set(self, _, part): From 42c4ec655f4c731a068bbc24703c87845db5edb4 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Tue, 23 Mar 2021 09:08:55 +0000 Subject: [PATCH 07/28] hlx503: Remove setup part, test setpoint is set post condense --- tests/hlx503.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index 1dfcc7e95..e46ddd14a 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -188,17 +188,23 @@ def test_WHEN_temp_set_AND_lookup_table_off_THEN_pids_not_set(self, _, temp, p, self.ca.assert_that_pv_is("I", 0) self.ca.assert_that_pv_is("D", 0) - def test_WHEN_condense_started_THEN_condensing_is_started_WHEN_steps_skipped_THEN_skipped(self): + def test_WHEN_recondense_started_THEN_condensing_is_started_WHEN_steps_skipped_THEN_skipped_AND_temp_sp_set(self): + # Set temp values + self.ca.set_pv_value("TEMP:HE3POT:SP", 0.1) + post_recondense_temp_sp = 0.3 + self.ca.assert_setting_setpoint_sets_readback( + post_recondense_temp_sp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP" + ) + # Start recondensing and skip steps self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") - self.ca.assert_that_pv_is("RECONDENSE:PART", "SETUP") - self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") self.ca.assert_that_pv_is("RECONDENSE:PART", "PART 1") self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") self.ca.assert_that_pv_is("RECONDENSE:PART", "PART 2") self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") self.ca.assert_that_pv_is("RECONDENSE:PART", "PART 3") self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") - self.ca.assert_that_pv_is("RECONDENSE:PART", "FINISHING") + # Assert that temperature setpoint is set + self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", post_recondense_temp_sp, tolerance=0.001) @parameterized.expand(parameterized_list(["SETUP", "PART 1", "PART 2", "PART 3", "FINISHING", "NOT RECONDENSING"])) def test_WHEN_set_part_THEN_part_set(self, _, part): From 93fbfc2240573a0ef4100e71cc4ad8d19e7fdb76 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Tue, 23 Mar 2021 09:36:20 +0000 Subject: [PATCH 08/28] hlx503: Test cancelling of recondense --- tests/hlx503.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/tests/hlx503.py b/tests/hlx503.py index e46ddd14a..bebdadcae 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -206,6 +206,25 @@ def test_WHEN_recondense_started_THEN_condensing_is_started_WHEN_steps_skipped_T # Assert that temperature setpoint is set self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", post_recondense_temp_sp, tolerance=0.001) + @parameterized.expand(parameterized_list([1, 2])) + def test_WHEN_cancelled_in_any_step_THEN_temp_not_set_AND_cancelled(self, _, parts_skipped): + # Set temp values + original_temp_sp = 0.1 + self.ca.set_pv_value("TEMP:HE3POT:SP", original_temp_sp) + post_recondense_temp_sp = 0.3 + self.ca.assert_setting_setpoint_sets_readback( + post_recondense_temp_sp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP" + ) + # Start recondensing and skip steps + self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") + for i in range(parts_skipped): + self.ca.assert_that_pv_is("RECONDENSE:PART", f"PART {i+1}") + self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") + self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSE:CANCELLED") + self.ca.assert_that_pv_is("RECONDENSE:PART", "NOT RECONDENSING") + # Assert that temperature setpoint is set + self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", original_temp_sp, tolerance=0.001) + @parameterized.expand(parameterized_list(["SETUP", "PART 1", "PART 2", "PART 3", "FINISHING", "NOT RECONDENSING"])) def test_WHEN_set_part_THEN_part_set(self, _, part): self.ca.assert_setting_setpoint_sets_readback(part, "RECONDENSE:PART") From ddf8571923b62a8e934374a9ec5f257ccfae75a3 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Tue, 23 Mar 2021 10:04:49 +0000 Subject: [PATCH 09/28] hlx503: Test values set in part 1 --- tests/hlx503.py | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index bebdadcae..99c3e4306 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -58,6 +58,9 @@ def setUp(self): if not IOCRegister.uses_rec_sim: self._lewis.backdoor_run_function_on_device("backdoor_plug_in_he3potlow") + self.ca.set_pv_value("RECONDENSE:CANCELLED:SP", "YES") + self.ca.assert_that_pv_is("RECONDENSING", "NO") + @parameterized.expand(parameterized_list(["Auto", "Manual"])) def test_WHEN_set_autoheat_THEN_autoheat_set(self, _, value): self.ca.assert_setting_setpoint_sets_readback(value, "MODE:HTR") @@ -206,7 +209,7 @@ def test_WHEN_recondense_started_THEN_condensing_is_started_WHEN_steps_skipped_T # Assert that temperature setpoint is set self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", post_recondense_temp_sp, tolerance=0.001) - @parameterized.expand(parameterized_list([1, 2])) + @parameterized.expand(parameterized_list([0, 1, 2])) def test_WHEN_cancelled_in_any_step_THEN_temp_not_set_AND_cancelled(self, _, parts_skipped): # Set temp values original_temp_sp = 0.1 @@ -225,6 +228,17 @@ def test_WHEN_cancelled_in_any_step_THEN_temp_not_set_AND_cancelled(self, _, par # Assert that temperature setpoint is set self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", original_temp_sp, tolerance=0.001) + def test_WHEN_in_part_1_THEN_values_set_correctly(self): + self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") + self.ca.assert_that_pv_is("RECONDENSE:PART", "PART 1") + self.ca.assert_that_pv_is("RECONDENSE:SKIPPED", "NO") + self.ca.assert_that_pv_is("RECONDENSE:CANCELLED", "NO") + self.ca.assert_that_pv_is("RECONDENSE:TIMED_OUT", "NO") + self.ca.assert_that_pv_is("ADJUST_PIDS", "NO") + self.ca.assert_that_pv_is("MODE:HTR", "Manual") + self.ca.assert_that_pv_is_number("HEATERP", 0, tolerance=0.001) + self.ca.assert_that_pv_is_number("TEMP:SP", 0, tolerance=0.001) + @parameterized.expand(parameterized_list(["SETUP", "PART 1", "PART 2", "PART 3", "FINISHING", "NOT RECONDENSING"])) def test_WHEN_set_part_THEN_part_set(self, _, part): self.ca.assert_setting_setpoint_sets_readback(part, "RECONDENSE:PART") From c352965e3aacc08f63515be05b52940205cbcb96 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Tue, 23 Mar 2021 10:36:04 +0000 Subject: [PATCH 10/28] hlx503: Test setting sorb in part 1 of recondense --- tests/hlx503.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index 99c3e4306..b502fe75e 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -236,8 +236,13 @@ def test_WHEN_in_part_1_THEN_values_set_correctly(self): self.ca.assert_that_pv_is("RECONDENSE:TIMED_OUT", "NO") self.ca.assert_that_pv_is("ADJUST_PIDS", "NO") self.ca.assert_that_pv_is("MODE:HTR", "Manual") - self.ca.assert_that_pv_is_number("HEATERP", 0, tolerance=0.001) - self.ca.assert_that_pv_is_number("TEMP:SP", 0, tolerance=0.001) + self.ca.assert_that_pv_is_number("HEATERP", 0.0, tolerance=0.001) + self.ca.assert_that_pv_is("CTRLCHANNEL", "SORB") + self.ca.assert_that_pv_is_number("TEMP:SORB:SP", 33.0, tolerance=0.001) + self.ca.assert_that_pv_is_number("TEMP:SP", 33.0, tolerance=0.001) + self.ca.assert_that_pv_is_number("P", 1.2, tolerance=0.001) + self.ca.assert_that_pv_is_number("I", 1.2, tolerance=0.001) + self.ca.assert_that_pv_is_number("D", 1.2, tolerance=0.001) @parameterized.expand(parameterized_list(["SETUP", "PART 1", "PART 2", "PART 3", "FINISHING", "NOT RECONDENSING"])) def test_WHEN_set_part_THEN_part_set(self, _, part): From 2129436c9592c872bf12d0a7a0cc2f4720e4f202 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Tue, 23 Mar 2021 11:17:03 +0000 Subject: [PATCH 11/28] hlx503: Test setting of control channel --- tests/hlx503.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index b502fe75e..950d020cf 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -237,12 +237,12 @@ def test_WHEN_in_part_1_THEN_values_set_correctly(self): self.ca.assert_that_pv_is("ADJUST_PIDS", "NO") self.ca.assert_that_pv_is("MODE:HTR", "Manual") self.ca.assert_that_pv_is_number("HEATERP", 0.0, tolerance=0.001) - self.ca.assert_that_pv_is("CTRLCHANNEL", "SORB") self.ca.assert_that_pv_is_number("TEMP:SORB:SP", 33.0, tolerance=0.001) self.ca.assert_that_pv_is_number("TEMP:SP", 33.0, tolerance=0.001) self.ca.assert_that_pv_is_number("P", 1.2, tolerance=0.001) self.ca.assert_that_pv_is_number("I", 1.2, tolerance=0.001) self.ca.assert_that_pv_is_number("D", 1.2, tolerance=0.001) + self.ca.assert_that_pv_is("CTRLCHANNEL", "1KPOTHE3POTLO") @parameterized.expand(parameterized_list(["SETUP", "PART 1", "PART 2", "PART 3", "FINISHING", "NOT RECONDENSING"])) def test_WHEN_set_part_THEN_part_set(self, _, part): From 3d0838ec6295082dcb25c2d61b138afd40cca641 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Tue, 23 Mar 2021 12:48:04 +0000 Subject: [PATCH 12/28] hlx503: Test set values for part 3 --- tests/hlx503.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tests/hlx503.py b/tests/hlx503.py index 950d020cf..98941192a 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -244,6 +244,24 @@ def test_WHEN_in_part_1_THEN_values_set_correctly(self): self.ca.assert_that_pv_is_number("D", 1.2, tolerance=0.001) self.ca.assert_that_pv_is("CTRLCHANNEL", "1KPOTHE3POTLO") + def test_WHEN_in_part_3_THEN_values_set_correctly(self): + self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") + self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") + self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") + self.ca.assert_that_pv_is("RECONDENSE:PART", "PART 3") + self.ca.assert_that_pv_is("RECONDENSE:SKIPPED", "NO") + self.ca.assert_that_pv_is("RECONDENSE:CANCELLED", "NO") + self.ca.assert_that_pv_is("RECONDENSE:TIMED_OUT", "NO") + self.ca.assert_that_pv_is("ADJUST_PIDS", "NO") + self.ca.assert_that_pv_is("MODE:HTR", "Manual") + self.ca.assert_that_pv_is_number("HEATERP", 0.0, tolerance=0.001) + self.ca.assert_that_pv_is_number("TEMP:SORB:SP", 0.0, tolerance=0.001) + self.ca.assert_that_pv_is_number("TEMP:SP", 0.0, tolerance=0.001) + self.ca.assert_that_pv_is_number("P", 1.2, tolerance=0.001) + self.ca.assert_that_pv_is_number("I", 1.2, tolerance=0.001) + self.ca.assert_that_pv_is_number("D", 1.2, tolerance=0.001) + self.ca.assert_that_pv_is("CTRLCHANNEL", "SORB") + @parameterized.expand(parameterized_list(["SETUP", "PART 1", "PART 2", "PART 3", "FINISHING", "NOT RECONDENSING"])) def test_WHEN_set_part_THEN_part_set(self, _, part): self.ca.assert_setting_setpoint_sets_readback(part, "RECONDENSE:PART") From 5d5d12db14e37c03626118296d87edb76b5a6167 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Tue, 23 Mar 2021 14:53:10 +0000 Subject: [PATCH 13/28] hlx503: Remove no longer applicable tests and add tests for setting of new PVs --- tests/hlx503.py | 54 +++++++++++++++++++++++++++++++++---------------- 1 file changed, 37 insertions(+), 17 deletions(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index 98941192a..bc34323c0 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -8,6 +8,8 @@ from utils.testing import get_running_lewis_and_ioc, parameterized_list, skip_if_recsim from genie_python.utilities import dehex_and_decompress +from itertools import product + # Device prefix DEVICE_PREFIX = "HLX503_01" @@ -25,7 +27,15 @@ "1KPOTHE3POTLO_SENSOR": 2, "HE3POTHI_SENSOR": 3, "MAX_TEMP_FOR_HE3_COOLING": 2.0, - "MAX_OPERATING_TEMP_FOR_HELIOX": 20.0 + "MAX_OPERATING_TEMP_FOR_HELIOX": 20.0, + "RECONDENSE_SORB_TEMP_FINAL": 20.0, + "RECONDENSE_SORB_TEMP_SET": 33.0, + "RECONDENSE_SORB_P": 1.2, + "RECONDENSE_SORB_I": 1.2, + "RECONDENSE_SORB_D": 1.2, + "RECONDENSE_HE3POT_TARGET_TEMP_PART1": 1.5, + "RECONDENSE_HE3POT_TARGET_TEMP_PART2": 1.6, + "RECONDENSE_POST_PART2_WAIT_TIME": 10 } }, ] @@ -262,18 +272,6 @@ def test_WHEN_in_part_3_THEN_values_set_correctly(self): self.ca.assert_that_pv_is_number("D", 1.2, tolerance=0.001) self.ca.assert_that_pv_is("CTRLCHANNEL", "SORB") - @parameterized.expand(parameterized_list(["SETUP", "PART 1", "PART 2", "PART 3", "FINISHING", "NOT RECONDENSING"])) - def test_WHEN_set_part_THEN_part_set(self, _, part): - self.ca.assert_setting_setpoint_sets_readback(part, "RECONDENSE:PART") - - @parameterized.expand(parameterized_list(["YES", "NO"])) - def test_WHEN_set_timed_out_THEN_timed_out_set(self, _, timed_out): - self.ca.assert_setting_setpoint_sets_readback(timed_out, "RECONDENSE:TIMED_OUT") - - @parameterized.expand(parameterized_list(["YES", "NO"])) - def test_WHEN_set_skipped_THEN_skipped_set(self, _, skipped): - self.ca.assert_setting_setpoint_sets_readback(skipped, "RECONDENSE:SKIPPED") - @parameterized.expand(parameterized_list([0.5, 1.2])) def test_WHEN_set_post_recondense_temp_AND_setpoint_is_less_than_max_he3_cooling_temp_THEN_post_recondense_set( self, _, temp): @@ -299,7 +297,29 @@ def test_WHEN_set_post_recondense_temp_AND_setpoint_is_greater_than_max_heliox_o @skip_if_recsim("Comes back via record redirection which recsim can't handle easily") def test_WHEN_forward_post_condense_temp_setpoint_THEN_temp_set(self, _, temp): self.ca.assert_setting_setpoint_sets_readback(temp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP") - self.ca.process_pv("RECONDENSE:TEMP:_FORWARD") - self.ca.assert_that_pv_is("CTRLCHANNEL", "1KPOTHE3POTLO") - self.ca.assert_that_pv_is("TEMP:HE3POT:SP", temp) - self.ca.assert_that_pv_is("TEMP:HE3POT", temp) + + @parameterized.expand(parameterized_list([12.0, 15.0])) + def test_WHEN_set_final_recondense_sorb_temp_THEN_final_recondense_sorb_temp_set(self, _, temp): + self.ca.assert_setting_setpoint_sets_readback( + temp, "RECONDENSE:SORB:TEMP:FINAL:SP:RBV", set_point_pv="RECONDENSE:SORB:TEMP:FINAL:SP" + ) + + @parameterized.expand(parameterized_list([12.0, 15.0])) + def test_WHEN_set_recondense_sorb_temp_set_THEN_recondense_sorb_temp_set_set(self, _, temp): + self.ca.assert_setting_setpoint_sets_readback( + temp, "RECONDENSE:SORB:TEMP:SP:RBV", set_point_pv="RECONDENSE:SORB:TEMP:SP" + ) + + @parameterized.expand(parameterized_list(product(["P", "I", "D"], [0.8, 3.4]))) + def test_WHEN_set_recondense_sorb_pids_THEN_recondense_sorb_pids_set(self, _, p_or_i_or_d, val): + self.ca.assert_setting_setpoint_sets_readback( + val, f"RECONDENSE:SORB:{p_or_i_or_d}:SP:RBV", set_point_pv=f"RECONDENSE:SORB:{p_or_i_or_d}:SP" + ) + + @parameterized.expand(parameterized_list([3, 10])) + def test_WHEN_set_post_part_2_recondense_wait_time_THEN_post_part_2_recondense_wait_time_set(self, _, time): + self.ca.assert_setting_setpoint_sets_readback(time, "RECONDENSE:PART2:WAIT_TIME") + + @parameterized.expand(parameterized_list(product([1, 2], [1.8, 2.2]))) + def test_WHEN_set_he3pot_targets_THEN_he3pot_targets_set(self, _, part, temp): + self.ca.assert_setting_setpoint_sets_readback(temp, f"RECONDENSE:HE3POT:TEMP:PART{part}") From 8cc68ab7c2deda8b6cd562e133eccd5afddbab34 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Tue, 23 Mar 2021 15:45:30 +0000 Subject: [PATCH 14/28] hlx503: Clean up macro and recondense states in setup --- tests/hlx503.py | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/tests/hlx503.py b/tests/hlx503.py index bc34323c0..ed2bf6770 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -45,6 +45,17 @@ "HE3POT": "HE3POTHI" } +pv_to_macros_map = { + "RECONDENSE:SORB:TEMP:FINAL:SP": "RECONDENSE_SORB_TEMP_FINAL", + "RECONDENSE:SORB:TEMP:SP": "RECONDENSE_SORB_TEMP_SET", + "RECONDENSE:SORB:P:SP": "RECONDENSE_SORB_P", + "RECONDENSE:SORB:I:SP": "RECONDENSE_SORB_I", + "RECONDENSE:SORB:D:SP": "RECONDENSE_SORB_D", + "RECONDENSE:HE3POT:TEMP:PART1:SP": "RECONDENSE_HE3POT_TARGET_TEMP_PART1", + "RECONDENSE:HE3POT:TEMP:PART2:SP": "RECONDENSE_HE3POT_TARGET_TEMP_PART1", + "RECONDENSE:PART2:WAIT_TIME:SP": "RECONDENSE_POST_PART2_WAIT_TIME" +} + TEST_MODES = [TestModes.DEVSIM, TestModes.RECSIM] @@ -68,8 +79,22 @@ def setUp(self): if not IOCRegister.uses_rec_sim: self._lewis.backdoor_run_function_on_device("backdoor_plug_in_he3potlow") + self.reset_any_changes_from_recondense() + self.reset_any_changes_from_macros() + + def reset_any_changes_from_recondense(self): self.ca.set_pv_value("RECONDENSE:CANCELLED:SP", "YES") + self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "NO") + self.ca.set_pv_value("RECONDENSE:CANCELLED:SP", "NO") + self.ca.set_pv_value("RECONDENSING:SP", "NO") + self.ca.set_pv_value("RECONDENSE:TIMED_OUT", "NO") self.ca.assert_that_pv_is("RECONDENSING", "NO") + self.ca.assert_that_pv_is("RECONDENSE:PART", "NOT RECONDENSING") + self._lewis.backdoor_run_function_on_device("reset_to_temp_control_state") + + def reset_any_changes_from_macros(self): + for pv, macro in pv_to_macros_map.items(): + self.ca.set_pv_value(pv, IOCS[0]["macros"][macro]) @parameterized.expand(parameterized_list(["Auto", "Manual"])) def test_WHEN_set_autoheat_THEN_autoheat_set(self, _, value): From 6c5a1ac073f9fb2fcf87383390b21aacd29f5572 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Tue, 23 Mar 2021 17:24:34 +0000 Subject: [PATCH 15/28] hlx503: Correct for new pv naming scheme --- tests/hlx503.py | 92 ++++++++++++++++++++++++------------------------- 1 file changed, 46 insertions(+), 46 deletions(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index ed2bf6770..3a1d52efc 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -46,14 +46,14 @@ } pv_to_macros_map = { - "RECONDENSE:SORB:TEMP:FINAL:SP": "RECONDENSE_SORB_TEMP_FINAL", - "RECONDENSE:SORB:TEMP:SP": "RECONDENSE_SORB_TEMP_SET", - "RECONDENSE:SORB:P:SP": "RECONDENSE_SORB_P", - "RECONDENSE:SORB:I:SP": "RECONDENSE_SORB_I", - "RECONDENSE:SORB:D:SP": "RECONDENSE_SORB_D", - "RECONDENSE:HE3POT:TEMP:PART1:SP": "RECONDENSE_HE3POT_TARGET_TEMP_PART1", - "RECONDENSE:HE3POT:TEMP:PART2:SP": "RECONDENSE_HE3POT_TARGET_TEMP_PART1", - "RECONDENSE:PART2:WAIT_TIME:SP": "RECONDENSE_POST_PART2_WAIT_TIME" + "RE:SORB:TEMP:FIN:SP": "RECONDENSE_SORB_TEMP_FINAL", + "RE:SORB:TEMP:SP": "RECONDENSE_SORB_TEMP_SET", + "RE:SORB:P:SP": "RECONDENSE_SORB_P", + "RE:SORB:I:SP": "RECONDENSE_SORB_I", + "RE:SORB:D:SP": "RECONDENSE_SORB_D", + "RE:HE3POT:TEMP:PART1:SP": "RECONDENSE_HE3POT_TARGET_TEMP_PART1", + "RE:HE3POT:TEMP:PART2:SP": "RECONDENSE_HE3POT_TARGET_TEMP_PART1", + "RE:PART2:WAIT_TIME:SP": "RECONDENSE_POST_PART2_WAIT_TIME" } @@ -83,13 +83,13 @@ def setUp(self): self.reset_any_changes_from_macros() def reset_any_changes_from_recondense(self): - self.ca.set_pv_value("RECONDENSE:CANCELLED:SP", "YES") - self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "NO") - self.ca.set_pv_value("RECONDENSE:CANCELLED:SP", "NO") + self.ca.set_pv_value("RE:CANCELLED:SP", "YES") + self.ca.set_pv_value("RE:SKIPPED:SP", "NO") + self.ca.set_pv_value("RE:CANCELLED:SP", "NO") self.ca.set_pv_value("RECONDENSING:SP", "NO") - self.ca.set_pv_value("RECONDENSE:TIMED_OUT", "NO") + self.ca.set_pv_value("RE:TIMED_OUT", "NO") self.ca.assert_that_pv_is("RECONDENSING", "NO") - self.ca.assert_that_pv_is("RECONDENSE:PART", "NOT RECONDENSING") + self.ca.assert_that_pv_is("RE:PART", "NOT RECONDENSING") self._lewis.backdoor_run_function_on_device("reset_to_temp_control_state") def reset_any_changes_from_macros(self): @@ -231,16 +231,16 @@ def test_WHEN_recondense_started_THEN_condensing_is_started_WHEN_steps_skipped_T self.ca.set_pv_value("TEMP:HE3POT:SP", 0.1) post_recondense_temp_sp = 0.3 self.ca.assert_setting_setpoint_sets_readback( - post_recondense_temp_sp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP" + post_recondense_temp_sp, "RE:TEMP:SP:RBV", set_point_pv="RE:TEMP:SP" ) # Start recondensing and skip steps self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") - self.ca.assert_that_pv_is("RECONDENSE:PART", "PART 1") - self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") - self.ca.assert_that_pv_is("RECONDENSE:PART", "PART 2") - self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") - self.ca.assert_that_pv_is("RECONDENSE:PART", "PART 3") - self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") + self.ca.assert_that_pv_is("RE:PART", "PART 1") + self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + self.ca.assert_that_pv_is("RE:PART", "PART 2") + self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + self.ca.assert_that_pv_is("RE:PART", "PART 3") + self.ca.set_pv_value("RE:SKIPPED:SP", "YES") # Assert that temperature setpoint is set self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", post_recondense_temp_sp, tolerance=0.001) @@ -251,24 +251,24 @@ def test_WHEN_cancelled_in_any_step_THEN_temp_not_set_AND_cancelled(self, _, par self.ca.set_pv_value("TEMP:HE3POT:SP", original_temp_sp) post_recondense_temp_sp = 0.3 self.ca.assert_setting_setpoint_sets_readback( - post_recondense_temp_sp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP" + post_recondense_temp_sp, "RE:TEMP:SP:RBV", set_point_pv="RE:TEMP:SP" ) # Start recondensing and skip steps self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") for i in range(parts_skipped): - self.ca.assert_that_pv_is("RECONDENSE:PART", f"PART {i+1}") - self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") - self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSE:CANCELLED") - self.ca.assert_that_pv_is("RECONDENSE:PART", "NOT RECONDENSING") + self.ca.assert_that_pv_is("RE:PART", f"PART {i+1}") + self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + self.ca.assert_setting_setpoint_sets_readback("YES", "RE:CANCELLED") + self.ca.assert_that_pv_is("RE:PART", "NOT RECONDENSING") # Assert that temperature setpoint is set self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", original_temp_sp, tolerance=0.001) def test_WHEN_in_part_1_THEN_values_set_correctly(self): self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") - self.ca.assert_that_pv_is("RECONDENSE:PART", "PART 1") - self.ca.assert_that_pv_is("RECONDENSE:SKIPPED", "NO") - self.ca.assert_that_pv_is("RECONDENSE:CANCELLED", "NO") - self.ca.assert_that_pv_is("RECONDENSE:TIMED_OUT", "NO") + self.ca.assert_that_pv_is("RE:PART", "PART 1") + self.ca.assert_that_pv_is("RE:SKIPPED", "NO") + self.ca.assert_that_pv_is("RE:CANCELLED", "NO") + self.ca.assert_that_pv_is("RE:TIMED_OUT", "NO") self.ca.assert_that_pv_is("ADJUST_PIDS", "NO") self.ca.assert_that_pv_is("MODE:HTR", "Manual") self.ca.assert_that_pv_is_number("HEATERP", 0.0, tolerance=0.001) @@ -281,12 +281,12 @@ def test_WHEN_in_part_1_THEN_values_set_correctly(self): def test_WHEN_in_part_3_THEN_values_set_correctly(self): self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") - self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") - self.ca.set_pv_value("RECONDENSE:SKIPPED:SP", "YES") - self.ca.assert_that_pv_is("RECONDENSE:PART", "PART 3") - self.ca.assert_that_pv_is("RECONDENSE:SKIPPED", "NO") - self.ca.assert_that_pv_is("RECONDENSE:CANCELLED", "NO") - self.ca.assert_that_pv_is("RECONDENSE:TIMED_OUT", "NO") + self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + self.ca.assert_that_pv_is("RE:PART", "PART 3") + self.ca.assert_that_pv_is("RE:SKIPPED", "NO") + self.ca.assert_that_pv_is("RE:CANCELLED", "NO") + self.ca.assert_that_pv_is("RE:TIMED_OUT", "NO") self.ca.assert_that_pv_is("ADJUST_PIDS", "NO") self.ca.assert_that_pv_is("MODE:HTR", "Manual") self.ca.assert_that_pv_is_number("HEATERP", 0.0, tolerance=0.001) @@ -300,51 +300,51 @@ def test_WHEN_in_part_3_THEN_values_set_correctly(self): @parameterized.expand(parameterized_list([0.5, 1.2])) def test_WHEN_set_post_recondense_temp_AND_setpoint_is_less_than_max_he3_cooling_temp_THEN_post_recondense_set( self, _, temp): - self.ca.assert_setting_setpoint_sets_readback(temp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP") + self.ca.assert_setting_setpoint_sets_readback(temp, "RE:TEMP:SP:RBV", set_point_pv="RE:TEMP:SP") @parameterized.expand(parameterized_list([2.8, 12.2])) def test_WHEN_set_post_recondense_temp_AND_setpoint_is_greater_than_max_he3_cooling_temp_THEN_post_recondense_not_set( self, _, temp): self.ca.assert_setting_setpoint_sets_readback( - temp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP", expected_value=0.3 + temp, "RE:TEMP:SP:RBV", set_point_pv="RE:TEMP:SP", expected_value=0.3 ) - self.ca.assert_that_pv_alarm_is("RECONDENSE:TEMP:SP", self.ca.Alarms.MINOR) + self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MINOR) @parameterized.expand(parameterized_list([20.8, 100.2])) def test_WHEN_set_post_recondense_temp_AND_setpoint_is_greater_than_max_heliox_op_temp_THEN_post_recondense_not_set( self, _, temp): self.ca.assert_setting_setpoint_sets_readback( - temp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP", expected_value=0.3 + temp, "RE:TEMP:SP:RBV", set_point_pv="RE:TEMP:SP", expected_value=0.3 ) - self.ca.assert_that_pv_alarm_is("RECONDENSE:TEMP:SP", self.ca.Alarms.MAJOR) + self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MAJOR) @parameterized.expand(parameterized_list([0.5, 1.2])) @skip_if_recsim("Comes back via record redirection which recsim can't handle easily") def test_WHEN_forward_post_condense_temp_setpoint_THEN_temp_set(self, _, temp): - self.ca.assert_setting_setpoint_sets_readback(temp, "RECONDENSE:TEMP:SP:RBV", set_point_pv="RECONDENSE:TEMP:SP") + self.ca.assert_setting_setpoint_sets_readback(temp, "RE:TEMP:SP:RBV", set_point_pv="RE:TEMP:SP") @parameterized.expand(parameterized_list([12.0, 15.0])) def test_WHEN_set_final_recondense_sorb_temp_THEN_final_recondense_sorb_temp_set(self, _, temp): self.ca.assert_setting_setpoint_sets_readback( - temp, "RECONDENSE:SORB:TEMP:FINAL:SP:RBV", set_point_pv="RECONDENSE:SORB:TEMP:FINAL:SP" + temp, "RE:SORB:TEMP:FIN:SP:RBV", set_point_pv="RE:SORB:TEMP:FIN:SP" ) @parameterized.expand(parameterized_list([12.0, 15.0])) def test_WHEN_set_recondense_sorb_temp_set_THEN_recondense_sorb_temp_set_set(self, _, temp): self.ca.assert_setting_setpoint_sets_readback( - temp, "RECONDENSE:SORB:TEMP:SP:RBV", set_point_pv="RECONDENSE:SORB:TEMP:SP" + temp, "RE:SORB:TEMP:SP:RBV", set_point_pv="RE:SORB:TEMP:SP" ) @parameterized.expand(parameterized_list(product(["P", "I", "D"], [0.8, 3.4]))) def test_WHEN_set_recondense_sorb_pids_THEN_recondense_sorb_pids_set(self, _, p_or_i_or_d, val): self.ca.assert_setting_setpoint_sets_readback( - val, f"RECONDENSE:SORB:{p_or_i_or_d}:SP:RBV", set_point_pv=f"RECONDENSE:SORB:{p_or_i_or_d}:SP" + val, f"RE:SORB:{p_or_i_or_d}:SP:RBV", set_point_pv=f"RE:SORB:{p_or_i_or_d}:SP" ) @parameterized.expand(parameterized_list([3, 10])) def test_WHEN_set_post_part_2_recondense_wait_time_THEN_post_part_2_recondense_wait_time_set(self, _, time): - self.ca.assert_setting_setpoint_sets_readback(time, "RECONDENSE:PART2:WAIT_TIME") + self.ca.assert_setting_setpoint_sets_readback(time, "RE:PART2:WAIT_TIME") @parameterized.expand(parameterized_list(product([1, 2], [1.8, 2.2]))) def test_WHEN_set_he3pot_targets_THEN_he3pot_targets_set(self, _, part, temp): - self.ca.assert_setting_setpoint_sets_readback(temp, f"RECONDENSE:HE3POT:TEMP:PART{part}") + self.ca.assert_setting_setpoint_sets_readback(temp, f"RE:HE3POT:TEMP:PART{part}") From 367a71f264ea29622031f18691f4c00d31a1d747 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Wed, 24 Mar 2021 14:38:36 +0000 Subject: [PATCH 16/28] hlx503: Correct for pv renaming; change expected control channel --- tests/hlx503.py | 34 ++++++++++------------------------ 1 file changed, 10 insertions(+), 24 deletions(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index 3a1d52efc..be273ad28 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -230,9 +230,7 @@ def test_WHEN_recondense_started_THEN_condensing_is_started_WHEN_steps_skipped_T # Set temp values self.ca.set_pv_value("TEMP:HE3POT:SP", 0.1) post_recondense_temp_sp = 0.3 - self.ca.assert_setting_setpoint_sets_readback( - post_recondense_temp_sp, "RE:TEMP:SP:RBV", set_point_pv="RE:TEMP:SP" - ) + self.ca.assert_setting_setpoint_sets_readback(post_recondense_temp_sp, "RE:TEMP") # Start recondensing and skip steps self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") self.ca.assert_that_pv_is("RE:PART", "PART 1") @@ -250,9 +248,7 @@ def test_WHEN_cancelled_in_any_step_THEN_temp_not_set_AND_cancelled(self, _, par original_temp_sp = 0.1 self.ca.set_pv_value("TEMP:HE3POT:SP", original_temp_sp) post_recondense_temp_sp = 0.3 - self.ca.assert_setting_setpoint_sets_readback( - post_recondense_temp_sp, "RE:TEMP:SP:RBV", set_point_pv="RE:TEMP:SP" - ) + self.ca.assert_setting_setpoint_sets_readback(post_recondense_temp_sp, "RE:TEMP") # Start recondensing and skip steps self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") for i in range(parts_skipped): @@ -271,13 +267,13 @@ def test_WHEN_in_part_1_THEN_values_set_correctly(self): self.ca.assert_that_pv_is("RE:TIMED_OUT", "NO") self.ca.assert_that_pv_is("ADJUST_PIDS", "NO") self.ca.assert_that_pv_is("MODE:HTR", "Manual") + self.ca.assert_that_pv_is("CTRLCHANNEL", "SORB") self.ca.assert_that_pv_is_number("HEATERP", 0.0, tolerance=0.001) self.ca.assert_that_pv_is_number("TEMP:SORB:SP", 33.0, tolerance=0.001) self.ca.assert_that_pv_is_number("TEMP:SP", 33.0, tolerance=0.001) self.ca.assert_that_pv_is_number("P", 1.2, tolerance=0.001) self.ca.assert_that_pv_is_number("I", 1.2, tolerance=0.001) self.ca.assert_that_pv_is_number("D", 1.2, tolerance=0.001) - self.ca.assert_that_pv_is("CTRLCHANNEL", "1KPOTHE3POTLO") def test_WHEN_in_part_3_THEN_values_set_correctly(self): self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") @@ -300,46 +296,36 @@ def test_WHEN_in_part_3_THEN_values_set_correctly(self): @parameterized.expand(parameterized_list([0.5, 1.2])) def test_WHEN_set_post_recondense_temp_AND_setpoint_is_less_than_max_he3_cooling_temp_THEN_post_recondense_set( self, _, temp): - self.ca.assert_setting_setpoint_sets_readback(temp, "RE:TEMP:SP:RBV", set_point_pv="RE:TEMP:SP") + self.ca.assert_setting_setpoint_sets_readback(temp, "RE:TEMP") @parameterized.expand(parameterized_list([2.8, 12.2])) def test_WHEN_set_post_recondense_temp_AND_setpoint_is_greater_than_max_he3_cooling_temp_THEN_post_recondense_not_set( self, _, temp): - self.ca.assert_setting_setpoint_sets_readback( - temp, "RE:TEMP:SP:RBV", set_point_pv="RE:TEMP:SP", expected_value=0.3 - ) + self.ca.assert_setting_setpoint_sets_readback(temp, "RE:TEMP", expected_value=0.3) self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MINOR) @parameterized.expand(parameterized_list([20.8, 100.2])) def test_WHEN_set_post_recondense_temp_AND_setpoint_is_greater_than_max_heliox_op_temp_THEN_post_recondense_not_set( self, _, temp): - self.ca.assert_setting_setpoint_sets_readback( - temp, "RE:TEMP:SP:RBV", set_point_pv="RE:TEMP:SP", expected_value=0.3 - ) + self.ca.assert_setting_setpoint_sets_readback(temp, "RE:TEMP", expected_value=0.3) self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MAJOR) @parameterized.expand(parameterized_list([0.5, 1.2])) @skip_if_recsim("Comes back via record redirection which recsim can't handle easily") def test_WHEN_forward_post_condense_temp_setpoint_THEN_temp_set(self, _, temp): - self.ca.assert_setting_setpoint_sets_readback(temp, "RE:TEMP:SP:RBV", set_point_pv="RE:TEMP:SP") + self.ca.assert_setting_setpoint_sets_readback(temp, "RE:TEMP") @parameterized.expand(parameterized_list([12.0, 15.0])) def test_WHEN_set_final_recondense_sorb_temp_THEN_final_recondense_sorb_temp_set(self, _, temp): - self.ca.assert_setting_setpoint_sets_readback( - temp, "RE:SORB:TEMP:FIN:SP:RBV", set_point_pv="RE:SORB:TEMP:FIN:SP" - ) + self.ca.assert_setting_setpoint_sets_readback(temp, "RE:SORB:TEMP:FIN") @parameterized.expand(parameterized_list([12.0, 15.0])) def test_WHEN_set_recondense_sorb_temp_set_THEN_recondense_sorb_temp_set_set(self, _, temp): - self.ca.assert_setting_setpoint_sets_readback( - temp, "RE:SORB:TEMP:SP:RBV", set_point_pv="RE:SORB:TEMP:SP" - ) + self.ca.assert_setting_setpoint_sets_readback(temp, "RE:SORB:TEMP") @parameterized.expand(parameterized_list(product(["P", "I", "D"], [0.8, 3.4]))) def test_WHEN_set_recondense_sorb_pids_THEN_recondense_sorb_pids_set(self, _, p_or_i_or_d, val): - self.ca.assert_setting_setpoint_sets_readback( - val, f"RE:SORB:{p_or_i_or_d}:SP:RBV", set_point_pv=f"RE:SORB:{p_or_i_or_d}:SP" - ) + self.ca.assert_setting_setpoint_sets_readback(val, f"RE:SORB:{p_or_i_or_d}") @parameterized.expand(parameterized_list([3, 10])) def test_WHEN_set_post_part_2_recondense_wait_time_THEN_post_part_2_recondense_wait_time_set(self, _, time): From a0c492d243944aef7c0b439a7b2cc7d1d8e7d6ff Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Wed, 24 Mar 2021 15:44:49 +0000 Subject: [PATCH 17/28] hlx503: Add tests for setting MAX_TEMP_FOR_HE3_COOLING --- tests/hlx503.py | 33 ++++++++++++++++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index be273ad28..77fc6dff8 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -53,7 +53,8 @@ "RE:SORB:D:SP": "RECONDENSE_SORB_D", "RE:HE3POT:TEMP:PART1:SP": "RECONDENSE_HE3POT_TARGET_TEMP_PART1", "RE:HE3POT:TEMP:PART2:SP": "RECONDENSE_HE3POT_TARGET_TEMP_PART1", - "RE:PART2:WAIT_TIME:SP": "RECONDENSE_POST_PART2_WAIT_TIME" + "RE:PART2:WAIT_TIME:SP": "RECONDENSE_POST_PART2_WAIT_TIME", + "MAX_TEMP_FOR_HE3_COOLING": "MAX_TEMP_FOR_HE3_COOLING" } @@ -334,3 +335,33 @@ def test_WHEN_set_post_part_2_recondense_wait_time_THEN_post_part_2_recondense_w @parameterized.expand(parameterized_list(product([1, 2], [1.8, 2.2]))) def test_WHEN_set_he3pot_targets_THEN_he3pot_targets_set(self, _, part, temp): self.ca.assert_setting_setpoint_sets_readback(temp, f"RE:HE3POT:TEMP:PART{part}") + + @parameterized.expand(parameterized_list([1.4, 3.2])) + def test_WHEN_set_max_temp_he3_cooling_THEN_max_temp_he3_cooling_set(self, _, max_temp_for_he3_cooling): + self.ca.assert_setting_setpoint_sets_readback(max_temp_for_he3_cooling, "MAX_TEMP_FOR_HE3_COOLING") + + @parameterized.expand(parameterized_list([ + (1.4, 0.8, "1KPOTHE3POTLO", "1KPOTHE3POTLO"), (1.4, 1.9, "1KPOTHE3POTLO", "HE3POTHI"), + (3.2, 2.1, "HE3POTHI", "1KPOTHE3POTLO"), (3.2, 3.8, "HE3POTHI", "HE3POTHI")])) + def test_WHEN_set_max_temp_he3_cooling_THEN_correct_control_channel_used( + self, _, max_temp_for_he3_cooling, temp, previous_expected_ctrl_channel, new_expected_ctrl_channel): + self.ca.set_pv_value("TEMP:HE3POT:SP", temp) + self.ca.assert_that_pv_is("CTRLCHANNEL", previous_expected_ctrl_channel) + self.ca.assert_setting_setpoint_sets_readback(max_temp_for_he3_cooling, "MAX_TEMP_FOR_HE3_COOLING") + self.ca.set_pv_value("TEMP:HE3POT:SP", temp) + self.ca.assert_that_pv_is("CTRLCHANNEL", new_expected_ctrl_channel) + + @parameterized.expand(parameterized_list([(1.4, False), (3.2, True)])) + def test_WHEN_set_max_temp_he3_cooling_THEN_high_value_set_on_recondense_temp_sp_AND_alarms_correct( + self, _, max_temp_for_he3_cooling, alarm_expected): + self.ca.set_pv_value("RE:TEMP:SP", max_temp_for_he3_cooling + 0.1) + if alarm_expected: + self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MINOR) + self.ca.assert_that_pv_alarm_is("RE:TEMP", self.ca.Alarms.MINOR) + else: + self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.NONE) + self.ca.assert_that_pv_alarm_is("RE:TEMP", self.ca.Alarms.NONE) + self.ca.assert_setting_setpoint_sets_readback(max_temp_for_he3_cooling, "MAX_TEMP_FOR_HE3_COOLING") + self.ca.assert_that_pv_is("RE:TEMP:SP.HIGH", max_temp_for_he3_cooling) + self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MINOR) + self.ca.assert_that_pv_alarm_is("RE:TEMP", self.ca.Alarms.MINOR) From 27d7e2ea40b81bc8b1179acf8eb04e9e86f57201 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Thu, 25 Mar 2021 09:43:32 +0000 Subject: [PATCH 18/28] hlx503: Correct test expected alarm; add test for setting max_temp_he3_cooling --- tests/hlx503.py | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index 77fc6dff8..5bf0de591 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -302,7 +302,9 @@ def test_WHEN_set_post_recondense_temp_AND_setpoint_is_less_than_max_he3_cooling @parameterized.expand(parameterized_list([2.8, 12.2])) def test_WHEN_set_post_recondense_temp_AND_setpoint_is_greater_than_max_he3_cooling_temp_THEN_post_recondense_not_set( self, _, temp): - self.ca.assert_setting_setpoint_sets_readback(temp, "RE:TEMP", expected_value=0.3) + self.ca.assert_setting_setpoint_sets_readback( + temp, "RE:TEMP", expected_value=0.3, expected_alarm=self.ca.Alarms.MINOR + ) self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MINOR) @parameterized.expand(parameterized_list([20.8, 100.2])) @@ -365,3 +367,18 @@ def test_WHEN_set_max_temp_he3_cooling_THEN_high_value_set_on_recondense_temp_sp self.ca.assert_that_pv_is("RE:TEMP:SP.HIGH", max_temp_for_he3_cooling) self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MINOR) self.ca.assert_that_pv_alarm_is("RE:TEMP", self.ca.Alarms.MINOR) + + @parameterized.expand(parameterized_list([(1.4, False), (3.2, True)])) + def test_WHEN_set_max_temp_he3_cooling_THEN_low_value_set_on_recondense_temp_sp_AND_alarms_correct( + self, _, max_temp_for_he3_cooling, alarm_expected): + self.ca.set_pv_value("RE:TEMP:SP", max_temp_for_he3_cooling - 0.1) + if alarm_expected: + self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MINOR) + self.ca.assert_that_pv_alarm_is("RE:TEMP", self.ca.Alarms.MINOR) + else: + self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.NONE) + self.ca.assert_that_pv_alarm_is("RE:TEMP", self.ca.Alarms.NONE) + self.ca.assert_setting_setpoint_sets_readback(max_temp_for_he3_cooling, "MAX_TEMP_FOR_HE3_COOLING") + self.ca.assert_that_pv_is("RE:TEMP:SP.HIGH", max_temp_for_he3_cooling) + self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.NONE) + self.ca.assert_that_pv_alarm_is("RE:TEMP", self.ca.Alarms.NONE) From 95be9f340fad1d5420b961081baeeab12fc01949 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Thu, 25 Mar 2021 10:11:35 +0000 Subject: [PATCH 19/28] hlx503: Correct test failing on alarm, test setting of timeout --- tests/hlx503.py | 37 ++++++++++++++++++++++++++++++++++--- 1 file changed, 34 insertions(+), 3 deletions(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index 5bf0de591..1ee72b26a 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -35,7 +35,9 @@ "RECONDENSE_SORB_D": 1.2, "RECONDENSE_HE3POT_TARGET_TEMP_PART1": 1.5, "RECONDENSE_HE3POT_TARGET_TEMP_PART2": 1.6, - "RECONDENSE_POST_PART2_WAIT_TIME": 10 + "RECONDENSE_POST_PART2_WAIT_TIME": 10, + "RECONDENSE_PART_TIMEOUT": 1800, + "RECONDENSE_PART_TIMEOUT_ON": "YES" } }, ] @@ -54,7 +56,9 @@ "RE:HE3POT:TEMP:PART1:SP": "RECONDENSE_HE3POT_TARGET_TEMP_PART1", "RE:HE3POT:TEMP:PART2:SP": "RECONDENSE_HE3POT_TARGET_TEMP_PART1", "RE:PART2:WAIT_TIME:SP": "RECONDENSE_POST_PART2_WAIT_TIME", - "MAX_TEMP_FOR_HE3_COOLING": "MAX_TEMP_FOR_HE3_COOLING" + "MAX_TEMP_FOR_HE3_COOLING": "MAX_TEMP_FOR_HE3_COOLING", + "RE:TIMEOUT:SP": "RECONDENSE_PART_TIMEOUT", + "RE:TIMEOUT:ON:SP": "RECONDENSE_PART_TIMEOUT_ON" } @@ -310,7 +314,7 @@ def test_WHEN_set_post_recondense_temp_AND_setpoint_is_greater_than_max_he3_cool @parameterized.expand(parameterized_list([20.8, 100.2])) def test_WHEN_set_post_recondense_temp_AND_setpoint_is_greater_than_max_heliox_op_temp_THEN_post_recondense_not_set( self, _, temp): - self.ca.assert_setting_setpoint_sets_readback(temp, "RE:TEMP", expected_value=0.3) + self.ca.assert_setting_setpoint_sets_readback(temp, "RE:TEMP", expected_value=0.3, expected_alarm=self.ca.Alarms.MAJOR) self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MAJOR) @parameterized.expand(parameterized_list([0.5, 1.2])) @@ -382,3 +386,30 @@ def test_WHEN_set_max_temp_he3_cooling_THEN_low_value_set_on_recondense_temp_sp_ self.ca.assert_that_pv_is("RE:TEMP:SP.HIGH", max_temp_for_he3_cooling) self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.NONE) self.ca.assert_that_pv_alarm_is("RE:TEMP", self.ca.Alarms.NONE) + + @parameterized.expand(parameterized_list(["YES", "NO"])) + def test_WHEN_set_timeout_on_or_off_THEN_timeout_on_or_off_set(self, _, on_or_off): + self.ca.assert_setting_setpoint_sets_readback(on_or_off, "RE:TIMEOUT:ON") + + @parameterized.expand(parameterized_list([2, 30])) + def test_WHEN_set_timeout_THEN_timeout_set(self, _, timeout): + self.ca.assert_setting_setpoint_sets_readback(timeout, "RE:TIMEOUT") + + @parameterized.expand(parameterized_list([0, 1, 2])) + def test_WHEN_timed_out_in_any_step_THEN_temp_set_AND_timed_out(self, _, parts_skipped): + # Set temp values + original_temp_sp = 0.1 + self.ca.set_pv_value("TEMP:HE3POT:SP", original_temp_sp) + post_recondense_temp_sp = 0.3 + self.ca.assert_setting_setpoint_sets_readback(post_recondense_temp_sp, "RE:TEMP") + # Start recondensing and skip steps + self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") + for i in range(parts_skipped): + self.ca.assert_that_pv_is("RE:PART", f"PART {i+1}") + self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + self.ca.assert_setting_setpoint_sets_readback(1, "RE:TIMEOUT") + self.ca.assert_that_pv_is("YES", "RE:TIMED_OUT", timeout=3) + self.ca.assert_that_pv_is("RE:PART", "NOT RECONDENSING") + # Assert that temperature setpoint is set + self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", post_recondense_temp_sp, tolerance=0.001) + From 82842d28778609d62037a58c3ac6c2dbadec47a2 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Thu, 25 Mar 2021 10:31:17 +0000 Subject: [PATCH 20/28] hlx503: Further testing of timing out parts --- tests/hlx503.py | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index 1ee72b26a..3bbae1f03 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -408,8 +408,28 @@ def test_WHEN_timed_out_in_any_step_THEN_temp_set_AND_timed_out(self, _, parts_s self.ca.assert_that_pv_is("RE:PART", f"PART {i+1}") self.ca.set_pv_value("RE:SKIPPED:SP", "YES") self.ca.assert_setting_setpoint_sets_readback(1, "RE:TIMEOUT") - self.ca.assert_that_pv_is("YES", "RE:TIMED_OUT", timeout=3) + self.ca.assert_that_pv_is("RE:TIMED_OUT", "YES", timeout=3) self.ca.assert_that_pv_is("RE:PART", "NOT RECONDENSING") # Assert that temperature setpoint is set self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", post_recondense_temp_sp, tolerance=0.001) + @parameterized.expand(parameterized_list([0, 1, 2])) + def test_WHEN_time_out_off_in_any_step_AND_wait_AND_cancel_THEN_temp_not_set_AND_timed_out(self, _, parts_skipped): + # Set temp values + original_temp_sp = 0.1 + self.ca.set_pv_value("TEMP:HE3POT:SP", original_temp_sp) + post_recondense_temp_sp = 0.3 + self.ca.assert_setting_setpoint_sets_readback(post_recondense_temp_sp, "RE:TEMP") + # Start recondensing and skip steps + self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") + for i in range(parts_skipped): + self.ca.assert_that_pv_is("RE:PART", f"PART {i+1}") + self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + self.ca.assert_setting_setpoint_sets_readback("NO", "RE:TIMEOUT:ON") + self.ca.set_pv_value("RE:TIMEOUT:SP", 1, sleep_after_set=2) + self.ca.assert_that_pv_is("RE:TIMED_OUT", "NO", timeout=3) + self.ca.set_pv_value("RE:CANCELLED:SP", "YES") + self.ca.assert_that_pv_is("RE:PART", "NOT RECONDENSING") + # Assert that temperature setpoint is set + self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", original_temp_sp, tolerance=0.001) + From 3b354844041f81f982b0425cdd119038b9c87b42 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Thu, 25 Mar 2021 13:26:52 +0000 Subject: [PATCH 21/28] hlx503: Test real recondense logic --- tests/hlx503.py | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/tests/hlx503.py b/tests/hlx503.py index 3bbae1f03..6654fe25f 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -433,3 +433,35 @@ def test_WHEN_time_out_off_in_any_step_AND_wait_AND_cancel_THEN_temp_not_set_AND # Assert that temperature setpoint is set self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", original_temp_sp, tolerance=0.001) + @skip_if_recsim("Backdoor not available in recsim") + def test_WHEN_recondense_THEN_recondense(self): + # Set requirement for recondense + self._lewis.backdoor_set_on_device("helium_3_pot_empty", True) + # Set temp values + original_temp_sp = 0.1 + self.ca.set_pv_value("TEMP:HE3POT:SP", original_temp_sp) + post_recondense_temp_sp = 0.3 + self.ca.assert_setting_setpoint_sets_readback(post_recondense_temp_sp, "RE:TEMP") + # Set state for recondense + self.ca.set_pv_value("RE:PART2:WAIT_TIME", 1) + # Initiate recondense + self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") + # Wait for recondense to finish + self.ca.assert_that_pv_is("RE:PART", "PART 1", timeout=3) + self.ca.assert_that_pv_is("RE:PART", "PART 2", timeout=3) + self.ca.assert_that_pv_is("RE:PART", "PART 3", timeout=3) + self.ca.assert_that_pv_is("RECONDENSING", "NO", timeout=3) + self._lewis.backdoor_set_on_device("helium_3_pot_empty", False) + # Assert post condense status + self.ca.assert_that_pv_is("RE:SUCCESS", "YES") + self.ca.assert_that_pv_is("RE:CANCELLED", "NO") + self.ca.assert_that_pv_is("RE:TIMED_OUT", "NO") + self.ca.assert_that_pv_is("RE:SKIPPED", "NO") + self.ca.assert_that_pv_is("RE:PART", "NOT RECONDENSING") + # Assert post condense setpoint set + self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", post_recondense_temp_sp, tolerance=0.001) + self.ca.assert_that_pv_is_number("TEMP:HE3POT", post_recondense_temp_sp, tolerance=0.001) + + + + From 803c3e02acf99be15b35a28ecb8435ef852629ef Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Fri, 26 Mar 2021 14:15:41 +0000 Subject: [PATCH 22/28] hlx503: Avoid recondense conditions by setting unattainable targets, change test assertions to match new logic --- tests/hlx503.py | 47 ++++++++++++++++++++++++++++++++++++----------- 1 file changed, 36 insertions(+), 11 deletions(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index 6654fe25f..62a0c0a3e 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -69,6 +69,11 @@ (0.6, 13.0, 14.0, 15.0, "HE3POT"), (4.0, 23.0, 24.0, 25.0, "HE3POT"), (5.8, 33.0, 34.0, 35.0, "HE3POT") ] +UNATTAINABLE_RECONDENSE_VALUES = { + "RE:SORB:TEMP:SP": 10000, "RE:SORB:TEMP:FIN:SP": -1000, + "RE:HE3POT:TEMP:PART1:SP": -1, "RE:HE3POT:TEMP:PART2:SP": -1 +} + class HLX503Tests(unittest.TestCase): """ @@ -101,6 +106,10 @@ def reset_any_changes_from_macros(self): for pv, macro in pv_to_macros_map.items(): self.ca.set_pv_value(pv, IOCS[0]["macros"][macro]) + def set_unattainable_recondense_conditions(self): + for pv, value in UNATTAINABLE_RECONDENSE_VALUES.items(): + self.ca.set_pv_value(pv, value) + @parameterized.expand(parameterized_list(["Auto", "Manual"])) def test_WHEN_set_autoheat_THEN_autoheat_set(self, _, value): self.ca.assert_setting_setpoint_sets_readback(value, "MODE:HTR") @@ -254,6 +263,7 @@ def test_WHEN_cancelled_in_any_step_THEN_temp_not_set_AND_cancelled(self, _, par self.ca.set_pv_value("TEMP:HE3POT:SP", original_temp_sp) post_recondense_temp_sp = 0.3 self.ca.assert_setting_setpoint_sets_readback(post_recondense_temp_sp, "RE:TEMP") + self.set_unattainable_recondense_conditions() # Start recondensing and skip steps self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") for i in range(parts_skipped): @@ -265,6 +275,7 @@ def test_WHEN_cancelled_in_any_step_THEN_temp_not_set_AND_cancelled(self, _, par self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", original_temp_sp, tolerance=0.001) def test_WHEN_in_part_1_THEN_values_set_correctly(self): + self.set_unattainable_recondense_conditions() self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") self.ca.assert_that_pv_is("RE:PART", "PART 1") self.ca.assert_that_pv_is("RE:SKIPPED", "NO") @@ -274,13 +285,16 @@ def test_WHEN_in_part_1_THEN_values_set_correctly(self): self.ca.assert_that_pv_is("MODE:HTR", "Manual") self.ca.assert_that_pv_is("CTRLCHANNEL", "SORB") self.ca.assert_that_pv_is_number("HEATERP", 0.0, tolerance=0.001) - self.ca.assert_that_pv_is_number("TEMP:SORB:SP", 33.0, tolerance=0.001) - self.ca.assert_that_pv_is_number("TEMP:SP", 33.0, tolerance=0.001) + self.ca.assert_that_pv_is_number( + "TEMP:SORB:SP", UNATTAINABLE_RECONDENSE_VALUES["RE:SORB:TEMP:SP"], tolerance=0.001 + ) + self.ca.assert_that_pv_is_number("TEMP:SP", UNATTAINABLE_RECONDENSE_VALUES["RE:SORB:TEMP:SP"], tolerance=0.001) self.ca.assert_that_pv_is_number("P", 1.2, tolerance=0.001) self.ca.assert_that_pv_is_number("I", 1.2, tolerance=0.001) self.ca.assert_that_pv_is_number("D", 1.2, tolerance=0.001) def test_WHEN_in_part_3_THEN_values_set_correctly(self): + self.set_unattainable_recondense_conditions() self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") self.ca.set_pv_value("RE:SKIPPED:SP", "YES") self.ca.set_pv_value("RE:SKIPPED:SP", "YES") @@ -402,6 +416,7 @@ def test_WHEN_timed_out_in_any_step_THEN_temp_set_AND_timed_out(self, _, parts_s self.ca.set_pv_value("TEMP:HE3POT:SP", original_temp_sp) post_recondense_temp_sp = 0.3 self.ca.assert_setting_setpoint_sets_readback(post_recondense_temp_sp, "RE:TEMP") + self.set_unattainable_recondense_conditions() # Start recondensing and skip steps self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") for i in range(parts_skipped): @@ -420,6 +435,7 @@ def test_WHEN_time_out_off_in_any_step_AND_wait_AND_cancel_THEN_temp_not_set_AND self.ca.set_pv_value("TEMP:HE3POT:SP", original_temp_sp) post_recondense_temp_sp = 0.3 self.ca.assert_setting_setpoint_sets_readback(post_recondense_temp_sp, "RE:TEMP") + self.set_unattainable_recondense_conditions() # Start recondensing and skip steps self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") for i in range(parts_skipped): @@ -433,8 +449,12 @@ def test_WHEN_time_out_off_in_any_step_AND_wait_AND_cancel_THEN_temp_not_set_AND # Assert that temperature setpoint is set self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", original_temp_sp, tolerance=0.001) + @parameterized.expand(parameterized_list([ + # Set targets that aren't reasonable to test different paths + {}, {"RE:SORB:TEMP:SP": 10000}, {"RE:HE3POT:TEMP:PART1:SP": -1}, {"RE:HE3POT:TEMP:PART2:SP": -1} + ])) @skip_if_recsim("Backdoor not available in recsim") - def test_WHEN_recondense_THEN_recondense(self): + def test_WHEN_recondense_THEN_recondense(self, _, pv_sets): # Set requirement for recondense self._lewis.backdoor_set_on_device("helium_3_pot_empty", True) # Set temp values @@ -444,23 +464,28 @@ def test_WHEN_recondense_THEN_recondense(self): self.ca.assert_setting_setpoint_sets_readback(post_recondense_temp_sp, "RE:TEMP") # Set state for recondense self.ca.set_pv_value("RE:PART2:WAIT_TIME", 1) + for pv, set_point in pv_sets.items(): + self.ca.set_pv_value(pv, set_point) # Initiate recondense self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") # Wait for recondense to finish - self.ca.assert_that_pv_is("RE:PART", "PART 1", timeout=3) - self.ca.assert_that_pv_is("RE:PART", "PART 2", timeout=3) - self.ca.assert_that_pv_is("RE:PART", "PART 3", timeout=3) - self.ca.assert_that_pv_is("RECONDENSING", "NO", timeout=3) + self.ca.assert_that_pv_is("RE:PART", "PART 1", timeout=10) + self.ca.assert_that_pv_is("RE:PART", "PART 2", timeout=10) + self.ca.assert_that_pv_is("RE:PART", "PART 3", timeout=10) + self.ca.assert_that_pv_is("RE:PART", "FINISHING", timeout=10) self._lewis.backdoor_set_on_device("helium_3_pot_empty", False) - # Assert post condense status + self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", post_recondense_temp_sp, tolerance=0.001) + self.ca.assert_that_pv_is_number("TEMP:HE3POT", post_recondense_temp_sp, tolerance=0.001) self.ca.assert_that_pv_is("RE:SUCCESS", "YES") + self.ca.assert_that_pv_is("RECONDENSING", "NO", timeout=10) + # Assert post condense status self.ca.assert_that_pv_is("RE:CANCELLED", "NO") self.ca.assert_that_pv_is("RE:TIMED_OUT", "NO") self.ca.assert_that_pv_is("RE:SKIPPED", "NO") self.ca.assert_that_pv_is("RE:PART", "NOT RECONDENSING") - # Assert post condense setpoint set - self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", post_recondense_temp_sp, tolerance=0.001) - self.ca.assert_that_pv_is_number("TEMP:HE3POT", post_recondense_temp_sp, tolerance=0.001) + + + From 93621b41ba46720aba2bb886a456ee17da0b8aab Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Fri, 26 Mar 2021 15:36:08 +0000 Subject: [PATCH 23/28] hlx503: Remove unused imports, use common unattainable recondense values --- tests/hlx503.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index 62a0c0a3e..9324c34d3 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -6,9 +6,6 @@ from utils.channel_access import ChannelAccess from utils.ioc_launcher import get_default_ioc_dir, IOCRegister from utils.testing import get_running_lewis_and_ioc, parameterized_list, skip_if_recsim -from genie_python.utilities import dehex_and_decompress - -from itertools import product # Device prefix DEVICE_PREFIX = "HLX503_01" @@ -451,7 +448,9 @@ def test_WHEN_time_out_off_in_any_step_AND_wait_AND_cancel_THEN_temp_not_set_AND @parameterized.expand(parameterized_list([ # Set targets that aren't reasonable to test different paths - {}, {"RE:SORB:TEMP:SP": 10000}, {"RE:HE3POT:TEMP:PART1:SP": -1}, {"RE:HE3POT:TEMP:PART2:SP": -1} + {}, {"RE:SORB:TEMP:SP": UNATTAINABLE_RECONDENSE_VALUES["RE:SORB:TEMP:SP"]}, + {"RE:HE3POT:TEMP:PART1:SP": UNATTAINABLE_RECONDENSE_VALUES["RE:HE3POT:TEMP:PART1:SP"]}, + {"RE:HE3POT:TEMP:PART2:SP": UNATTAINABLE_RECONDENSE_VALUES["RE:HE3POT:TEMP:PART2:SP"]} ])) @skip_if_recsim("Backdoor not available in recsim") def test_WHEN_recondense_THEN_recondense(self, _, pv_sets): @@ -472,12 +471,11 @@ def test_WHEN_recondense_THEN_recondense(self, _, pv_sets): self.ca.assert_that_pv_is("RE:PART", "PART 1", timeout=10) self.ca.assert_that_pv_is("RE:PART", "PART 2", timeout=10) self.ca.assert_that_pv_is("RE:PART", "PART 3", timeout=10) - self.ca.assert_that_pv_is("RE:PART", "FINISHING", timeout=10) + self.ca.assert_that_pv_is("RECONDENSING", "NO", timeout=10) + self.ca.assert_that_pv_is("RE:SUCCESS", "YES") self._lewis.backdoor_set_on_device("helium_3_pot_empty", False) self.ca.assert_that_pv_is_number("TEMP:HE3POT:SP", post_recondense_temp_sp, tolerance=0.001) self.ca.assert_that_pv_is_number("TEMP:HE3POT", post_recondense_temp_sp, tolerance=0.001) - self.ca.assert_that_pv_is("RE:SUCCESS", "YES") - self.ca.assert_that_pv_is("RECONDENSING", "NO", timeout=10) # Assert post condense status self.ca.assert_that_pv_is("RE:CANCELLED", "NO") self.ca.assert_that_pv_is("RE:TIMED_OUT", "NO") From ebfe73fbd79a10e52f5a5936920f5462dfd8f9e2 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Fri, 26 Mar 2021 15:48:09 +0000 Subject: [PATCH 24/28] hlx503: Add back required imports --- tests/hlx503.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/hlx503.py b/tests/hlx503.py index 9324c34d3..d3bf4c3b4 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -1,6 +1,9 @@ import unittest from parameterized import parameterized +from itertools import product + +from genie_python.utilities import dehex_and_decompress from utils.test_modes import TestModes from utils.channel_access import ChannelAccess From 222f9f17b469359906ff16814f4ac793be0900bd Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Fri, 26 Mar 2021 16:17:12 +0000 Subject: [PATCH 25/28] hlx503: Reset correct PV, set unattainable recondense conditions for a skipping test --- tests/hlx503.py | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index d3bf4c3b4..eab7ed074 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -56,7 +56,7 @@ "RE:HE3POT:TEMP:PART1:SP": "RECONDENSE_HE3POT_TARGET_TEMP_PART1", "RE:HE3POT:TEMP:PART2:SP": "RECONDENSE_HE3POT_TARGET_TEMP_PART1", "RE:PART2:WAIT_TIME:SP": "RECONDENSE_POST_PART2_WAIT_TIME", - "MAX_TEMP_FOR_HE3_COOLING": "MAX_TEMP_FOR_HE3_COOLING", + "MAX_TEMP_FOR_HE3_COOLING:SP": "MAX_TEMP_FOR_HE3_COOLING", "RE:TIMEOUT:SP": "RECONDENSE_PART_TIMEOUT", "RE:TIMEOUT:ON:SP": "RECONDENSE_PART_TIMEOUT_ON" } @@ -245,6 +245,7 @@ def test_WHEN_recondense_started_THEN_condensing_is_started_WHEN_steps_skipped_T self.ca.set_pv_value("TEMP:HE3POT:SP", 0.1) post_recondense_temp_sp = 0.3 self.ca.assert_setting_setpoint_sets_readback(post_recondense_temp_sp, "RE:TEMP") + self.set_unattainable_recondense_conditions() # Start recondensing and skip steps self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") self.ca.assert_that_pv_is("RE:PART", "PART 1") @@ -485,9 +486,3 @@ def test_WHEN_recondense_THEN_recondense(self, _, pv_sets): self.ca.assert_that_pv_is("RE:SKIPPED", "NO") self.ca.assert_that_pv_is("RE:PART", "NOT RECONDENSING") - - - - - - From 43b192b4121290d72bf7ce8351ca8c081c6191cc Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Fri, 26 Mar 2021 16:58:50 +0000 Subject: [PATCH 26/28] hlx503: Add test to check PID settings reapplied post-condense --- tests/hlx503.py | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/tests/hlx503.py b/tests/hlx503.py index eab7ed074..996e0d91c 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -486,3 +486,45 @@ def test_WHEN_recondense_THEN_recondense(self, _, pv_sets): self.ca.assert_that_pv_is("RE:SKIPPED", "NO") self.ca.assert_that_pv_is("RE:PART", "NOT RECONDENSING") + def test_WHEN_recondense_THEN_after_recondense_pid_settings_are_restored(self): + self.set_unattainable_recondense_conditions() + # Set up old values + old_autopid_value = "ON" + self.ca.set_pv_value("AUTOPID", old_autopid_value) + old_adjust_pid_value = "YES" + self.ca.set_pv_value("ADJUST_PIDS:SP", old_adjust_pid_value) + old_pid_values = 1.0 + for pid in ["P", "I", "D"]: + self.ca.set_pv_value(f"{pid}:SP", old_pid_values) + # Set up expected in-recondense values + new_pid_values = 1.8 + for pid in ["P", "I", "D"]: + self.ca.set_pv_value(f"RE:SORB:{pid}:SP", new_pid_values) + new_autopid_value = "OFF" + new_adjust_pid_value = "NO" + # Commence recondense + self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") + # Assert Old PIDS stored + for pid in ["P", "I", "D"]: + self.ca.assert_that_pv_is(f"RE:_OLD_{pid}", old_pid_values) + self.ca.assert_that_pv_is("RE:_OLD_ADJUST_PIDS", old_adjust_pid_value) + self.ca.assert_that_pv_is("RE:_OLD_AUTOPID", old_autopid_value) + # Assert PIDs set + for pid in ["P", "I", "D"]: + self.ca.assert_that_pv_is(f"{pid}", new_pid_values) + self.ca.assert_that_pv_is("ADJUST_PIDS", new_adjust_pid_value) + self.ca.assert_that_pv_is("AUTOPID", new_autopid_value) + # Skip parts + for i in range(3): + self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + # Assert recondense finished + self.ca.assert_setting_setpoint_sets_readback("NO", "RECONDENSING", timeout=10) + # Assert PID settings reapplied + for pid in ["P", "I", "D"]: + self.ca.assert_that_pv_is(f"{pid}", old_pid_values) + self.ca.assert_that_pv_is("ADJUST_PIDS", old_adjust_pid_value) + self.ca.assert_that_pv_is("AUTOPID", old_autopid_value) + + + + From 6dc6d42680d3a1ea8f218a41ff7eb85df33ddba3 Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Fri, 26 Mar 2021 18:17:05 +0000 Subject: [PATCH 27/28] hlx503: Refactor tests to improve readability --- tests/hlx503.py | 134 ++++++++++++++++++++++++------------------------ 1 file changed, 67 insertions(+), 67 deletions(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index 996e0d91c..ea9ce04a8 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -74,6 +74,10 @@ "RE:HE3POT:TEMP:PART1:SP": -1, "RE:HE3POT:TEMP:PART2:SP": -1 } +PID_TEST_VALUES = [0.2, 3.8] + +CONTROL_CHANNELS = ["SORB", "HE3POTHI", "1KPOTHE3POTLO"] + class HLX503Tests(unittest.TestCase): """ @@ -130,20 +134,20 @@ def test_WHEN_temp_set_THEN_temp_sp_rbv_correct(self, _, val): self.ca.set_pv_value("TEMP:SP", val) self.ca.assert_that_pv_is_number("TEMP:SP:RBV", val, tolerance=0.1) - @parameterized.expand(parameterized_list(["SORB", "HE3POTHI", "1KPOTHE3POTLO"])) + @parameterized.expand(parameterized_list(CONTROL_CHANNELS)) @skip_if_recsim("Comes back via record redirection which recsim can't handle easily") def test_WHEN_ctrlchannel_set_THEN_ctrlchannel_set(self, _, new_control_channel): self.ca.assert_setting_setpoint_sets_readback(new_control_channel, "CTRLCHANNEL") - @parameterized.expand(parameterized_list([0.2, 3.8])) + @parameterized.expand(parameterized_list(PID_TEST_VALUES)) def test_WHEN_proportional_set_THEN_proportional_set(self, _, proportional): self.ca.assert_setting_setpoint_sets_readback(proportional, "P") - @parameterized.expand(parameterized_list([0.2, 3.8])) + @parameterized.expand(parameterized_list(PID_TEST_VALUES)) def test_WHEN_integral_set_THEN_integral_set(self, _, integral): self.ca.assert_setting_setpoint_sets_readback(integral, "I") - @parameterized.expand(parameterized_list([0.2, 3.8])) + @parameterized.expand(parameterized_list(PID_TEST_VALUES)) def test_WHEN_derivative_set_THEN_derivative_set(self, _, derivative): self.ca.assert_setting_setpoint_sets_readback(derivative, "D") @@ -267,9 +271,7 @@ def test_WHEN_cancelled_in_any_step_THEN_temp_not_set_AND_cancelled(self, _, par self.set_unattainable_recondense_conditions() # Start recondensing and skip steps self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") - for i in range(parts_skipped): - self.ca.assert_that_pv_is("RE:PART", f"PART {i+1}") - self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + self.skip_parts(parts_skipped) self.ca.assert_setting_setpoint_sets_readback("YES", "RE:CANCELLED") self.ca.assert_that_pv_is("RE:PART", "NOT RECONDENSING") # Assert that temperature setpoint is set @@ -290,15 +292,14 @@ def test_WHEN_in_part_1_THEN_values_set_correctly(self): "TEMP:SORB:SP", UNATTAINABLE_RECONDENSE_VALUES["RE:SORB:TEMP:SP"], tolerance=0.001 ) self.ca.assert_that_pv_is_number("TEMP:SP", UNATTAINABLE_RECONDENSE_VALUES["RE:SORB:TEMP:SP"], tolerance=0.001) - self.ca.assert_that_pv_is_number("P", 1.2, tolerance=0.001) - self.ca.assert_that_pv_is_number("I", 1.2, tolerance=0.001) - self.ca.assert_that_pv_is_number("D", 1.2, tolerance=0.001) + self.ca.assert_that_pv_is_number("P", IOCS[0]["macros"]["RECONDENSE_SORB_P"], tolerance=0.001) + self.ca.assert_that_pv_is_number("I", IOCS[0]["macros"]["RECONDENSE_SORB_I"], tolerance=0.001) + self.ca.assert_that_pv_is_number("D", IOCS[0]["macros"]["RECONDENSE_SORB_D"], tolerance=0.001) def test_WHEN_in_part_3_THEN_values_set_correctly(self): self.set_unattainable_recondense_conditions() self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") - self.ca.set_pv_value("RE:SKIPPED:SP", "YES") - self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + self.skip_parts(2) self.ca.assert_that_pv_is("RE:PART", "PART 3") self.ca.assert_that_pv_is("RE:SKIPPED", "NO") self.ca.assert_that_pv_is("RE:CANCELLED", "NO") @@ -308,9 +309,9 @@ def test_WHEN_in_part_3_THEN_values_set_correctly(self): self.ca.assert_that_pv_is_number("HEATERP", 0.0, tolerance=0.001) self.ca.assert_that_pv_is_number("TEMP:SORB:SP", 0.0, tolerance=0.001) self.ca.assert_that_pv_is_number("TEMP:SP", 0.0, tolerance=0.001) - self.ca.assert_that_pv_is_number("P", 1.2, tolerance=0.001) - self.ca.assert_that_pv_is_number("I", 1.2, tolerance=0.001) - self.ca.assert_that_pv_is_number("D", 1.2, tolerance=0.001) + self.ca.assert_that_pv_is_number("P", IOCS[0]["macros"]["RECONDENSE_SORB_P"], tolerance=0.001) + self.ca.assert_that_pv_is_number("I", IOCS[0]["macros"]["RECONDENSE_SORB_I"], tolerance=0.001) + self.ca.assert_that_pv_is_number("D", IOCS[0]["macros"]["RECONDENSE_SORB_D"], tolerance=0.001) self.ca.assert_that_pv_is("CTRLCHANNEL", "SORB") @parameterized.expand(parameterized_list([0.5, 1.2])) @@ -332,11 +333,6 @@ def test_WHEN_set_post_recondense_temp_AND_setpoint_is_greater_than_max_heliox_o self.ca.assert_setting_setpoint_sets_readback(temp, "RE:TEMP", expected_value=0.3, expected_alarm=self.ca.Alarms.MAJOR) self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MAJOR) - @parameterized.expand(parameterized_list([0.5, 1.2])) - @skip_if_recsim("Comes back via record redirection which recsim can't handle easily") - def test_WHEN_forward_post_condense_temp_setpoint_THEN_temp_set(self, _, temp): - self.ca.assert_setting_setpoint_sets_readback(temp, "RE:TEMP") - @parameterized.expand(parameterized_list([12.0, 15.0])) def test_WHEN_set_final_recondense_sorb_temp_THEN_final_recondense_sorb_temp_set(self, _, temp): self.ca.assert_setting_setpoint_sets_readback(temp, "RE:SORB:TEMP:FIN") @@ -345,7 +341,7 @@ def test_WHEN_set_final_recondense_sorb_temp_THEN_final_recondense_sorb_temp_set def test_WHEN_set_recondense_sorb_temp_set_THEN_recondense_sorb_temp_set_set(self, _, temp): self.ca.assert_setting_setpoint_sets_readback(temp, "RE:SORB:TEMP") - @parameterized.expand(parameterized_list(product(["P", "I", "D"], [0.8, 3.4]))) + @parameterized.expand(parameterized_list(product(["P", "I", "D"], PID_TEST_VALUES))) def test_WHEN_set_recondense_sorb_pids_THEN_recondense_sorb_pids_set(self, _, p_or_i_or_d, val): self.ca.assert_setting_setpoint_sets_readback(val, f"RE:SORB:{p_or_i_or_d}") @@ -372,16 +368,19 @@ def test_WHEN_set_max_temp_he3_cooling_THEN_correct_control_channel_used( self.ca.set_pv_value("TEMP:HE3POT:SP", temp) self.ca.assert_that_pv_is("CTRLCHANNEL", new_expected_ctrl_channel) - @parameterized.expand(parameterized_list([(1.4, False), (3.2, True)])) - def test_WHEN_set_max_temp_he3_cooling_THEN_high_value_set_on_recondense_temp_sp_AND_alarms_correct( - self, _, max_temp_for_he3_cooling, alarm_expected): - self.ca.set_pv_value("RE:TEMP:SP", max_temp_for_he3_cooling + 0.1) - if alarm_expected: + def assert_recondense_temp_alarm_is(self, minor: bool): + if minor: self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MINOR) self.ca.assert_that_pv_alarm_is("RE:TEMP", self.ca.Alarms.MINOR) else: self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.NONE) self.ca.assert_that_pv_alarm_is("RE:TEMP", self.ca.Alarms.NONE) + + @parameterized.expand(parameterized_list([(1.4, False), (3.2, True)])) + def test_WHEN_set_max_temp_he3_cooling_THEN_high_value_set_on_recondense_temp_sp_AND_alarms_correct( + self, _, max_temp_for_he3_cooling, alarm_expected): + self.ca.set_pv_value("RE:TEMP:SP", max_temp_for_he3_cooling + 0.1) + self.assert_recondense_temp_alarm_is(alarm_expected) self.ca.assert_setting_setpoint_sets_readback(max_temp_for_he3_cooling, "MAX_TEMP_FOR_HE3_COOLING") self.ca.assert_that_pv_is("RE:TEMP:SP.HIGH", max_temp_for_he3_cooling) self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MINOR) @@ -391,12 +390,7 @@ def test_WHEN_set_max_temp_he3_cooling_THEN_high_value_set_on_recondense_temp_sp def test_WHEN_set_max_temp_he3_cooling_THEN_low_value_set_on_recondense_temp_sp_AND_alarms_correct( self, _, max_temp_for_he3_cooling, alarm_expected): self.ca.set_pv_value("RE:TEMP:SP", max_temp_for_he3_cooling - 0.1) - if alarm_expected: - self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.MINOR) - self.ca.assert_that_pv_alarm_is("RE:TEMP", self.ca.Alarms.MINOR) - else: - self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.NONE) - self.ca.assert_that_pv_alarm_is("RE:TEMP", self.ca.Alarms.NONE) + self.assert_recondense_temp_alarm_is(alarm_expected) self.ca.assert_setting_setpoint_sets_readback(max_temp_for_he3_cooling, "MAX_TEMP_FOR_HE3_COOLING") self.ca.assert_that_pv_is("RE:TEMP:SP.HIGH", max_temp_for_he3_cooling) self.ca.assert_that_pv_alarm_is("RE:TEMP:SP", self.ca.Alarms.NONE) @@ -410,6 +404,12 @@ def test_WHEN_set_timeout_on_or_off_THEN_timeout_on_or_off_set(self, _, on_or_of def test_WHEN_set_timeout_THEN_timeout_set(self, _, timeout): self.ca.assert_setting_setpoint_sets_readback(timeout, "RE:TIMEOUT") + def skip_parts(self, number_of_parts_to_skip: int, part_offset: int = 0, assert_parts=True): + for i in range(number_of_parts_to_skip): + if assert_parts: + self.ca.assert_that_pv_is("RE:PART", f"PART {i+1+part_offset}") + self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + @parameterized.expand(parameterized_list([0, 1, 2])) def test_WHEN_timed_out_in_any_step_THEN_temp_set_AND_timed_out(self, _, parts_skipped): # Set temp values @@ -420,9 +420,7 @@ def test_WHEN_timed_out_in_any_step_THEN_temp_set_AND_timed_out(self, _, parts_s self.set_unattainable_recondense_conditions() # Start recondensing and skip steps self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") - for i in range(parts_skipped): - self.ca.assert_that_pv_is("RE:PART", f"PART {i+1}") - self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + self.skip_parts(parts_skipped) self.ca.assert_setting_setpoint_sets_readback(1, "RE:TIMEOUT") self.ca.assert_that_pv_is("RE:TIMED_OUT", "YES", timeout=3) self.ca.assert_that_pv_is("RE:PART", "NOT RECONDENSING") @@ -439,9 +437,7 @@ def test_WHEN_time_out_off_in_any_step_AND_wait_AND_cancel_THEN_temp_not_set_AND self.set_unattainable_recondense_conditions() # Start recondensing and skip steps self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") - for i in range(parts_skipped): - self.ca.assert_that_pv_is("RE:PART", f"PART {i+1}") - self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + self.skip_parts(parts_skipped) self.ca.assert_setting_setpoint_sets_readback("NO", "RE:TIMEOUT:ON") self.ca.set_pv_value("RE:TIMEOUT:SP", 1, sleep_after_set=2) self.ca.assert_that_pv_is("RE:TIMED_OUT", "NO", timeout=3) @@ -486,45 +482,49 @@ def test_WHEN_recondense_THEN_recondense(self, _, pv_sets): self.ca.assert_that_pv_is("RE:SKIPPED", "NO") self.ca.assert_that_pv_is("RE:PART", "NOT RECONDENSING") + def assert_pid_values(self, pid_value: float, pv_prefix: str = "", pv_suffix: str = "", timeouts: int = None): + for pid in ["P", "I", "D"]: + self.ca.assert_that_pv_is_number( + f"{pv_prefix}{pid}{pv_suffix}", pid_value, timeout=timeouts, tolerance=0.0001 + ) + + def assert_pid_settings(self, adjust_pids: str, autopid: str, pid_value: float, + pv_prefix: str = "", pv_suffix: str = "", timeouts: int = None): + self.ca.assert_that_pv_is(f"{pv_prefix}ADJUST_PIDS{pv_suffix}", adjust_pids, timeout=timeouts) + self.ca.assert_that_pv_is(f"{pv_prefix}AUTOPID{pv_suffix}", autopid, timeout=timeouts) + self.assert_pid_values(pid_value, pv_prefix, pv_suffix, timeouts) + + def set_pid_values(self, pid_value: float, pv_prefix: str = ""): + for pid in ["P", "I", "D"]: + self.ca.set_pv_value(f"{pv_prefix}{pid}:SP", pid_value) + + def set_pid_settings(self, adjust_pids: str, autopid: str, pid_value: float): + self.ca.set_pv_value("AUTOPID:SP", autopid) + self.ca.set_pv_value("ADJUST_PIDS:SP", adjust_pids) + self.set_pid_values(pid_value) + + def test_WHEN_recondense_THEN_after_recondense_pid_settings_are_restored(self): self.set_unattainable_recondense_conditions() # Set up old values old_autopid_value = "ON" - self.ca.set_pv_value("AUTOPID", old_autopid_value) old_adjust_pid_value = "YES" - self.ca.set_pv_value("ADJUST_PIDS:SP", old_adjust_pid_value) - old_pid_values = 1.0 - for pid in ["P", "I", "D"]: - self.ca.set_pv_value(f"{pid}:SP", old_pid_values) + old_pid_values = 0.0 + self.set_pid_settings(old_adjust_pid_value, old_autopid_value, old_pid_values) # Set up expected in-recondense values new_pid_values = 1.8 - for pid in ["P", "I", "D"]: - self.ca.set_pv_value(f"RE:SORB:{pid}:SP", new_pid_values) + self.set_pid_values(new_pid_values, pv_prefix="RE:SORB:") new_autopid_value = "OFF" new_adjust_pid_value = "NO" # Commence recondense self.ca.assert_setting_setpoint_sets_readback("YES", "RECONDENSING") - # Assert Old PIDS stored - for pid in ["P", "I", "D"]: - self.ca.assert_that_pv_is(f"RE:_OLD_{pid}", old_pid_values) - self.ca.assert_that_pv_is("RE:_OLD_ADJUST_PIDS", old_adjust_pid_value) - self.ca.assert_that_pv_is("RE:_OLD_AUTOPID", old_autopid_value) - # Assert PIDs set - for pid in ["P", "I", "D"]: - self.ca.assert_that_pv_is(f"{pid}", new_pid_values) - self.ca.assert_that_pv_is("ADJUST_PIDS", new_adjust_pid_value) - self.ca.assert_that_pv_is("AUTOPID", new_autopid_value) - # Skip parts - for i in range(3): - self.ca.set_pv_value("RE:SKIPPED:SP", "YES") + # Assert Old PID settings stored and new PID settings set + self.assert_pid_settings( + old_adjust_pid_value, old_autopid_value, old_pid_values, pv_prefix="RE:_OLD_", timeouts=2 + ) + self.assert_pid_settings(new_adjust_pid_value, new_autopid_value, new_pid_values) + self.skip_parts(3, assert_parts=False) # Assert recondense finished self.ca.assert_setting_setpoint_sets_readback("NO", "RECONDENSING", timeout=10) - # Assert PID settings reapplied - for pid in ["P", "I", "D"]: - self.ca.assert_that_pv_is(f"{pid}", old_pid_values) - self.ca.assert_that_pv_is("ADJUST_PIDS", old_adjust_pid_value) - self.ca.assert_that_pv_is("AUTOPID", old_autopid_value) - - - - + # Assert old PID settings reapplied + self.assert_pid_settings(old_adjust_pid_value, old_autopid_value, old_pid_values) From f22b02f8d820f25f9c2f11bacd077c14e580c99b Mon Sep 17 00:00:00 2001 From: JamesKingWork Date: Fri, 26 Mar 2021 18:49:04 +0000 Subject: [PATCH 28/28] hlx503: Parameterize tests to try multiple cases --- tests/hlx503.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/tests/hlx503.py b/tests/hlx503.py index ea9ce04a8..dd7249793 100644 --- a/tests/hlx503.py +++ b/tests/hlx503.py @@ -492,7 +492,8 @@ def assert_pid_settings(self, adjust_pids: str, autopid: str, pid_value: float, pv_prefix: str = "", pv_suffix: str = "", timeouts: int = None): self.ca.assert_that_pv_is(f"{pv_prefix}ADJUST_PIDS{pv_suffix}", adjust_pids, timeout=timeouts) self.ca.assert_that_pv_is(f"{pv_prefix}AUTOPID{pv_suffix}", autopid, timeout=timeouts) - self.assert_pid_values(pid_value, pv_prefix, pv_suffix, timeouts) + if pid_value is not None: + self.assert_pid_values(pid_value, pv_prefix, pv_suffix, timeouts) def set_pid_values(self, pid_value: float, pv_prefix: str = ""): for pid in ["P", "I", "D"]: @@ -501,15 +502,13 @@ def set_pid_values(self, pid_value: float, pv_prefix: str = ""): def set_pid_settings(self, adjust_pids: str, autopid: str, pid_value: float): self.ca.set_pv_value("AUTOPID:SP", autopid) self.ca.set_pv_value("ADJUST_PIDS:SP", adjust_pids) - self.set_pid_values(pid_value) + if pid_value is not None: + self.set_pid_values(pid_value) - - def test_WHEN_recondense_THEN_after_recondense_pid_settings_are_restored(self): + @parameterized.expand(parameterized_list([("OFF", "NO", 0.0), ("ON", "NO", 0.0), ("OFF", "YES", None), ("OFF", "YES", None)])) + def test_WHEN_recondense_THEN_after_recondense_pid_settings_are_restored(self, _, old_autopid_value, old_adjust_pid_value, old_pid_values): self.set_unattainable_recondense_conditions() # Set up old values - old_autopid_value = "ON" - old_adjust_pid_value = "YES" - old_pid_values = 0.0 self.set_pid_settings(old_adjust_pid_value, old_autopid_value, old_pid_values) # Set up expected in-recondense values new_pid_values = 1.8