Refactor chip::app::Testing namespace to chip::Testing (#42303)

* Initial commit

* Refactor test context usage in various cluster tests to use `chip::Testing` namespace instead of `chip::Test`.

* Refactor test cases to use `SetMockNodeConfig` directly from the `Testing` namespace

* Refactor ClusterTester.h

* Update test files to consistently use `chip::Testing` namespace for test context and cluster tester instances.

* Update references from `chip::Test` to `chip::Testing` across multiple files for consistency in test context usage.

* Refactor test files to replace all instances of `chip::Test` with `chip::Testing` for improved consistency and clarity in test context usage.

* Refactor AppTestContext.h

* Refactor test-interaction-model-api.h for improved readability and consistency in formatting.

* Refactor MessagingContext.h to improve code readability

* Refactor test files to replace all instances of `chip::Test` with `chip::Testing` for improved consistency and clarity in test context usage.

* Refactor LoopbackTransport and IOContext classes for improved readability

* Refactor test files to consistently use `chip::Testing` namespace, enhancing clarity and uniformity in test context usage across multiple test files.

* Refactor ICDConfigurationData and related test access class to consistently use `chip::Testing` namespace, enhancing clarity and uniformity in test context usage.

* Update test files to consistently use `chip::Testing` namespace, enhancing clarity and uniformity in test context usage across various components.

* Refactor test files to consistently use `chip::Testing` namespace, improving clarity and uniformity in test context usage across DataModelFixtures, TestRead, and TestCodeDrivenDataModelProvider components.

* Refactor test files to replace all instances of `chip::Test` with `chip::Testing`, ensuring consistency and clarity in test context usage across various components.

* Refactor attribute-storage.cpp to replace `namespace Test` with `namespace chip::Testing`, ensuring consistency in test context usage across the file.

* Restyled by whitespace

* Restyled by clang-format

* Remove unnecessary `using namespace chip::Testing;` from TestRead.cpp, improving clarity in the test context.

* Update TestMessagingLayer to use `chip::Testing` namespace for consistency in test context usage.

* Restyled by clang-format

* Refactor test files to consistently use `DispatchCount` and `GetLastDispatchPath` functions, enhancing clarity and uniformity in test context usage across TestServerClusterShim and TestICDManager components.

* Refactor test-ember-api.h to improve namespace formatting and enhance clarity in the test context usage.

* Refactor TestExchange to use `Testing::LoopbackMessagingContext` directly, enhancing consistency in test context usage.

* Update src/app/util/mock/attribute-storage.cpp

Co-authored-by: Elen777300 <[email protected]>

* Restyled by clang-format

* Refactor TestPASESession to directly use `Testing::LoopbackMessagingContext`, improving consistency in test context usage.

* Refactor TestCodegenModelViaMocks to use `Protocols::InteractionModel::Status` directly, improving consistency in status handling within tests.

* Refactor MockNodeConfig to improve code consistency by replacing `internal::kDefaultStringSize` with `kDefaultStringSize` and streamline constructor initializations in MockClusterConfig and MockEndpointConfig.

* Refactor DataModelFixtures to use `Testing::MockClusterId` and `Testing::MockAttributeId` directly, enhancing consistency in test fixture definitions.

* Refactor TestAclEvent to improve namespace usage and enhance consistency by removing redundant `chip::` prefixes, streamlining access to types and functions within the app namespace.

* Restyled by clang-format

* Remove redundant namespace declaration in attribute-storage.cpp to improve code clarity and maintain consistency in namespace usage.

* Refactor test namespaces for consistency across network commissioning and occupancy sensing clusters.

Update usage of TestServerClusterContext and ClusterTester to the Testing namespace in relevant test files.

* Refactor `DataModelFixtures.h `

* Restyled by clang-format

* Remove unused includes in `TestResourceMonitoringCluster.cpp`

* Refactor namespace usage in `Group Key Management Cluster` tests

* Refactor namespace, initial commit

* Refactor: Move `chip::app::Testing` to `chip::Testing`

Move Testing namespace from chip::app::Testing to chip::Testing across
the codebase.

* Restyled by clang-format

* Refactor: Remove redundant `using namespace chip::Testing;` from `TestCodegenModelViaMocks.cpp`

---------

Co-authored-by: Restyled.io <[email protected]>
Co-authored-by: Elen777300 <[email protected]>
Co-authored-by: Andrei Litvin <[email protected]>

Author: 4 people

docs/testing/unit_testing.md

@@ -279,10 +279,10 @@ own text context class.
 -   If your test requires access to private/protected members of the underlying
     class you're testing, you'll need to create an accessor class that performs
     these operations and is friended to the underlying class. Please name the
-    class `chip::Test::SomethingTestAccess` where `Something` is the name of the
-    underlying class whose private/protected members you're trying to access.
-    Then add `friend class chip::Test::SomethingTestAccess;` to the underlying
-    class. Make sure your test's BUILD.gn file contains
+    class `chip::Testing::SomethingTestAccess` where `Something` is the name of
+    the underlying class whose private/protected members you're trying to
+    access. Then add `friend class chip::Testing::SomethingTestAccess;` to the
+    underlying class. Make sure your test's BUILD.gn file contains
     `sources = [ "SomethingTestAccess.h" ]`. Before creating a new TestAccess
     class, check if one already exists. If it does exist but doesn't expose the
     member you need, you can add a function to that class to do so. Note that

examples/common/server-cluster-shim/tests/TestServerClusterShim.cpp

@@ -36,7 +36,7 @@ using namespace chip::Testing;
 using namespace chip::app;
 using namespace chip::app::Clusters;
 using namespace chip::app::DataModel;
-using namespace chip::app::Testing;
+using namespace chip::Testing;
 using namespace chip::Protocols::InteractionModel;
 using namespace chip::app::Clusters::Globals::Attributes;
 

src/app/clusters/electrical-energy-measurement-server/tests/TestElectricalEnergyMeasurementCluster.cpp

@@ -222,7 +222,7 @@ TEST_F(TestElectricalEnergyMeasurementCluster, FeatureAttributeTest)
         // Test CumulativeEnergyImported (requires kCumulativeEnergy + kImportedEnergy)
         {
             const ConcreteDataAttributePath path = { paths[0].mEndpointId, paths[0].mClusterId, CumulativeEnergyImported::Id };
-            chip::app::Testing::ReadOperation readOperation(path);
+            chip::Testing::ReadOperation readOperation(path);
             std::unique_ptr<AttributeValueEncoder> encoder = readOperation.StartEncoding();
             auto result                                    = cluster.ReadAttribute(readOperation.GetRequest(), *encoder);
             EXPECT_TRUE(result.IsSuccess());
@@ -231,7 +231,7 @@ TEST_F(TestElectricalEnergyMeasurementCluster, FeatureAttributeTest)
         // Test CumulativeEnergyExported (requires kCumulativeEnergy + kExportedEnergy)
         {
             const ConcreteDataAttributePath path = { paths[0].mEndpointId, paths[0].mClusterId, CumulativeEnergyExported::Id };
-            chip::app::Testing::ReadOperation readOperation(path);
+            chip::Testing::ReadOperation readOperation(path);
             std::unique_ptr<AttributeValueEncoder> encoder = readOperation.StartEncoding();
             auto result                                    = cluster.ReadAttribute(readOperation.GetRequest(), *encoder);
             EXPECT_TRUE(result.IsSuccess());
@@ -240,7 +240,7 @@ TEST_F(TestElectricalEnergyMeasurementCluster, FeatureAttributeTest)
         // Test PeriodicEnergyImported (requires kPeriodicEnergy + kImportedEnergy)
         {
             const ConcreteDataAttributePath path = { paths[0].mEndpointId, paths[0].mClusterId, PeriodicEnergyImported::Id };
-            chip::app::Testing::ReadOperation readOperation(path);
+            chip::Testing::ReadOperation readOperation(path);
             std::unique_ptr<AttributeValueEncoder> encoder = readOperation.StartEncoding();
             auto result                                    = cluster.ReadAttribute(readOperation.GetRequest(), *encoder);
             EXPECT_TRUE(result.IsSuccess());
@@ -249,7 +249,7 @@ TEST_F(TestElectricalEnergyMeasurementCluster, FeatureAttributeTest)
         // Test PeriodicEnergyExported (requires kPeriodicEnergy + kExportedEnergy)
         {
             const ConcreteDataAttributePath path = { paths[0].mEndpointId, paths[0].mClusterId, PeriodicEnergyExported::Id };
-            chip::app::Testing::ReadOperation readOperation(path);
+            chip::Testing::ReadOperation readOperation(path);
             std::unique_ptr<AttributeValueEncoder> encoder = readOperation.StartEncoding();
             auto result                                    = cluster.ReadAttribute(readOperation.GetRequest(), *encoder);
             EXPECT_TRUE(result.IsSuccess());
@@ -258,7 +258,7 @@ TEST_F(TestElectricalEnergyMeasurementCluster, FeatureAttributeTest)
         // Test CumulativeEnergyReset (requires kCumulativeEnergy)
         {
             const ConcreteDataAttributePath path = { paths[0].mEndpointId, paths[0].mClusterId, CumulativeEnergyReset::Id };
-            chip::app::Testing::ReadOperation readOperation(path);
+            chip::Testing::ReadOperation readOperation(path);
             std::unique_ptr<AttributeValueEncoder> encoder = readOperation.StartEncoding();
             auto result                                    = cluster.ReadAttribute(readOperation.GetRequest(), *encoder);
             EXPECT_TRUE(result.IsSuccess());

src/app/clusters/general-diagnostics-server/tests/TestGeneralDiagnosticsCluster.cpp

@@ -39,7 +39,6 @@ using namespace chip::app;
 using namespace chip::app::Clusters;
 using namespace chip::app::Clusters::GeneralDiagnostics::Attributes;
 using namespace chip::app::DataModel;
-using namespace chip::Test;
 using namespace chip::Testing;
 
 template <class T>

src/app/clusters/groupcast/tests/TestGroupcastCluster.cpp

@@ -115,7 +115,7 @@ TEST_F(TestGroupcastCluster, TestJoinGroupCommand)
     cmdData.gracePeriod     = MakeOptional(0U);
     cmdData.useAuxiliaryACL = MakeOptional(true);
 
-    chip::app::Testing::MockCommandHandler cmdHandler;
+    chip::Testing::MockCommandHandler cmdHandler;
     chip::Testing::ClusterTester tester(cluster);
     auto result = tester.Invoke(Commands::JoinGroup::Id, cmdData);
     ASSERT_TRUE(result.status.has_value());

src/app/clusters/network-commissioning/tests/TestNetworkCommissioningCluster.cpp

@@ -46,8 +46,8 @@ using namespace chip::app::Clusters::NetworkCommissioning::Attributes;
 
 using chip::app::AttributeValueDecoder;
 using chip::app::DataModel::AttributeEntry;
-using chip::app::Testing::kAdminSubjectDescriptor;
-using chip::app::Testing::WriteOperation;
+using chip::Testing::kAdminSubjectDescriptor;
+using chip::Testing::WriteOperation;
 
 class NoopBreadcrumbTracker : public BreadCrumbTracker
 {

src/app/clusters/network-commissioning/tests/TestNetworkCommissioningClusterEthernet.cpp

@@ -48,8 +48,8 @@ using namespace chip::app::Clusters::NetworkCommissioning;
 
 using chip::app::AttributeValueDecoder;
 using chip::app::DataModel::AttributeEntry;
-using chip::app::Testing::kAdminSubjectDescriptor;
-using chip::app::Testing::WriteOperation;
+using chip::Testing::kAdminSubjectDescriptor;
+using chip::Testing::WriteOperation;
 
 class NoopBreadcrumbTracker : public BreadCrumbTracker
 {

src/app/clusters/testing/ClusterTester.h

@@ -92,18 +92,18 @@ class ClusterTester
         // Store the read operation in a vector<std::unique_ptr<...>> to ensure its lifetime
         // using std::unique_ptr because ReadOperation is non-copyable and non-movable
         // vector reallocation is not an issue since we store unique_ptrs
-        std::unique_ptr<app::Testing::ReadOperation> readOperation =
-            std::make_unique<app::Testing::ReadOperation>(path.mEndpointId, path.mClusterId, attr_id);
+        std::unique_ptr<chip::Testing::ReadOperation> readOperation =
+            std::make_unique<chip::Testing::ReadOperation>(path.mEndpointId, path.mClusterId, attr_id);
 
         mReadOperations.push_back(std::move(readOperation));
-        app::Testing::ReadOperation & readOperationRef = *mReadOperations.back().get();
+        chip::Testing::ReadOperation & readOperationRef = *mReadOperations.back().get();
 
         std::unique_ptr<app::AttributeValueEncoder> encoder = readOperationRef.StartEncoding();
         app::DataModel::ActionReturnStatus status           = mCluster.ReadAttribute(readOperationRef.GetRequest(), *encoder);
         VerifyOrReturnError(status.IsSuccess(), status);
         ReturnErrorOnFailure(readOperationRef.FinishEncoding());
 
-        std::vector<app::Testing::DecodedAttributeData> attributeData;
+        std::vector<chip::Testing::DecodedAttributeData> attributeData;
         ReturnErrorOnFailure(readOperationRef.GetEncodedIBs().Decode(attributeData));
         VerifyOrReturnError(attributeData.size() == 1u, CHIP_ERROR_INCORRECT_STATE);
 
@@ -124,7 +124,7 @@ class ClusterTester
         VerifyOrReturnError(paths.size() == 1u, CHIP_ERROR_INCORRECT_STATE);
 
         app::ConcreteAttributePath path(paths[0].mEndpointId, paths[0].mClusterId, attr);
-        app::Testing::WriteOperation writeOp(path);
+        chip::Testing::WriteOperation writeOp(path);
 
         // Create a stable object on the stack
         Access::SubjectDescriptor subjectDescriptor{ mHandler.GetAccessingFabricIndex() };
@@ -293,9 +293,9 @@ class ClusterTester
     // If protocol or test requirements change, this value may need to be increased.
     static constexpr size_t kTlvBufferSize = 256;
 
-    app::Testing::MockCommandHandler mHandler;
+    chip::Testing::MockCommandHandler mHandler;
     uint8_t mTlvBuffer[kTlvBufferSize];
-    std::vector<std::unique_ptr<app::Testing::ReadOperation>> mReadOperations;
+    std::vector<std::unique_ptr<chip::Testing::ReadOperation>> mReadOperations;
 };
 
 } // namespace Testing

src/app/clusters/testing/MockCommandHandler.cpp

@@ -26,33 +26,32 @@
 #include <transport/raw/MessageHeader.h>
 
 namespace chip {
-namespace app {
 namespace Testing {
 
-CHIP_ERROR MockCommandHandler::FallibleAddStatus(const ConcreteCommandPath & aRequestCommandPath,
+CHIP_ERROR MockCommandHandler::FallibleAddStatus(const app::ConcreteCommandPath & aRequestCommandPath,
                                                  const Protocols::InteractionModel::ClusterStatusCode & aStatus,
                                                  const char * context)
 {
     mStatuses.emplace_back(StatusRecord{ aRequestCommandPath, aStatus, context });
     return CHIP_NO_ERROR;
 }
 
-void MockCommandHandler::AddStatus(const ConcreteCommandPath & aRequestCommandPath,
+void MockCommandHandler::AddStatus(const app::ConcreteCommandPath & aRequestCommandPath,
                                    const Protocols::InteractionModel::ClusterStatusCode & aStatus, const char * context)
 {
     CHIP_ERROR err = FallibleAddStatus(aRequestCommandPath, aStatus, context);
     VerifyOrDie(err == CHIP_NO_ERROR);
 }
 
-CHIP_ERROR MockCommandHandler::AddResponseData(const ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
-                                               const DataModel::EncodableToTLV & aEncodable)
+CHIP_ERROR MockCommandHandler::AddResponseData(const app::ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
+                                               const app::DataModel::EncodableToTLV & aEncodable)
 {
     chip::System::PacketBufferHandle handle = chip::MessagePacketBuffer::New(chip::kMaxAppMessageLen);
     VerifyOrReturnError(!handle.IsNull(), CHIP_ERROR_NO_MEMORY);
 
     TLV::TLVWriter baseWriter;
     baseWriter.Init(handle->Start(), handle->MaxDataLength());
-    DataModel::FabricAwareTLVWriter writer(baseWriter, mFabricIndex);
+    app::DataModel::FabricAwareTLVWriter writer(baseWriter, mFabricIndex);
     TLV::TLVType ct;
 
     ReturnErrorOnFailure(writer.mTLVWriter.StartContainer(TLV::AnonymousTag(), TLV::kTLVType_Structure, ct));
@@ -64,8 +63,8 @@ CHIP_ERROR MockCommandHandler::AddResponseData(const ConcreteCommandPath & aRequ
     return CHIP_NO_ERROR;
 }
 
-void MockCommandHandler::AddResponse(const ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
-                                     const DataModel::EncodableToTLV & aEncodable)
+void MockCommandHandler::AddResponse(const app::ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
+                                     const app::DataModel::EncodableToTLV & aEncodable)
 {
     CHIP_ERROR err = AddResponseData(aRequestCommandPath, aResponseCommandId, aEncodable);
     VerifyOrDie(err == CHIP_NO_ERROR);
@@ -93,5 +92,4 @@ CHIP_ERROR MockCommandHandler::GetResponseReader(TLV::TLVReader & reader, size_t
 }
 
 } // namespace Testing
-} // namespace app
 } // namespace chip

src/app/clusters/testing/MockCommandHandler.h

@@ -32,48 +32,47 @@
 #include <vector>
 
 namespace chip {
-namespace app {
 namespace Testing {
 
 constexpr FabricIndex kTestFabricIndex = static_cast<FabricIndex>(151);
 
 // Mock class that simulates CommandHandler behavior for unit testing, allowing capture and
 // verification of responses and statuses without real network interactions.
-class MockCommandHandler : public CommandHandler
+class MockCommandHandler : public app::CommandHandler
 {
 public:
     struct ResponseRecord
     {
         CommandId commandId;
         System::PacketBufferHandle encodedData;
-        ConcreteCommandPath path;
+        app::ConcreteCommandPath path;
     };
 
     struct StatusRecord
     {
-        ConcreteCommandPath path;
+        app::ConcreteCommandPath path;
         Protocols::InteractionModel::ClusterStatusCode status;
         const char * context;
     };
 
     ~MockCommandHandler() override = default;
 
-    CHIP_ERROR FallibleAddStatus(const ConcreteCommandPath & aRequestCommandPath,
+    CHIP_ERROR FallibleAddStatus(const app::ConcreteCommandPath & aRequestCommandPath,
                                  const Protocols::InteractionModel::ClusterStatusCode & aStatus,
                                  const char * context = nullptr) override;
 
-    void AddStatus(const ConcreteCommandPath & aRequestCommandPath, const Protocols::InteractionModel::ClusterStatusCode & aStatus,
-                   const char * context = nullptr) override;
+    void AddStatus(const app::ConcreteCommandPath & aRequestCommandPath,
+                   const Protocols::InteractionModel::ClusterStatusCode & aStatus, const char * context = nullptr) override;
 
     FabricIndex GetAccessingFabricIndex() const override { return mFabricIndex; }
 
     // Encodes and stores response data, returning error if encoding fails (fallible version for robust test handling).
-    CHIP_ERROR AddResponseData(const ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
-                               const DataModel::EncodableToTLV & aEncodable) override;
+    CHIP_ERROR AddResponseData(const app::ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
+                               const app::DataModel::EncodableToTLV & aEncodable) override;
 
     // Encodes and stores response data, without error return (non-fallible version that assumes successful encoding in tests).
-    void AddResponse(const ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
-                     const DataModel::EncodableToTLV & aEncodable) override;
+    void AddResponse(const app::ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
+                     const app::DataModel::EncodableToTLV & aEncodable) override;
 
     bool IsTimedInvoke() const override { return false; }
     void FlushAcksRightAwayOnSlowCommand() override {}
@@ -133,5 +132,4 @@ class MockCommandHandler : public CommandHandler
 };
 
 } // namespace Testing
-} // namespace app
 } // namespace chip