mw::com: fix tests for method enabled_ bool change

Author: KrishaDeshkool

score/mw/com/impl/bindings/lola/proxy_method_handling_test.cpp

@@ -106,9 +106,9 @@ const LolaServiceInstanceDeployment kLolaServiceInstanceDeploymentWithMethods{
     LolaServiceInstanceId{kLolaInstanceId},
     {},
     {},
-    {{kDummyMethodName0, LolaMethodInstanceDeployment{kDummyQueueSize0}},
-     {kDummyMethodName1, LolaMethodInstanceDeployment{kDummyQueueSize1}},
-     {kDummyMethodName2, LolaMethodInstanceDeployment{kDummyQueueSize2}}}};
+    {{kDummyMethodName0, LolaMethodInstanceDeployment{kDummyQueueSize0, true}},
+     {kDummyMethodName1, LolaMethodInstanceDeployment{kDummyQueueSize1, true}},
+     {kDummyMethodName2, LolaMethodInstanceDeployment{kDummyQueueSize2, true}}}};
 const LolaServiceTypeDeployment kLolaServiceTypeDeploymentWithMethods{
     kLolaServiceId,
     {},

score/mw/com/impl/bindings/lola/test/skeleton_test_resources.h

@@ -255,16 +255,17 @@ static const ServiceInstanceDeployment kValidInstanceDeploymentWithField{
 
 static const ServiceInstanceDeployment kValidInstanceDeploymentWithMethods{
     kFooService,
-    CreateLolaServiceInstanceDeployment(kDefaultLolaInstanceId,
-                                        {},
-                                        {},
-                                        {{test::kFooMethodName, LolaMethodInstanceDeployment{kFooMethodQueueSize}},
-                                         {test::kDumbMethodName, LolaMethodInstanceDeployment{kDumbMethodQueueSize}}},
-                                        {kAllowedQmMethodConsumer},
-                                        {},
-                                        kConfiguredDeploymentShmSize,
-                                        kConfiguredDeploymentControlAsilBShmSize,
-                                        kConfiguredDeploymentControlQmShmSize),
+    CreateLolaServiceInstanceDeployment(
+        kDefaultLolaInstanceId,
+        {},
+        {},
+        {{test::kFooMethodName, LolaMethodInstanceDeployment{kFooMethodQueueSize, true}},
+         {test::kDumbMethodName, LolaMethodInstanceDeployment{kDumbMethodQueueSize, true}}},
+        {kAllowedQmMethodConsumer},
+        {},
+        kConfiguredDeploymentShmSize,
+        kConfiguredDeploymentControlAsilBShmSize,
+        kConfiguredDeploymentControlQmShmSize),
     QualityType::kASIL_QM,
     kFooInstanceSpecifier};
 
@@ -301,16 +302,17 @@ static const ServiceInstanceDeployment kValidAsilInstanceDeploymentWithField{
 
 static const ServiceInstanceDeployment kValidAsilInstanceDeploymentWithMethods{
     kFooService,
-    CreateLolaServiceInstanceDeployment(kDefaultLolaInstanceId,
-                                        {},
-                                        {},
-                                        {{test::kFooMethodName, LolaMethodInstanceDeployment{kFooMethodQueueSize}},
-                                         {test::kDumbMethodName, LolaMethodInstanceDeployment{kDumbMethodQueueSize}}},
-                                        {},
-                                        {kAllowedAsilBMethodConsumer},
-                                        kConfiguredDeploymentShmSize,
-                                        kConfiguredDeploymentControlAsilBShmSize,
-                                        kConfiguredDeploymentControlQmShmSize),
+    CreateLolaServiceInstanceDeployment(
+        kDefaultLolaInstanceId,
+        {},
+        {},
+        {{test::kFooMethodName, LolaMethodInstanceDeployment{kFooMethodQueueSize, true}},
+         {test::kDumbMethodName, LolaMethodInstanceDeployment{kDumbMethodQueueSize, true}}},
+        {},
+        {kAllowedAsilBMethodConsumer},
+        kConfiguredDeploymentShmSize,
+        kConfiguredDeploymentControlAsilBShmSize,
+        kConfiguredDeploymentControlQmShmSize),
     QualityType::kASIL_B,
     kFooInstanceSpecifier};
 

score/mw/com/impl/configuration/config_parser_methods_test.cpp

@@ -694,8 +694,7 @@ TEST_F(ConfigParserFixture, MethodCanBeExplicitlyDisabled)
     const auto deployments =
         config.GetServiceInstances().at(InstanceSpecifier::Create(std::string{"abc/abc/TirePressurePort"}).value());
     const auto& lola_deployment = std::get<LolaServiceInstanceDeployment>(deployments.bindingInfo_);
-    ASSERT_TRUE(lola_deployment.methods_.at("SetPressure").enabled_.has_value());
-    EXPECT_FALSE(lola_deployment.methods_.at("SetPressure").enabled_.value());
+    EXPECT_FALSE(lola_deployment.methods_.at("SetPressure").enabled_);
 }
 
 TEST_F(ConfigParserFixture, MethodCanBeExplicitlyEnabled)
@@ -761,8 +760,7 @@ TEST_F(ConfigParserFixture, MethodCanBeExplicitlyEnabled)
     const auto deployments =
         config.GetServiceInstances().at(InstanceSpecifier::Create(std::string{"abc/abc/TirePressurePort"}).value());
     const auto& lola_deployment = std::get<LolaServiceInstanceDeployment>(deployments.bindingInfo_);
-    ASSERT_TRUE(lola_deployment.methods_.at("SetPressure").enabled_.has_value());
-    EXPECT_TRUE(lola_deployment.methods_.at("SetPressure").enabled_.value());
+    EXPECT_TRUE(lola_deployment.methods_.at("SetPressure").enabled_);
 }
 
 }  // namespace

score/mw/com/impl/configuration/config_parser_test.cpp

@@ -129,8 +129,7 @@ TEST_F(ConfigParserFixture, ParseExampleJson)
               1);
     EXPECT_EQ(secondDeploymentInfo.fields_.at("CurrentTemperatureFrontLeft").use_get_if_available_, true);
     EXPECT_EQ(secondDeploymentInfo.fields_.at("CurrentTemperatureFrontLeft").use_set_if_available_, true);
-    ASSERT_TRUE(secondDeploymentInfo.methods_.at("SetPressure").enabled_.has_value());
-    EXPECT_TRUE(secondDeploymentInfo.methods_.at("SetPressure").enabled_.value());
+    EXPECT_TRUE(secondDeploymentInfo.methods_.at("SetPressure").enabled_);
 
     const auto service_deployment = config.GetServiceTypes().at(deployments.service_);
     const auto* const lola_service_type_deployment =

score/mw/com/impl/configuration/lola_method_instance_deployment_test.cpp

@@ -14,6 +14,9 @@
 
 #include <gtest/gtest.h>
 
+#include <score/assert_support.hpp>
+#include <score/utility.hpp>
+
 #include <cstdint>
 #include <limits>
 
@@ -25,8 +28,8 @@ namespace
 TEST(LolaMethodInstanceDeploymentTest, EqualityOperatorWithSameQueueSize)
 {
     // Given two LolaMethodInstanceDeployments with the same queue size
-    LolaMethodInstanceDeployment unit1{50U};
-    LolaMethodInstanceDeployment unit2{50U};
+    LolaMethodInstanceDeployment unit1{50U, true};
+    LolaMethodInstanceDeployment unit2{50U, true};
 
     // When comparing them
     // Then they should be equal
@@ -36,8 +39,8 @@ TEST(LolaMethodInstanceDeploymentTest, EqualityOperatorWithSameQueueSize)
 TEST(LolaMethodInstanceDeploymentTest, EqualityOperatorWithDifferentQueueSize)
 {
     // Given two LolaMethodInstanceDeployments with different queue sizes
-    LolaMethodInstanceDeployment unit1{10U};
-    LolaMethodInstanceDeployment unit2{20U};
+    LolaMethodInstanceDeployment unit1{10U, true};
+    LolaMethodInstanceDeployment unit2{20U, true};
 
     // When comparing them
     // Then they should not be equal
@@ -47,8 +50,8 @@ TEST(LolaMethodInstanceDeploymentTest, EqualityOperatorWithDifferentQueueSize)
 TEST(LolaMethodInstanceDeploymentTest, DefaultInstancesAreEqual)
 {
     // Given two LolaMethodInstanceDeployments constructed with std::nullopt
-    LolaMethodInstanceDeployment unit1{std::nullopt};
-    LolaMethodInstanceDeployment unit2{std::nullopt};
+    LolaMethodInstanceDeployment unit1{std::nullopt, true};
+    LolaMethodInstanceDeployment unit2{std::nullopt, true};
 
     // When comparing them
     // Then they should be equal
@@ -58,30 +61,33 @@ TEST(LolaMethodInstanceDeploymentTest, DefaultInstancesAreEqual)
 TEST(LolaMethodInstanceDeploymentTest, MaxQueueSize)
 {
     // Given a LolaMethodInstanceDeployment with maximum queue size
-    LolaMethodInstanceDeployment unit{std::numeric_limits<LolaMethodInstanceDeployment::QueueSize>::max()};
+    LolaMethodInstanceDeployment unit{std::numeric_limits<LolaMethodInstanceDeployment::QueueSize>::max(), true};
 
     // Then the queue size should match
     EXPECT_EQ(unit.queue_size_, std::numeric_limits<LolaMethodInstanceDeployment::QueueSize>::max());
 }
 
-TEST(LolaMethodInstanceDeploymentSerializationTest, CreateFromJsonWithQueueSize)
+TEST(LolaMethodInstanceDeploymentSerializationTest, CreateFromJsonWithQueueSizeAndEnabledFlag)
 {
     // Given a JSON object with queueSize
     const LolaMethodInstanceDeployment::QueueSize queue_size{20U};
     score::json::Object json_object{};
     json_object["queueSize"] = score::json::Any{queue_size};
+    json_object["use"] = score::json::Any{true};
 
     // When creating from JSON
     auto unit = LolaMethodInstanceDeployment::CreateFromJson(json_object);
 
     // Then the queue size should match the value from JSON
     EXPECT_EQ(unit.queue_size_, queue_size);
+    EXPECT_TRUE(unit.enabled_);
 }
 
 TEST(LolaMethodInstanceDeploymentSerializationTest, CreateFromJsonWithoutQueueSizeResultsInNullopt)
 {
     // Given an empty JSON object
     score::json::Object json_object{};
+    json_object["use"] = score::json::Any{true};
 
     // When creating from JSON
     auto unit = LolaMethodInstanceDeployment::CreateFromJson(json_object);
@@ -91,19 +97,16 @@ TEST(LolaMethodInstanceDeploymentSerializationTest, CreateFromJsonWithoutQueueSi
     EXPECT_EQ(unit.queue_size_, std::nullopt);
 }
 
-TEST(LolaMethodInstanceDeploymentSerializationTest, CreateFromJsonWithoutEnabledLeavesEnabledUnset)
+TEST(LolaMethodInstanceDeploymentSerializationTest, CreateFromJsonWithoutEnabledFlagTerminates)
 {
     // Given a JSON object without enabled
     const LolaMethodInstanceDeployment::QueueSize queue_size{20U};
     score::json::Object json_object{};
     json_object["queueSize"] = score::json::Any{queue_size};
 
     // When creating from JSON
-    auto unit = LolaMethodInstanceDeployment::CreateFromJson(json_object);
-
-    // Then the method instance should keep enabled unset
-    EXPECT_FALSE(unit.enabled_.has_value());
-    EXPECT_EQ(unit.enabled_, std::nullopt);
+    // Then we terminate because the enabled flag is required.
+    SCORE_LANGUAGE_FUTURECPP_EXPECT_CONTRACT_VIOLATED(LolaMethodInstanceDeployment::CreateFromJson(json_object));
 }
 
 TEST(LolaMethodInstanceDeploymentSerializationTest, CreateFromJsonWithEnabledFalseDisablesMethod)
@@ -116,8 +119,7 @@ TEST(LolaMethodInstanceDeploymentSerializationTest, CreateFromJsonWithEnabledFal
     auto unit = LolaMethodInstanceDeployment::CreateFromJson(json_object);
 
     // Then the method instance should be disabled
-    ASSERT_TRUE(unit.enabled_.has_value());
-    EXPECT_FALSE(unit.enabled_.value());
+    EXPECT_FALSE(unit.enabled_);
 }
 
 TEST(LolaMethodInstanceDeploymentSerializationTest, CreateFromJsonWithEnabledTrueEnablesMethod)
@@ -130,8 +132,7 @@ TEST(LolaMethodInstanceDeploymentSerializationTest, CreateFromJsonWithEnabledTru
     auto unit = LolaMethodInstanceDeployment::CreateFromJson(json_object);
 
     // Then the method instance should be enabled
-    ASSERT_TRUE(unit.enabled_.has_value());
-    EXPECT_TRUE(unit.enabled_.value());
+    EXPECT_TRUE(unit.enabled_);
 }
 
 TEST(LolaMethodInstanceDeploymentSerializationTest, SerializeAndDeserializePreservesQueueSize)
@@ -140,6 +141,8 @@ TEST(LolaMethodInstanceDeploymentSerializationTest, SerializeAndDeserializePrese
     const LolaMethodInstanceDeployment::QueueSize queue_size{100U};
     score::json::Object json_object{};
     json_object["queueSize"] = score::json::Any{queue_size};
+    json_object["use"] = score::json::Any{true};
+
     auto original_unit = LolaMethodInstanceDeployment::CreateFromJson(json_object);
 
     // When serializing and deserializing
@@ -157,6 +160,8 @@ TEST(LolaMethodInstanceDeploymentSerializationTest, SerializeIncludesQueueSize)
     const LolaMethodInstanceDeployment::QueueSize queue_size{42U};
     score::json::Object json_object{};
     json_object["queueSize"] = score::json::Any{queue_size};
+    json_object["use"] = score::json::Any{true};
+
     auto unit = LolaMethodInstanceDeployment::CreateFromJson(json_object);
 
     // When serializing
@@ -180,8 +185,7 @@ TEST(LolaMethodInstanceDeploymentSerializationTest, SerializeAndDeserializePrese
     auto reconstructed_unit = LolaMethodInstanceDeployment::CreateFromJson(serialized);
 
     // Then the use state should be preserved
-    ASSERT_TRUE(reconstructed_unit.enabled_.has_value());
-    EXPECT_FALSE(reconstructed_unit.enabled_.value());
+    EXPECT_FALSE(reconstructed_unit.enabled_);
     EXPECT_EQ(reconstructed_unit, original_unit);
 }
 

score/mw/com/impl/configuration/test/configuration_test_resources.cpp

@@ -61,13 +61,13 @@ LolaFieldInstanceDeployment MakeLolaFieldInstanceDeployment(
 
 LolaMethodInstanceDeployment MakeDefaultLolaMethodInstanceDeployment() noexcept
 {
-    return LolaMethodInstanceDeployment{std::nullopt};
+    return LolaMethodInstanceDeployment{std::nullopt, true};
 }
 
 LolaMethodInstanceDeployment MakeLolaMethodInstanceDeployment(
     const std::optional<LolaMethodInstanceDeployment::QueueSize> queue_size) noexcept
 {
-    const LolaMethodInstanceDeployment unit{queue_size};
+    const LolaMethodInstanceDeployment unit{queue_size, true};
     return unit;
 }
 

score/mw/com/impl/plumbing/proxy_method_binding_factory_test.cpp

@@ -136,31 +136,6 @@ TYPED_TEST(ProxyMethodFactoryTypedFixture, ConstructingLolaMethodBindingWhichIsD
     EXPECT_EQ(proxy_method.value(), nullptr);
 }
 
-TYPED_TEST(ProxyMethodFactoryTypedFixture, ConstructingLolaMethodBindingWithEmptyEnabledFieldTerminates)
-{
-    // Given a handle to a valid lola deployment which contains a method with empty Enabled field
-    const LolaServiceInstanceDeployment lola_service_instance_deployment_with_empty_enabled_method{
-        LolaServiceInstanceId{kInstanceId},
-        {},
-        {},
-        {{kDummyMethodName, LolaMethodInstanceDeployment{kQueueSize, std::nullopt}}}};
-    ConfigurationStore config_store_with_empty_enabled_method{
-        kInstanceSpecifier,
-        make_ServiceIdentifierType("/a/service/somewhere/out/there", 13U, 37U),
-        kQualityType,
-        kLolaServiceTypeDeployment,
-        lola_service_instance_deployment_with_empty_enabled_method};
-    const auto handle = config_store_with_empty_enabled_method.GetHandle();
-    this->InitialiseProxyWithConstructor(handle.GetInstanceIdentifier());
-
-    // when creating a ProxyMethod using MethodBindingFactory
-    // Then the program terminates
-    using MethodSignature = TypeParam;
-    EXPECT_DEATH(score::cpp::ignore = ProxyMethodBindingFactory<MethodSignature>::Create(
-                     handle, *this->proxy_, kDummyMethodName, MethodType::kMethod),
-                 ".*");
-}
-
 TYPED_TEST(ProxyMethodFactoryTypedFixture, ConstructingLolaMethodBindingWithInstanceDeploymentWithoutMethodTerminates)
 {
     // Given a handle to a valid lola deployment which does not contain the method

score/mw/com/impl/plumbing/skeleton_method_binding_factory_test.cpp

@@ -44,7 +44,7 @@ const LolaServiceInstanceDeployment kLolaServiceInstanceDeployment{
     LolaServiceInstanceId{kInstanceId},
     {},
     {},
-    {{kDummyMethodName, LolaMethodInstanceDeployment{kQueueSize}}}};
+    {{kDummyMethodName, LolaMethodInstanceDeployment{kQueueSize, true}}}};
 
 const LolaServiceTypeDeployment kLolaServiceTypeDeployment{kServiceId, {}, {}, {{kDummyMethodName, kDummyMethodId}}};