Valve: Disco ball - argument parsing for open

Author: cecille

src/app/clusters/valve-configuration-and-control-server/valve-configuration-and-control-cluster-logic.cpp

@@ -160,6 +160,77 @@ CHIP_ERROR ClusterLogic::ClearValveFault(const ValveFaultBitmap valveFault)
     return CHIP_ERROR_NOT_IMPLEMENTED;
 }
 
+CHIP_ERROR ClusterLogic::GetRealTargetLevel(const std::optional<uint8_t> & targetLevel,
+                                            DataModel::Nullable<uint8_t> & realTargetLevel)
+{
+    if (!mConformance.HasFeature(Feature::kLevel))
+    {
+        if (targetLevel.has_value())
+        {
+            return CHIP_ERROR_INVALID_ARGUMENT;
+        }
+        realTargetLevel = DataModel::NullNullable;
+        return CHIP_NO_ERROR;
+    }
+    // LVL is supported
+    if (!targetLevel.has_value())
+    {
+        if (mConformance.supportsDefaultOpenLevel)
+        {
+            realTargetLevel = mState.defaultOpenLevel;
+            return CHIP_NO_ERROR;
+        }
+        realTargetLevel.SetNonNull(100u);
+        return CHIP_NO_ERROR;
+    }
+    // targetLevel has a value
+    if (mConformance.supportsLevelStep)
+    {
+        if ((targetLevel.value() != 100u) && ((targetLevel.value() % mState.levelStep) != 0))
+        {
+            return CHIP_ERROR_INVALID_ARGUMENT;
+        }
+    }
+    realTargetLevel.SetNonNull(targetLevel.value());
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR ClusterLogic::HandleOpenCommand(std::optional<DataModel::Nullable<uint32_t>> openDuration,
+                                           std::optional<uint8_t> targetLevel)
+{
+    // openDuration
+    // - if this is omitted, fall back to defaultOpenDuration
+    // - if this is NULL, remaining duration is NULL
+    // - if this is a value, use that value
+    // - if remaining duration is not null and TS is supported, set the autoCloseTime as appropriate
+    // targetLevel
+    // - if LVL is not supported
+    //   - if this is omitted, that's correct
+    //   - if this is supplied return error
+    // - if LVL is supported
+    //   - if this value is not supplied, use defaultOpenLevel if supported, otherwise 100
+    //   - if this value is supplied, check against levelStep, error if not OK, otherwise set targetLevel
+    VerifyOrReturnError(mInitialized, CHIP_ERROR_INCORRECT_STATE);
+
+    DataModel::Nullable<uint32_t> realOpenDuration;
+    if (openDuration.has_value())
+    {
+        realOpenDuration = openDuration.value();
+    }
+    else
+    {
+        realOpenDuration = mState.defaultOpenDuration;
+    }
+
+    DataModel::Nullable<uint8_t> realTargetLevel;
+    ReturnErrorOnFailure(GetRealTargetLevel(targetLevel, realTargetLevel));
+
+    mClusterDriver.HandleOpenValve(realTargetLevel);
+    mState.openDuration = realOpenDuration;
+    mState.targetLevel  = realTargetLevel;
+    return CHIP_NO_ERROR;
+}
+
 } // namespace ValveConfigurationAndControl
 } // namespace Clusters
 } // namespace app

src/app/clusters/valve-configuration-and-control-server/valve-configuration-and-control-cluster-logic.h

@@ -131,7 +131,16 @@ class ClusterLogic
     // Current state
     // Current level
 
+    // Return CHIP_ERROR_INCORRECT_STATE if the class has not been initialized.
+    // Return CHIP_ERROR_INVALID_ARGUMENT if the input values are out is out of range or the targetLevel is supplied when LVL is not
+    // supported.
+    // Calls delegate HandleOpen function after validating the parameters
+    CHIP_ERROR HandleOpenCommand(std::optional<DataModel::Nullable<uint32_t>> openDuration, std::optional<uint8_t> targetLevel);
+
 private:
+    // Returns the target level to send to the delegate based on the targetLevel command field, the device conformance and the
+    // defaults. Returns error if the supplied target level is invalid or not supported by the device conformance.
+    CHIP_ERROR GetRealTargetLevel(const std::optional<uint8_t> & targetLevel, DataModel::Nullable<uint8_t> & realTargetLevel);
     bool mInitialized = false;
 
     Delegate & mClusterDriver;

src/app/tests/TestValveConfigurationAndControl.cpp

@@ -40,12 +40,14 @@ class TestDelegate : public Delegate
 {
 public:
     TestDelegate() {}
-    DataModel::Nullable<chip::Percent> HandleOpenValve(DataModel::Nullable<chip::Percent> level) override
+    DataModel::Nullable<Percent> HandleOpenValve(DataModel::Nullable<Percent> level) override
     {
+        lastRequestedLevel = level;
         return DataModel::NullNullable;
     }
     CHIP_ERROR HandleCloseValve() override { return CHIP_NO_ERROR; }
     void HandleRemainingDurationTick(uint32_t duration) override {}
+    DataModel::Nullable<Percent> lastRequestedLevel;
 };
 
 TEST_F(TestValveConfigurationAndControlClusterLogic, TestConformanceValid)
@@ -504,6 +506,76 @@ TEST_F(TestValveConfigurationAndControlClusterLogic, TestSetDefaultOpenLevel)
     EXPECT_EQ(logic_no_level.SetDefaultOpenLevel(testVal), CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE);
 }
 
+TEST_F(TestValveConfigurationAndControlClusterLogic, TestHandleOpenDuration)
+{
+    TestDelegate delegate;
+    TestPersistentStorageDelegate storageDelegate;
+    EndpointId endpoint   = 0;
+    MatterContext context = MatterContext(endpoint, storageDelegate);
+    ClusterLogic logic    = ClusterLogic(delegate, context);
+
+    ClusterConformance conformance = { .featureMap = to_underlying(Feature::kLevel) | to_underlying(Feature::kTimeSync),
+                                       .supportsDefaultOpenLevel = true,
+                                       .supportsValveFault       = true,
+                                       .supportsLevelStep        = true };
+    EXPECT_EQ(logic.Init(conformance), CHIP_NO_ERROR);
+
+    DataModel::Nullable<ElapsedS> valElapsedSNullable;
+
+    EXPECT_EQ(logic.GetOpenDuration(valElapsedSNullable), CHIP_NO_ERROR);
+    EXPECT_EQ(valElapsedSNullable, DataModel::NullNullable);
+
+    EXPECT_EQ(logic.GetDefaultOpenDuration(valElapsedSNullable), CHIP_NO_ERROR);
+    EXPECT_EQ(valElapsedSNullable, DataModel::NullNullable);
+
+    // Fall back to default
+    EXPECT_EQ(logic.HandleOpenCommand(std::nullopt, std::nullopt), CHIP_NO_ERROR);
+    EXPECT_EQ(logic.GetOpenDuration(valElapsedSNullable), CHIP_NO_ERROR);
+    EXPECT_EQ(valElapsedSNullable, DataModel::NullNullable);
+
+    DataModel::Nullable<ElapsedS> defaultOpenDuration;
+    defaultOpenDuration.SetNonNull(12u);
+    EXPECT_EQ(logic.SetDefaultOpenDuration(defaultOpenDuration), CHIP_NO_ERROR);
+    EXPECT_EQ(logic.HandleOpenCommand(std::nullopt, std::nullopt), CHIP_NO_ERROR);
+    EXPECT_EQ(logic.GetOpenDuration(valElapsedSNullable), CHIP_NO_ERROR);
+    EXPECT_EQ(valElapsedSNullable, defaultOpenDuration);
+
+    // Set from command parameters
+    DataModel::Nullable<ElapsedS> openDuration;
+    openDuration.SetNull();
+    EXPECT_EQ(logic.HandleOpenCommand(std::make_optional(openDuration), std::nullopt), CHIP_NO_ERROR);
+    EXPECT_EQ(logic.GetOpenDuration(valElapsedSNullable), CHIP_NO_ERROR);
+    EXPECT_EQ(valElapsedSNullable, DataModel::NullNullable);
+
+    openDuration.SetNonNull(12u);
+    EXPECT_EQ(logic.HandleOpenCommand(std::make_optional(openDuration), std::nullopt), CHIP_NO_ERROR);
+    EXPECT_EQ(logic.GetOpenDuration(valElapsedSNullable), CHIP_NO_ERROR);
+    EXPECT_EQ(valElapsedSNullable.ValueOr(0), 12u);
+}
+
+TEST_F(TestValveConfigurationAndControlClusterLogic, TestHandleOpenTargetLevelFeatureUnsupported)
+{
+    TestDelegate delegate;
+    TestPersistentStorageDelegate storageDelegate;
+    EndpointId endpoint   = 0;
+    MatterContext context = MatterContext(endpoint, storageDelegate);
+    ClusterLogic logic    = ClusterLogic(delegate, context);
+
+    ClusterConformance conformance = {
+        .featureMap = 0, .supportsDefaultOpenLevel = false, .supportsValveFault = false, .supportsLevelStep = false
+    };
+    EXPECT_EQ(logic.Init(conformance), CHIP_NO_ERROR);
+
+    // Set the last value to something non-null first so we can ensure the delegate was called correctly.
+    delegate.lastRequestedLevel.SetNonNull(0);
+    EXPECT_EQ(logic.HandleOpenCommand(std::nullopt, std::nullopt), CHIP_NO_ERROR);
+    // This configuration doesn't support level, so the delegate should be called with a NullNullable
+    EXPECT_EQ(delegate.lastRequestedLevel, DataModel::NullNullable);
+
+    // Should get an error when this is called with target level set since the feature is unsupported.
+    EXPECT_EQ(logic.HandleOpenCommand(std::nullopt, std::make_optional(50u)), CHIP_ERROR_INVALID_ARGUMENT);
+}
+
 } // namespace ValveConfigurationAndControl
 } // namespace Clusters
 } // namespace app