Add GetCommissionerNodeId command supports for yaml tests, chip-tool …

…and darwin-framework-tool (project-chip#24737)

examples/chip-tool/commands/common/CHIPCommand.cpp

@@ -178,7 +178,7 @@ void CHIPCommand::MaybeTearDownStack()
 CHIP_ERROR CHIPCommand::EnsureCommissionerForIdentity(std::string identity)
 {
     chip::NodeId nodeId;
-    ReturnErrorOnFailure(GetCommissionerNodeId(identity, &nodeId));
+    ReturnErrorOnFailure(GetIdentityNodeId(identity, &nodeId));
     CommissionerIdentity lookupKey{ identity, nodeId };
     if (mCommissioners.find(lookupKey) != mCommissioners.end())
     {
@@ -310,7 +310,7 @@ std::string CHIPCommand::GetIdentity()
     return name;
 }
 
-CHIP_ERROR CHIPCommand::GetCommissionerNodeId(std::string identity, chip::NodeId * nodeId)
+CHIP_ERROR CHIPCommand::GetIdentityNodeId(std::string identity, chip::NodeId * nodeId)
 {
     if (mCommissionerNodeId.HasValue())
     {
@@ -374,7 +374,7 @@ chip::Controller::DeviceCommissioner & CHIPCommand::GetCommissioner(std::string
     VerifyOrDie(EnsureCommissionerForIdentity(identity) == CHIP_NO_ERROR);
 
     chip::NodeId nodeId;
-    VerifyOrDie(GetCommissionerNodeId(identity, &nodeId) == CHIP_NO_ERROR);
+    VerifyOrDie(GetIdentityNodeId(identity, &nodeId) == CHIP_NO_ERROR);
     CommissionerIdentity lookupKey{ identity, nodeId };
     auto item = mCommissioners.find(lookupKey);
     VerifyOrDie(item != mCommissioners.end());

examples/chip-tool/commands/common/CHIPCommand.h

@@ -144,7 +144,7 @@ class CHIPCommand : public Command
     CredentialIssuerCommands * mCredIssuerCmds;
 
     std::string GetIdentity();
-    CHIP_ERROR GetCommissionerNodeId(std::string identity, chip::NodeId * nodeId);
+    CHIP_ERROR GetIdentityNodeId(std::string identity, chip::NodeId * nodeId);
     void SetIdentity(const char * name);
 
     // This method returns the commissioner instance to be used for running the command.

examples/chip-tool/commands/common/RemoteDataModelLogger.cpp

@@ -27,6 +27,8 @@ constexpr const char * kEventIdKey        = "eventId";
 constexpr const char * kCommandIdKey      = "commandId";
 constexpr const char * kErrorIdKey        = "error";
 constexpr const char * kClusterErrorIdKey = "clusterError";
+constexpr const char * kValueKey          = "value";
+constexpr const char * kNodeIdKey         = "nodeId";
 
 namespace {
 RemoteDataModelLoggerDelegate * gDelegate;
@@ -148,6 +150,18 @@ CHIP_ERROR LogErrorAsJSON(const CHIP_ERROR & error)
     return LogError(value, status);
 }
 
+CHIP_ERROR LogGetCommissionerNodeId(chip::NodeId value)
+{
+    VerifyOrReturnError(gDelegate != nullptr, CHIP_NO_ERROR);
+
+    Json::Value rootValue;
+    rootValue[kValueKey]             = Json::Value();
+    rootValue[kValueKey][kNodeIdKey] = value;
+
+    auto valueStr = chip::JsonToString(rootValue);
+    return gDelegate->LogJSON(valueStr.c_str());
+}
+
 void SetDelegate(RemoteDataModelLoggerDelegate * delegate)
 {
     gDelegate = delegate;

examples/chip-tool/commands/common/RemoteDataModelLogger.h

@@ -38,5 +38,6 @@ CHIP_ERROR LogErrorAsJSON(const chip::app::ConcreteCommandPath & path, const chi
 CHIP_ERROR LogEventAsJSON(const chip::app::EventHeader & header, chip::TLV::TLVReader * data);
 CHIP_ERROR LogErrorAsJSON(const chip::app::EventHeader & header, const chip::app::StatusIB & status);
 CHIP_ERROR LogErrorAsJSON(const CHIP_ERROR & error);
+CHIP_ERROR LogGetCommissionerNodeId(chip::NodeId value);
 void SetDelegate(RemoteDataModelLoggerDelegate * delegate);
 }; // namespace RemoteDataModelLogger

examples/chip-tool/commands/pairing/Commands.h

@@ -21,6 +21,7 @@
 #include "commands/common/Commands.h"
 #include "commands/pairing/CloseSessionCommand.h"
 #include "commands/pairing/CommissionedListCommand.h"
+#include "commands/pairing/GetCommissionerNodeIdCommand.h"
 #include "commands/pairing/OpenCommissioningWindowCommand.h"
 #include "commands/pairing/PairingCommand.h"
 
@@ -220,6 +221,7 @@ void registerCommandsPairing(Commands & commands, CredentialIssuerCommands * cre
         make_unique<StartUdcServerCommand>(credsIssuerConfig),
         make_unique<OpenCommissioningWindowCommand>(credsIssuerConfig),
         make_unique<CloseSessionCommand>(credsIssuerConfig),
+        make_unique<GetCommissionerNodeIdCommand>(credsIssuerConfig),
     };
 
     commands.Register(clusterName, clusterCommands);

examples/chip-tool/commands/pairing/GetCommissionerNodeIdCommand.h

@@ -0,0 +1,43 @@
+/*
+ *   Copyright (c) 2023 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.
+ *
+ */
+
+#pragma once
+
+#include "../common/CHIPCommand.h"
+
+class GetCommissionerNodeIdCommand : public CHIPCommand
+{
+public:
+    GetCommissionerNodeIdCommand(CredentialIssuerCommands * credIssuerCommands) :
+        CHIPCommand("get-commissioner-node-id", credIssuerCommands)
+    {}
+
+    /////////// CHIPCommand Interface /////////
+    CHIP_ERROR RunCommand() override
+    {
+        chip::NodeId id;
+        ReturnErrorOnFailure(GetIdentityNodeId(GetIdentity(), &id));
+        ChipLogProgress(chipTool, "Commissioner Node Id 0x:" ChipLogFormatX64, ChipLogValueX64(id));
+
+        ReturnErrorOnFailure(RemoteDataModelLogger::LogGetCommissionerNodeId(id));
+        SetCommandExitStatus(CHIP_NO_ERROR);
+        return CHIP_NO_ERROR;
+    }
+
+    chip::System::Clock::Timeout GetWaitDuration() const override { return chip::System::Clock::Seconds16(10); }
+};

examples/chip-tool/commands/tests/TestCommand.h

@@ -78,12 +78,6 @@ class TestCommand : public TestRunner,
 
     chip::Controller::DeviceCommissioner & GetCommissioner(const char * identity) override
     {
-        // Best effort to get NodeId - if this fails, GetCommissioner will also fail
-        chip::NodeId id;
-        if (GetCommissionerNodeId(identity, &id) == CHIP_NO_ERROR)
-        {
-            mCommissionerNodeId.SetValue(id);
-        }
         return CHIPCommand::GetCommissioner(identity);
     };
 
@@ -101,7 +95,6 @@ class TestCommand : public TestRunner,
 
     chip::Optional<char *> mPICSFilePath;
     chip::Optional<uint16_t> mTimeout;
-    chip::Optional<chip::NodeId> mCommissionerNodeId;
     std::map<std::string, std::unique_ptr<chip::OperationalDeviceProxy>> mDevices;
 
     // When set to false, prevents interaction model events from affecting the current test status.

examples/chip-tool/templates/tests/partials/test_cluster.zapt

@@ -48,14 +48,6 @@ private:
 
     void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
     {
-
-        // Allow yaml to access the current commissioner node id.
-        // Default to 0 (undefined node id) so we know if this isn't
-        // set correctly.
-        // Reset on every step in case it changed.
-        chip::NodeId commissionerNodeId = mCommissionerNodeId.ValueOr(0);
-        (void) commissionerNodeId;
-
         bool shouldContinue = false;
 
         switch (mTestIndex - 1)
@@ -80,12 +72,6 @@ private:
     CHIP_ERROR DoTestStep(uint16_t testIndex) override
     {
         using namespace chip::app::Clusters;
-        // Allow yaml to access the current commissioner node id.
-        // Default to 0 (undefined node id) so we know if this isn't
-        // set correctly.
-        // Reset on every step in case it changed.
-        chip::NodeId commissionerNodeId = mCommissionerNodeId.ValueOr(0);
-        (void) commissionerNodeId;
         switch (testIndex)
         {
         {{#chip_tests_items}}

examples/darwin-framework-tool/BUILD.gn

@@ -139,6 +139,8 @@ executable("darwin-framework-tool") {
     "commands/common/MTRLogging.h",
     "commands/pairing/Commands.h",
     "commands/pairing/DeviceControllerDelegateBridge.mm",
+    "commands/pairing/GetCommissionerNodeIdCommand.h",
+    "commands/pairing/GetCommissionerNodeIdCommand.mm",
     "commands/pairing/OpenCommissioningWindowCommand.h",
     "commands/pairing/OpenCommissioningWindowCommand.mm",
     "commands/pairing/PairingCommandBridge.mm",

examples/darwin-framework-tool/commands/pairing/Commands.h

@@ -20,6 +20,7 @@
 
 #import <Matter/Matter.h>
 
+#include "GetCommissionerNodeIdCommand.h"
 #include "OpenCommissioningWindowCommand.h"
 #include "PairingCommandBridge.h"
 #include "PreWarmCommissioningCommand.h"
@@ -73,6 +74,7 @@ void registerCommandsPairing(Commands & commands)
         make_unique<Unpair>(),
         make_unique<OpenCommissioningWindowCommand>(),
         make_unique<PreWarmCommissioningCommand>(),
+        make_unique<GetCommissionerNodeIdCommand>(),
     };
 
     commands.Register(clusterName, clusterCommands);

examples/darwin-framework-tool/commands/pairing/GetCommissionerNodeIdCommand.h

@@ -0,0 +1,32 @@
+/*
+ *   Copyright (c) 2023 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.
+ *
+ */
+
+#pragma once
+
+#include "../common/CHIPCommandBridge.h"
+
+class GetCommissionerNodeIdCommand : public CHIPCommandBridge
+{
+public:
+    GetCommissionerNodeIdCommand() : CHIPCommandBridge("get-commissioner-node-id") {}
+
+    /////////// CHIPCommand Interface /////////
+    CHIP_ERROR RunCommand() override;
+
+    chip::System::Clock::Timeout GetWaitDuration() const override { return chip::System::Clock::Seconds16(0); }
+};

examples/darwin-framework-tool/commands/pairing/GetCommissionerNodeIdCommand.mm

@@ -0,0 +1,33 @@
+/*
+ *   Copyright (c) 2023 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 <Matter/Matter.h>
+
+#include "GetCommissionerNodeIdCommand.h"
+
+CHIP_ERROR GetCommissionerNodeIdCommand::RunCommand()
+{
+    auto * controller = CurrentCommissioner();
+    VerifyOrReturnError(nil != controller, CHIP_ERROR_INCORRECT_STATE);
+
+    auto id = [controller.controllerNodeId unsignedLongLongValue];
+    ChipLogProgress(chipTool, "Commissioner Node Id 0x:" ChipLogFormatX64, ChipLogValueX64(id));
+
+    SetCommandExitStatus(CHIP_NO_ERROR);
+    return CHIP_NO_ERROR;
+}

examples/darwin-framework-tool/commands/tests/TestCommandBridge.h

@@ -154,9 +154,6 @@ class TestCommandBridge : public CHIPCommandBridge,
         VerifyOrReturnError(controller != nil, CHIP_ERROR_INCORRECT_STATE);
 
         SetIdentity(identity);
-        if (controller.controllerNodeId != nil) {
-            mCommissionerNodeId.SetValue([controller.controllerNodeId unsignedLongLongValue]);
-        }
 
         // Invalidate our existing CASE session; otherwise trying to work with
         // our device will just reuse it without establishing a new CASE
@@ -184,10 +181,6 @@ class TestCommandBridge : public CHIPCommandBridge,
         VerifyOrReturnError(controller != nil, CHIP_ERROR_INCORRECT_STATE);
 
         SetIdentity(identity);
-        if (controller.controllerNodeId != nil) {
-            mCommissionerNodeId.SetValue([controller.controllerNodeId unsignedLongLongValue]);
-        }
-
         [controller setDeviceControllerDelegate:mDeviceControllerDelegate queue:mCallbackQueue];
         [mDeviceControllerDelegate setDeviceId:value.nodeId];
         [mDeviceControllerDelegate setActive:YES];
@@ -208,6 +201,26 @@ class TestCommandBridge : public CHIPCommandBridge,
         return MTRErrorToCHIPErrorCode(err);
     }
 
+    CHIP_ERROR GetCommissionerNodeId(const char * _Nullable identity,
+        const chip::app::Clusters::CommissionerCommands::Commands::GetCommissionerNodeId::Type & value,
+        void (^_Nonnull OnResponse)(const chip::GetCommissionerNodeIdResponse &))
+    {
+        auto * controller = GetCommissioner(identity);
+        VerifyOrReturnError(controller != nil, CHIP_ERROR_INCORRECT_STATE);
+
+        auto id = [controller.controllerNodeId unsignedLongLongValue];
+        ChipLogProgress(chipTool, "Commissioner Node Id: %llu", id);
+
+        chip::GetCommissionerNodeIdResponse outValue;
+        outValue.nodeId = id;
+
+        dispatch_async(mCallbackQueue, ^{
+            OnResponse(outValue);
+        });
+
+        return CHIP_NO_ERROR;
+    }
+
     /////////// SystemCommands Interface /////////
     CHIP_ERROR ContinueOnChipMainThread(CHIP_ERROR err) override
     {
@@ -226,9 +239,6 @@ class TestCommandBridge : public CHIPCommandBridge,
         MTRDeviceController * controller = GetCommissioner(identity);
 
         SetIdentity(identity);
-        if (controller != nil && controller.controllerNodeId != nil) {
-            mCommissionerNodeId.SetValue([controller.controllerNodeId unsignedLongLongValue]);
-        }
         return mConnectedDevices[identity];
     }
 
@@ -270,7 +280,6 @@ class TestCommandBridge : public CHIPCommandBridge,
     chip::Optional<char *> mPICSFilePath;
     chip::Optional<chip::EndpointId> mEndpointId;
     chip::Optional<uint16_t> mTimeout;
-    chip::Optional<chip::NodeId> mCommissionerNodeId;
 
     bool CheckConstraintStartsWith(
         const char * _Nonnull itemName, const NSString * _Nonnull current, const char * _Nonnull expected)

examples/darwin-framework-tool/templates/tests/partials/test_cluster.zapt

@@ -23,17 +23,10 @@ class {{filename}}: public TestCommandBridge
     {
     }
 
-    // Allow yaml to access the current commissioner node id.
-    // Default to 0 (undefined node id) so we know if this isn't
-    // set correctly.
-    // Reset on every step in case it changed.
-    chip::NodeId commissionerNodeId = mCommissionerNodeId.ValueOr(0);
-
     /////////// TestCommand Interface /////////
     void NextTest() override
     {
       CHIP_ERROR err = CHIP_NO_ERROR;
-      commissionerNodeId = mCommissionerNodeId.ValueOr(0);
 
       if (0 == mTestIndex)
       {
@@ -140,10 +133,31 @@ class {{filename}}: public TestCommandBridge
         {{#chip_tests_item_parameters}}
           {{>commandValue ns=parent.cluster container=(asPropertyValue dontUnwrapValue=true) definedValue=definedValue depth=0}}
         {{/chip_tests_item_parameters}}
+        {{#if (and (isStrEqual cluster "CommissionerCommands") (isStrEqual command "GetCommissionerNodeId"))}}
+        return {{command}}("{{identity}}", value, ^(const chip::{{command}}Response & values) {
+            {{#chip_tests_item_responses}}
+            {{#chip_tests_item_response_parameters}}
+            {{#if hasExpectedValue}}
+            {
+              id actualValue = values.{{asStructPropertyName name}}
+              {{>check_test_value actual="actualValue" expected=expectedValue cluster=../cluster}}
+            }
+            {{/if}}
+            {{>maybeCheckExpectedConstraints}}
+            {{#if saveAs}}
+            {
+              {{saveAs}} = [[NSNumber alloc] initWithUnsignedLongLong:values.{{asStructPropertyName name}}];
+            }
+            {{/if}}
+            {{/chip_tests_item_response_parameters}}
+            {{/chip_tests_item_responses}}
+            NextTest();
+        });
+        {{else}}
         return {{command}}("{{identity}}", value);
+        {{/if}}
         {{else}}
         MTRBaseDevice * device = GetDevice("{{identity}}");
-        commissionerNodeId = mCommissionerNodeId.ValueOr(0);
         __auto_type * cluster = [[MTRBaseCluster{{>cluster}} alloc] initWithDevice:device endpointID:@({{endpoint}}) queue:mCallbackQueue];
         VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE);