Updates to meet test plan

rbultman · rbultman · commit da224492e757 · 2024-05-06T18:58:54.000-04:00
diff --git a/src/app/tests/suites/certification/Test_TC_MWOCTRL_2_1.yaml b/src/app/tests/suites/certification/Test_TC_MWOCTRL_2_1.yaml
diff --git a/src/python_testing/TC_MWOCTRL_2_1.py b/src/python_testing/TC_MWOCTRL_2_1.py
@@ -0,0 +1,137 @@
+#
+#    Copyright (c) 2024 Project CHIP Authors
+#    All rights reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+import logging
+
+import chip.clusters as Clusters
+from chip.interaction_model import InteractionModelError, Status
+from matter_testing_support import MatterBaseTest, TestStep, async_test_body, default_matter_test_main
+from mobly import asserts
+
+# This test requires several additional command line arguments
+# run with
+# --endpoint endpoint
+
+
+class TC_MWOCTRL_2_1(MatterBaseTest):
+
+    async def read_mwoctrl_attribute_expect_success(self, endpoint, attribute):
+        cluster = Clusters.Objects.MicrowaveOvenControl
+        return await self.read_single_attribute_check_success(endpoint=endpoint, cluster=cluster, attribute=attribute)
+
+    async def set_cook_time_expect_success(self, endpoint, value):
+        commands = Clusters.Objects.MicrowaveOvenControl.Commands
+        try:
+            await self.send_single_cmd(cmd=commands.SetCookingParameters(cookTime=value), endpoint=endpoint)
+        except InteractionModelError as e:
+            asserts.assert_equal(e.status, Status.Success, "Unexpected error returned")
+
+    async def set_bad_cook_time_value_expect_failure(self, endpoint, value):
+        commands = Clusters.Objects.MicrowaveOvenControl.Commands
+        try:
+            await self.send_single_cmd(cmd=Clusters.Objects.MicrowaveOvenControl.Commands.SetCookingParameters(cookTime=value), endpoint=endpoint)
+            asserts.assert_fail("Expected an exception but received none.")
+        except InteractionModelError as e:
+            asserts.assert_equal(e.status, Status.ConstraintError, "Expected a CONSTRAINT_ERROR but got a different response.")
+
+    async def read_and_check_cook_time_value(self, endpoint, value):
+        attributes = Clusters.MicrowaveOvenControl.Attributes
+        cooktime = await self.read_mwoctrl_attribute_expect_success(endpoint=endpoint, attribute=attributes.CookTime)
+        asserts.assert_equal(cooktime, value, "Cooktime value not as expected")
+
+    def desc_TC_MWOCTRL_2_1(self) -> str:
+        return "[TC-MWOCTRL-2.1] Primary functionality with DUT as Server"
+
+    def steps_TC_MWOCTRL_2_1(self) -> list[TestStep]:
+        steps = [
+            TestStep(1, "Commissioning, already done", is_commissioning=True),
+            TestStep(2, "Read the MaxCookTime attribute and check limits",
+                "Verify that the DUT response contains an elapsed-s value between 1 and 86400 inclusive. Save value as MaxCookTime."
+            ),
+            TestStep(3, "Read the CookTime attribute and check limits",
+                "Verify that the DUT response contains an elapsed-s value between 1 and MaxCookTime inclusive."
+            ),
+            TestStep(4, "Set the CookTime attribute to 60", "Verify DUT responds w/ status SUCCESS(0x00)."),
+            TestStep(5, "Read the CookTime attribute and check for 60", "Verify that the DUT response contains the CookTime value 60."),
+            TestStep(6, "Set the CookTime attribute to 1", "Verify DUT responds w/ status SUCCESS(0x00)"),
+            TestStep(7, "Read the CookTime attribute and check for 1", "Verify that the DUT response contains the CookTime value 1."),
+            TestStep(8, "Set the CookTime attribute to MaxCookTime", "Verify DUT responds w/ status SUCCESS(0x00)"),
+            TestStep(9, "Read the CookTime attribute and check for MaxCookTime", "Verify that the DUT response contains the CookTime value MaxCookTime."),
+            TestStep(10, "Read the WattRating attribute, if supported", "Verify that the DUT response contains a uint16 value."),
+            TestStep(11, "Set the CookTime attribute to 0", "Verify DUT responds w/ status CONSTRAINT_ERROR(0x87)"),
+            TestStep(12, "Set the CookTime attribute to MaxCookTime+1", "Verify DUT responds w/ status CONSTRAINT_ERROR(0x87)"),
+        ]
+        return steps
+
+    def pics_TC_MWOCTRL_2_1(self) -> list[str]:
+        pics = [
+            "MWOCTRL.S",
+        ]
+        return pics
+
+    @async_test_body
+    async def test_TC_MWOCTRL_2_1(self):
+
+        endpoint = self.user_params.get("endpoint", 1)
+
+        self.step(1)
+        attributes = Clusters.MicrowaveOvenControl.Attributes
+        features = Clusters.MicrowaveOvenControl.Bitmaps.Feature
+        commands = Clusters.Objects.MicrowaveOvenControl.Commands
+
+        self.step(2)
+        maxCookTime = await self.read_mwoctrl_attribute_expect_success(endpoint=endpoint, attribute=attributes.MaxCookTime)
+        asserts.assert_greater_equal(maxCookTime, 1, "maxCookTime is less than 1")
+        asserts.assert_less_equal(maxCookTime, 86400, "maxCookTime is greater than 86400")
+
+        self.step(3)
+        cookTime = await self.read_mwoctrl_attribute_expect_success(endpoint=endpoint, attribute=attributes.CookTime)
+        asserts.assert_greater_equal(cookTime, 1, "cookTime is less than 1")
+        asserts.assert_less_equal(cookTime, maxCookTime, "cookTime is greater than maxCookTime")
+
+        self.step(4)
+        newCookTime = 60
+        await self.set_cook_time_expect_success(endpoint, newCookTime)
+
+        self.step(5)
+        await self.read_and_check_cook_time_value(endpoint, newCookTime)
+
+        self.step(6)
+        await self.set_cook_time_expect_success(endpoint, 1)
+
+        self.step(7)
+        await self.read_and_check_cook_time_value(endpoint, 1)
+
+        self.step(8)
+        await self.set_cook_time_expect_success(endpoint, maxCookTime)
+
+        self.step(9)
+        await self.read_and_check_cook_time_value(endpoint, maxCookTime)
+
+        self.step(10)
+        if self.pics_guard(self.check_pics("MWOCTRL.S.F01")):
+            await self.read_mwoctrl_attribute_expect_success(endpoint=endpoint, attribute=attributes.WattRating)
+
+        self.step(11)
+        await self.set_bad_cook_time_value_expect_failure(endpoint, 0)
+
+        self.step(12)
+        await self.set_bad_cook_time_value_expect_failure(endpoint, maxCookTime+1)
+
+
+if __name__ == "__main__":
+    default_matter_test_main()
diff --git a/src/python_testing/TC_MWOCTRL_2_2.py b/src/python_testing/TC_MWOCTRL_2_2.py
@@ -33,6 +33,23 @@ async def read_mwoctrl_attribute_expect_success(self, endpoint, attribute):
         cluster = Clusters.Objects.MicrowaveOvenControl
         return await self.read_single_attribute_check_success(endpoint=endpoint, cluster=cluster, attribute=attribute)
 
+    async def set_power_setting_expect_success(self, endpoint, value):
+        try:
+            await self.send_single_cmd(cmd=Clusters.Objects.MicrowaveOvenControl.Commands.SetCookingParameters(powerSetting=value), endpoint=endpoint)
+        except InteractionModelError as e:
+            asserts.assert_equal(e.status, Status.Success, "Error while trying to set the power setting.")
+
+    async def set_power_setting_expect_failure(self, endpoint, value):
+        try:
+            await self.send_single_cmd(cmd=Clusters.Objects.MicrowaveOvenControl.Commands.SetCookingParameters(powerSetting=value), endpoint=endpoint)
+            asserts.assert_fail("Expected an exception but received none.")
+        except InteractionModelError as e:
+            asserts.assert_equal(e.status, Status.ConstraintError, "Expected ConstraintError but received a different response: %x", e.status)
+
+    async def read_and_check_power_setting_value(self, endpoint, value):
+        powerValue = await self.read_mwoctrl_attribute_expect_success(endpoint=endpoint, attribute=Clusters.MicrowaveOvenControl.Attributes.PowerSetting)
+        asserts.assert_equal(powerValue, value, "PowerSetting was not correctly set")
+
     def desc_TC_MWOCTRL_2_2(self) -> str:
         return "[TC-MWOCTRL-2.2] Secondary functionality with DUT as Server"
 
@@ -49,8 +66,12 @@ def steps_TC_MWOCTRL_2_2(self) -> list[TestStep]:
             TestStep(9, "Send the SetCookingParameters command"),
             TestStep(10, "Read and verify the PowerSetting attribute"),
             TestStep(11, "Set the PowerSetting attribute to the minimum value"),
-            TestStep(12, "Set the PowerSetting attribute to the maximum value"),
-            TestStep(13, "Cause constraint error response"),
+            TestStep(12, "Read and verify the PowerSetting attribute"),
+            TestStep(13, "Set the PowerSetting attribute to the maximum value"),
+            TestStep(14, "Read and verify the PowerSetting attribute"),
+            TestStep(15, "Set PowerSetting to an invalid value"),
+            TestStep(16, "If PowerStep=1, exit test case."),
+            TestStep(17, "Set PowerSetting to a value that is not an integer multiple of PowerStep"),
         ]
         return steps
 
@@ -116,34 +137,38 @@ async def test_TC_MWOCTRL_2_2(self):
 
         self.step(9)
         newPowerValue = (powerValue-minPowerValue) % (maxPowerValue-minPowerValue)+powerStepValue+minPowerValue
-        try:
-            await self.send_single_cmd(cmd=commands.SetCookingParameters(powerSetting=newPowerValue), endpoint=endpoint)
-        except InteractionModelError as e:
-            asserts.assert_equal(e.status, Status.Success, "Unexpected error returned")
+        await self.set_power_setting_expect_success(endpoint, newPowerValue)
 
         self.step(10)
-        powerValue = await self.read_mwoctrl_attribute_expect_success(endpoint=endpoint, attribute=attributes.PowerSetting)
-        asserts.assert_true(powerValue == newPowerValue, "PowerSetting was not correctly set")
+        await self.read_and_check_power_setting_value(endpoint, newPowerValue)
 
         self.step(11)
-        try:
-            await self.send_single_cmd(cmd=commands.SetCookingParameters(powerSetting=minPowerValue), endpoint=endpoint)
-        except InteractionModelError as e:
-            asserts.assert_equal(e.status, Status.Success, "Unable to set power value to minimum")
+        await self.set_power_setting_expect_success(endpoint, minPowerValue)
 
         self.step(12)
-        try:
-            await self.send_single_cmd(cmd=commands.SetCookingParameters(powerSetting=maxPowerValue), endpoint=endpoint)
-        except InteractionModelError as e:
-            asserts.assert_equal(e.status, Status.Success, "Unable to set power value to maximum")
+        await self.read_and_check_power_setting_value(endpoint, minPowerValue)
 
         self.step(13)
+        await self.set_power_setting_expect_success(endpoint, maxPowerValue)
+
+        self.step(14)
+        await self.read_and_check_power_setting_value(endpoint, maxPowerValue)
+
+        self.step(15)
         newPowerValue = maxPowerValue+1
-        try:
-            await self.send_single_cmd(cmd=commands.SetCookingParameters(powerSetting=newPowerValue), endpoint=endpoint)
-            asserts.assert_fail("Expected an exception but received none.")
-        except InteractionModelError as e:
-            asserts.assert_equal(e.status, Status.ConstraintError, "Expected ConstraintError but received a different response.")
+        await self.set_power_setting_expect_failure(endpoint, newPowerValue)
+
+        self.step(16)
+        if powerStepValue == 1:
+            self.skip_step(17)
+            return
+
+        self.step(17)
+        newPowerValue = minPowerValue + powerStepValue / 2
+        logging.info("-------> MinPower = %d", minPowerValue)
+        logging.info("-------> PowerStep = %d", powerStepValue)
+        logging.info("-------> newPowerValue = %d", newPowerValue)
+        await self.set_power_setting_expect_failure(endpoint, newPowerValue)
 
 
 if __name__ == "__main__":
