Feat: Native SDK unit tests part 1 (Updated)

src/sdks/core/src/cpp/sdk/cpptest/CMakeLists.txt

@@ -39,8 +39,6 @@ endif ()
 
 find_package(WPEFramework CONFIG REQUIRED)
 find_package(${NAMESPACE}Core CONFIG REQUIRED)
-find_package(Firebolt CONFIG REQUIRED)
-find_package(${FIREBOLT_NAMESPACE}SDK CONFIG REQUIRED)
 
 set(TESTAPP TestFireboltCore)
 
@@ -52,13 +50,13 @@ target_link_libraries(${TESTAPP}
     PRIVATE
         ${NAMESPACE}Core::${NAMESPACE}Core
         ${FIREBOLT_NAMESPACE}SDK::${FIREBOLT_NAMESPACE}SDK
+        nlohmann_json_schema_validator
+        gtest_main
 )
 
 target_include_directories(${TESTAPP}
     PRIVATE
-        $<BUILD_INTERFACE:${FIREBOLT_PATH}/usr/include/${FIREBOLT_NAMESPACE}SDK>
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SRC_DIR}/>
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SRC_DIR}/../>
+        $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include/>
 )
 
 if (POLYMORPHICS_REDUCER_METHODS)
@@ -79,3 +77,34 @@ add_custom_command(
     COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/${FIREBOLT_NAMESPACE}/usr/bin
         COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_BINARY_DIR}/${TESTAPP} ${CMAKE_BINARY_DIR}/${FIREBOLT_NAMESPACE}/usr/bin
 )
+
+if(ENABLE_UNIT_TESTS)
+    set(UNIT_TESTS_APP FireboltCoreUnitTests)
+
+    message("Setup ${UNIT_TESTS_APP}")
+
+    file(GLOB UNIT_TESTS "unit/*")
+
+    add_executable(${UNIT_TESTS_APP} 
+        CoreSDKTest.cpp
+        Unit.cpp
+        ${UNIT_TESTS}
+    )
+
+    link_directories(${CMAKE_SOURCE_DIR}/../../Thunder/install/usr/lib/)
+    target_link_libraries(${UNIT_TESTS_APP}
+        PRIVATE
+            ${NAMESPACE}Core::${NAMESPACE}Core
+            ${FIREBOLT_NAMESPACE}SDK::${FIREBOLT_NAMESPACE}SDK
+            nlohmann_json_schema_validator
+            gtest_main
+    )
+
+    target_include_directories(${UNIT_TESTS_APP}
+        PRIVATE
+            $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include/>
+    )
+
+    include(GoogleTest)
+    gtest_discover_tests(${UNIT_TESTS_APP})
+endif()

src/sdks/core/src/cpp/sdk/cpptest/Unit.cpp

@@ -0,0 +1,10 @@
+#include "gtest/gtest.h"
+#include "CoreSDKTest.h"
+
+int main(int argc, char **argv)
+{
+    std::string url = "ws://localhost:9998";
+    CoreSDKTest::CreateFireboltInstance(url);
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

src/sdks/core/src/cpp/sdk/cpptest/unit/accessibilityTest.cpp

@@ -0,0 +1,220 @@
+#include "unit.h"
+
+class AccessibilityTest : public ::testing::Test
+{
+protected:
+    JsonEngine *jsonEngine;
+    Firebolt::Error error = Firebolt::Error::None;
+
+    void SetUp() override
+    {
+        jsonEngine = new JsonEngine();
+    }
+
+    void TearDown() override
+    {
+        delete jsonEngine;
+    }
+
+    std::string fontFamilyToString(Firebolt::Accessibility::FontFamily fontFamily)
+    {
+        std::string str = "";
+        switch (fontFamily)
+        {
+        case Firebolt::Accessibility::FontFamily::MONOSPACED_SERIF:
+            str = "monospaced_serif";
+            break;
+        case Firebolt::Accessibility::FontFamily::PROPORTIONAL_SERIF:
+            str = "proportional_serif";
+            break;
+        case Firebolt::Accessibility::FontFamily::MONOSPACED_SANSERIF:
+            str = "monospaced_sanserif";
+            break;
+        case Firebolt::Accessibility::FontFamily::PROPORTIONAL_SANSERIF:
+            str = "proportional_sanserif";
+            break;
+        case Firebolt::Accessibility::FontFamily::SMALLCAPS:
+            str = "smallcaps";
+            break;
+        case Firebolt::Accessibility::FontFamily::CURSIVE:
+            str = "cursive";
+            break;
+        case Firebolt::Accessibility::FontFamily::CASUAL:
+            str = "casual";
+            break;
+        default:
+            str = "unknown";
+        }
+        return str;
+    }
+
+    std::string fontEdgeToString(Firebolt::Accessibility::FontEdge fontEdge)
+    {
+        std::string str = "";
+        switch (fontEdge)
+        {
+        case Firebolt::Accessibility::FontEdge::NONE:
+            str = "none";
+            break;
+        case Firebolt::Accessibility::FontEdge::RAISED:
+            str = "raised";
+            break;
+        case Firebolt::Accessibility::FontEdge::DEPRESSED:
+            str = "depressed";
+            break;
+        case Firebolt::Accessibility::FontEdge::UNIFORM:
+            str = "uniform";
+            break;
+        case Firebolt::Accessibility::FontEdge::DROP_SHADOW_LEFT:
+            str = "drop_shadow_left";
+            break;
+        case Firebolt::Accessibility::FontEdge::DROP_SHADOW_RIGHT:
+            str = "drop_shadow_right";
+            break;
+        default:
+            str = "unknown";
+        }
+        return str;
+    }
+};
+
+TEST_F(AccessibilityTest, ClosedCaptions)
+{
+    nlohmann::json_abi_v3_11_3::json expectedValues = nlohmann::json::parse(jsonEngine->get_value("Accessibility.closedCaptions"));
+
+    Firebolt::Accessibility::ClosedCaptionsSettings closedCaptions = Firebolt::IFireboltAccessor::Instance().AccessibilityInterface().closedCaptions(&error);
+
+    EXPECT_EQ(error, Firebolt::Error::None) << "Failed to retrieve closedCaptions from Accessibility.closedCaptions() method";
+    EXPECT_EQ(closedCaptions.enabled, expectedValues["enabled"]);
+
+    if (closedCaptions.styles.has_value()) {
+        const auto& styles = closedCaptions.styles.value();
+
+        if (styles.backgroundColor.has_value())
+            EXPECT_EQ(styles.backgroundColor.value(), expectedValues["styles"]["backgroundColor"]);
+
+        if (styles.backgroundOpacity.has_value())
+            EXPECT_EQ(styles.backgroundOpacity.value(), expectedValues["styles"]["backgroundOpacity"]);
+
+        if (styles.fontColor.has_value())
+            EXPECT_EQ(styles.fontColor.value(), expectedValues["styles"]["fontColor"]);
+
+        if (styles.fontEdge.has_value())
+            EXPECT_EQ(fontEdgeToString(styles.fontEdge.value()), expectedValues["styles"]["fontEdge"]);
+
+        if (styles.fontEdgeColor.has_value())
+            EXPECT_EQ(styles.fontEdgeColor.value(), expectedValues["styles"]["fontEdgeColor"]);
+
+        if (styles.fontFamily.has_value())
+            EXPECT_EQ(fontFamilyToString(styles.fontFamily.value()), expectedValues["styles"]["fontFamily"]);
+
+        if (styles.fontOpacity.has_value())
+            EXPECT_EQ(styles.fontOpacity.value(), expectedValues["styles"]["fontOpacity"]);
+
+        if (styles.fontSize.has_value())
+            EXPECT_EQ(styles.fontSize.value(), expectedValues["styles"]["fontSize"]);
+
+        if (styles.textAlign.has_value())
+            EXPECT_EQ(styles.textAlign.value(), expectedValues["styles"]["textAlign"]);
+
+        if (styles.textAlignVertical.has_value())
+            EXPECT_EQ(styles.textAlignVertical.value(), expectedValues["styles"]["textAlignVertical"]);
+
+        if (styles.windowColor.has_value())
+            EXPECT_EQ(styles.windowColor.value(), expectedValues["styles"]["windowColor"]);
+
+        if (styles.windowOpacity.has_value())
+            EXPECT_EQ(styles.windowOpacity.value(), expectedValues["styles"]["windowOpacity"]);
+    }
+
+    EXPECT_EQ(closedCaptions.preferredLanguages.value()[0], expectedValues["preferredLanguages"][0]);
+    EXPECT_EQ(closedCaptions.preferredLanguages.value()[1], expectedValues["preferredLanguages"][1]);
+}
+
+TEST_F(AccessibilityTest, ClosedCaptionsSettings)
+{
+    nlohmann::json_abi_v3_11_3::json expectedValues = nlohmann::json::parse(jsonEngine->get_value("Accessibility.closedCaptionsSettings"));
+
+    Firebolt::Accessibility::ClosedCaptionsSettings closedCaptionSettings = Firebolt::IFireboltAccessor::Instance().AccessibilityInterface().closedCaptionsSettings(&error);
+
+    EXPECT_EQ(error, Firebolt::Error::None) << "Failed to retrieve closedCaptionSettings from Accessibility.closedCaptionSettings() method";
+    EXPECT_EQ(closedCaptionSettings.enabled, expectedValues["enabled"]);
+
+    if (closedCaptionSettings.styles.has_value()) {
+        const auto& styles = closedCaptionSettings.styles.value();
+
+        if (styles.backgroundColor.has_value())
+            EXPECT_EQ(styles.backgroundColor.value(), expectedValues["styles"]["backgroundColor"]);
+
+        if (styles.backgroundOpacity.has_value())
+            EXPECT_EQ(styles.backgroundOpacity.value(), expectedValues["styles"]["backgroundOpacity"]);
+
+        if (styles.fontColor.has_value())
+            EXPECT_EQ(styles.fontColor.value(), expectedValues["styles"]["fontColor"]);
+
+        if (styles.fontEdge.has_value())
+            EXPECT_EQ(fontEdgeToString(styles.fontEdge.value()), expectedValues["styles"]["fontEdge"]);
+
+        if (styles.fontEdgeColor.has_value())
+            EXPECT_EQ(styles.fontEdgeColor.value(), expectedValues["styles"]["fontEdgeColor"]);
+
+        if (styles.fontFamily.has_value())
+            EXPECT_EQ(fontFamilyToString(styles.fontFamily.value()), expectedValues["styles"]["fontFamily"]);
+
+        if (styles.fontOpacity.has_value())
+            EXPECT_EQ(styles.fontOpacity.value(), expectedValues["styles"]["fontOpacity"]);
+
+        if (styles.fontSize.has_value())
+            EXPECT_EQ(styles.fontSize.value(), expectedValues["styles"]["fontSize"]);
+
+        if (styles.textAlign.has_value())
+            EXPECT_EQ(styles.textAlign.value(), expectedValues["styles"]["textAlign"]);
+
+        if (styles.textAlignVertical.has_value())
+            EXPECT_EQ(styles.textAlignVertical.value(), expectedValues["styles"]["textAlignVertical"]);
+
+        if (styles.windowColor.has_value())
+            EXPECT_EQ(styles.windowColor.value(), expectedValues["styles"]["windowColor"]);
+
+        if (styles.windowOpacity.has_value())
+            EXPECT_EQ(styles.windowOpacity.value(), expectedValues["styles"]["windowOpacity"]);
+    }
+
+    EXPECT_EQ(closedCaptionSettings.preferredLanguages.value()[0], expectedValues["preferredLanguages"][0]);
+    EXPECT_EQ(closedCaptionSettings.preferredLanguages.value()[1], expectedValues["preferredLanguages"][1]);
+}
+
+TEST_F(AccessibilityTest, VoiceGuidance)
+{
+    nlohmann::json_abi_v3_11_3::json expectedValues = nlohmann::json::parse(jsonEngine->get_value("Accessibility.voiceGuidance"));
+
+    auto voiceGuidance = Firebolt::IFireboltAccessor::Instance().AccessibilityInterface().voiceGuidance(&error);
+
+    EXPECT_EQ(error, Firebolt::Error::None) << "Failed to retrieve voiceGuidance from Accessibility.voiceGuidance() method";
+
+    EXPECT_EQ(voiceGuidance.enabled, expectedValues["enabled"]);
+    EXPECT_EQ(voiceGuidance.speed, expectedValues["speed"]);
+}
+
+TEST_F(AccessibilityTest, VoiceGuidanceSettings)
+{
+    nlohmann::json_abi_v3_11_3::json expectedValues = nlohmann::json::parse(jsonEngine->get_value("Accessibility.voiceGuidanceSettings"));
+
+    auto voiceGuidanceSettings = Firebolt::IFireboltAccessor::Instance().AccessibilityInterface().voiceGuidanceSettings(&error);
+
+    EXPECT_EQ(error, Firebolt::Error::None) << "Failed to retrieve voiceGuidanceSettings from Accessibility.voiceGuidanceSettings() method";
+
+    EXPECT_EQ(voiceGuidanceSettings.enabled, expectedValues["enabled"]);
+    EXPECT_EQ(voiceGuidanceSettings.speed, expectedValues["speed"]);
+}
+
+TEST_F(AccessibilityTest, AudioDescriptionSettings)
+{
+    nlohmann::json_abi_v3_11_3::json expectedValues = nlohmann::json::parse(jsonEngine->get_value("Accessibility.audioDescriptionSettings"));
+
+    auto audioDescriptionSettings = Firebolt::IFireboltAccessor::Instance().AccessibilityInterface().audioDescriptionSettings(&error);
+
+    EXPECT_EQ(error, Firebolt::Error::None) << "Failed to retrieve audioDescriptionSettings from Accessibility.audioDescriptionSettings() method";
+
+    EXPECT_EQ(audioDescriptionSettings.enabled, expectedValues["enabled"]);
+}

src/sdks/core/src/cpp/sdk/cpptest/unit/accountTest.cpp

@@ -0,0 +1,38 @@
+#include "unit.h"
+
+class AccountTest : public ::testing::Test
+{
+protected:
+	JsonEngine *jsonEngine;
+	Firebolt::Error error = Firebolt::Error::None;
+
+	void SetUp() override
+	{
+		jsonEngine = new JsonEngine();
+	}
+
+	void TearDown() override
+	{
+		delete jsonEngine;
+	}
+};
+
+TEST_F(AccountTest, Id)
+{
+	nlohmann::json_abi_v3_11_3::json expectedValues = nlohmann::json::parse(jsonEngine->get_value("Account.id"));
+
+	std::string account_id = Firebolt::IFireboltAccessor::Instance().AccountInterface().id(&error);
+
+	EXPECT_EQ(error, Firebolt::Error::None) << "Failed to retrieve account_id from Account.id() method";
+	EXPECT_EQ(account_id, expectedValues);
+}
+
+TEST_F(AccountTest, Uid)
+{
+	nlohmann::json_abi_v3_11_3::json expectedValues = nlohmann::json::parse(jsonEngine->get_value("Account.uid"));
+
+	std::string account_uid = Firebolt::IFireboltAccessor::Instance().AccountInterface().uid(&error);
+
+	EXPECT_EQ(error, Firebolt::Error::None) << "Failed to retrieve account_uid from Account.uid() method";
+	EXPECT_EQ(account_uid, expectedValues);
+}