Add TC_ECOINFO_2_1.py test implementation

Author: tehampson

src/python_testing/TC_ECOINFO_2_1.py

@@ -0,0 +1,180 @@
+#
+#    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.clusters.Types import NullValue
+from chip.interaction_model import Status
+from chip.tlv import uint
+from matter_testing_support import MatterBaseTest, TestStep, async_test_body, type_matches
+from mobly import asserts
+
+
+class TC_ECOINFO_2_1(MatterBaseTest):
+
+    def steps_TC_ECOINFO_2_1(self) -> list[TestStep]:
+        steps = [TestStep(1, "Identify endpoints with Ecosystem Information Cluster", is_commissioning=True),
+                 TestStep(2, "Reading RemovedOn Attribute"),
+                 TestStep(3, "Reading DeviceDirectory Attribute"),
+                 TestStep(4, "Reading LocationDirectory Attribute"),
+                 TestStep(5, "Try Writing to RemovedOn Attribute"),
+                 TestStep(6, "Try Writing to DeviceDirectory Attribute"),
+                 TestStep(7, "Try Writing to LocationDirectory Attribute"),
+                 TestStep(8, "Repeating steps 2 to 7 for each endpoint identified in step 1")]
+        return steps
+
+    @async_test_body
+    async def test_TC_IDM_1_4(self):
+        dev_ctrl = self.default_controller
+        dut_node_id = self.dut_node_id
+
+        self.print_step(0, "Commissioning, already done")
+
+        first_cluster_validation = True
+        self.step(1)
+        endpoint_wild_card_read = await dev_ctrl.ReadAttribute(dut_node_id, [(Clusters.EcosystemInformation.Attributes.ClusterRevision)])
+        list_of_endpoints = list(endpoint_wild_card_read.keys())
+    
+        for cluster_endpoint in list_of_endpoints:
+            if first_cluster_validation:
+                self.step(2)
+            removed_on = await self.read_single_attribute(
+                dev_ctrl,
+                dut_node_id,
+                endpoint=cluster_endpoint,
+                attribute=Clusters.EcosystemInformation.Attributes.RemovedOn)
+    
+            removed_on_is_null = removed_on is NullValue
+            if not removed_on_is_null:
+                asserts.assert_true(type_matches(removed_on, uint))
+                asserts.assert_greater(removed_on, 0, "RemovedOn must be greater than 0", "RemovedOn should be a uint")
+                
+            if first_cluster_validation:
+                self.step(3)
+            device_directory = await self.read_single_attribute(
+                dev_ctrl,
+                dut_node_id,
+                endpoint=cluster_endpoint,
+                attribute=Clusters.EcosystemInformation.Attributes.DeviceDirectory,
+                fabricFiltered=False)
+    
+            num_of_devices = len(device_directory)
+            if removed_on_is_null:
+                asserts.assert_less_equal(num_of_devices, 256, "Too many device entries")
+                for device in device_directory:
+                    # TODO do fabric index check first
+                    if device.deviceName is not None:
+                        asserts.assert_true(type_matches(device.deviceName, str), "DeviceName should be a string")
+                        asserts.assert_less_equal(len(device.deviceName), 64, "DeviceName should be <= 64")
+                        asserts.assert_true(type_matches(device.deviceNameLastEdit, uint), "DeviceNameLastEdit should be a uint")
+                        asserts.assert_greater(device.deviceNameLastEdit, 0, "DeviceNameLastEdit must be greater than 0")
+                    else:
+                        asserts.assert_true(device.deviceNameLastEdit is None, "DeviceNameLastEdit should not be provided when there is no DeviceName")
+                    
+                    asserts.assert_true(type_matches(device.bridgedEndpoint, uint), "BridgedEndpoint should be a uint")
+                    asserts.assert_greater_equal(device.bridgedEndpoint, 0, "BridgedEndpoint >= 0")
+                    asserts.assert_less_equal(device.bridgedEndpoint, 0xffff_ffff, "BridgedEndpoint less than or equal to Invalid Endpoint value")
+    
+                    asserts.assert_true(type_matches(device.originalEndpoint, uint), "OriginalEndpoint should be a uint")
+                    asserts.assert_greater_equal(device.originalEndpoint, 0, "OriginalEndpoint >= 0")
+                    asserts.assert_less(device.originalEndpoint, 0xffff_ffff, "OriginalEndpoint less than or equal to Invalid Endpoint value")
+    
+                    asserts.assert_true(type_matches(device.deviceTypes, list), "DeviceTypes should be a list")
+                    asserts.assert_greater_equal(len(device.deviceTypes), 1, "DeviceTypes list must contains at least one entry")
+                    for device_type in device.deviceTypes:
+                        asserts.assert_true(type_matches(device_type.deviceType, uint), "DeviceType should be a uint")
+                        # TODO what other validation can we do here to device_type.deviceType
+                        asserts.assert_true(type_matches(device_type.revision, uint), "device type's revision should be a uint")
+                        asserts.assert_greater_equal(device_type.revision, 1, "device type's revision must >= 1")
+    
+                    asserts.assert_true(type_matches(device.uniqueLocationIDs, list), "UniqueLocationIds should be a list")
+                    num_of_unique_location_ids = len(device.uniqueLocationIDs)
+                    asserts.assert_less_equal(num_of_unique_location_ids, 64, "UniqueLocationIds list should be <= 64")
+                    for location_id in device.uniqueLocationIDs:
+                        asserts.assert_true(type_matches(location_id, str), "UniqueLocationId should be a string")
+                        location_id_string_length = len(location_id)
+                        asserts.assert_greater_equal(location_id_string_length, 1, "UniqueLocationId must contain at least one character")
+                        asserts.assert_less_equal(location_id_string_length, 64, "UniqueLocationId should be <= 64")
+    
+                    asserts.assert_true(type_matches(device.uniqueLocationIDsLastEdit, uint), "UniqueLocationIdsLastEdit should be a uint")
+                    if num_of_unique_location_ids:
+                        asserts.assert_greater(device.uniqueLocationIDsLastEdit, 0, "UniqueLocationIdsLastEdit must be non-zero")
+                    else:
+                        # TODO double check this is actually a true thing to be asserting.
+                        asserts.assert_equal(device.uniqueLocationIDsLastEdit, 0, "UniqueLocationIdsLastEdit must be 0 if there are no UniqueLocationIds")
+            else:
+                asserts.assert_equal(num_of_devices, 0, "Device was removed, there should be no devices in DeviceDirectory")
+            
+            if first_cluster_validation:
+                self.step(4)
+            location_directory = await self.read_single_attribute(
+                dev_ctrl,
+                dut_node_id,
+                endpoint=cluster_endpoint,
+                attribute=Clusters.EcosystemInformation.Attributes.LocationDirectory,
+                fabricFiltered=False)
+    
+            num_of_locations = len(location_directory)
+            if removed_on_is_null:
+                asserts.assert_less_equal(num_of_locations, 64, "Too many location entries")
+                for location in location_directory:
+                    asserts.assert_true(type_matches(location.uniqueLocationID, str), "UniqueLocationId should be a string")
+                    location_id_string_length = len(location.uniqueLocationID)
+                    asserts.assert_greater_equal(location_id_string_length, 1, "UniqueLocationId must contain at least one character")
+                    asserts.assert_less_equal(location_id_string_length, 64, "UniqueLocationId should be <= 64")
+    
+                    asserts.assert_true(type_matches(location.locationDescriptor.locationName, str), "LocationName should be a string")
+                    asserts.assert_less_equal(len(location.locationDescriptor.locationName), 64, "LocationName should be <= 64")
+    
+                    if location.locationDescriptor.floorNumber is not NullValue:
+                        asserts.assert_true(type_matches(location.locationDescriptor.floorNumber, int), "FloorNumber should be an int")
+                        # TODO check in range of int16.
+    
+                    if location.locationDescriptor.areaType is not NullValue:
+                        # TODO check areaType is valid.
+                        pass
+    
+                    asserts.assert_true(type_matches(location.locationDescriptorLastEdit, uint), "UniqueLocationIdsLastEdit should be a uint")
+                    asserts.assert_greater(location.locationDescriptorLastEdit, 0, "LocationDescriptorLastEdit must be non-zero")
+                    
+    
+            else:
+                asserts.assert_equal(num_of_locations, 0, "Device was removed, there should be no location in LocationDirectory")
+    
+            if first_cluster_validation:
+                self.step(5)
+            result = await dev_ctrl.WriteAttribute(dut_node_id, [(cluster_endpoint, Clusters.EcosystemInformation.Attributes.RemovedOn(2))])
+            asserts.assert_equal(len(result), 1, "Expecting only one result from trying to write to RemovedOn Attribute")
+            asserts.assert_equal(result[0].Status, Status.UnsupportedWrite, "Expecting Status of UnsupportedWrite")
+            
+            if first_cluster_validation:
+                self.step(6)
+            result = await dev_ctrl.WriteAttribute(dut_node_id, [(cluster_endpoint, Clusters.EcosystemInformation.Attributes.DeviceDirectory([]))])
+            asserts.assert_equal(len(result), 1, "Expecting only one result from trying to write to DeviceDirectory Attribute")
+            asserts.assert_equal(result[0].Status, Status.UnsupportedWrite, "Expecting Status of UnsupportedWrite")
+    
+            if first_cluster_validation:
+                self.step(7)
+            result = await dev_ctrl.WriteAttribute(dut_node_id, [(cluster_endpoint, Clusters.EcosystemInformation.Attributes.DeviceDirectory([]))])
+            asserts.assert_equal(len(result), 1, "Expecting only one result from trying to write to LocationDirectory Attribute")
+            asserts.assert_equal(result[0].Status, Status.UnsupportedWrite, "Expecting Status of UnsupportedWrite")
+    
+            if first_cluster_validation:
+                self.step(8)
+            
+            first_cluster_validation = False