wirenboard / wb-mqtt-smartweb / 47

Committed 31 Jul 2026 10:42AM UTC coverage: 33.897% (-0.8%) from 34.703%

Build # 47

Build Type

push

github

Committed by

web-flow

Commit Message

Use exported vars instead of MAKEFLAGS for coverage options (#40)

Coverage Stats

307 of 744 branches covered (41.26%)

501 of 1478 relevant lines covered (33.9%)

10.02 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.3

/test/config.test.cpp

#include "config_parser.h"

#include <gtest/gtest.h>
#include <vector>

#include <wblib/json_utils.h>
#include <wblib/testing/testlog.h>

using namespace WBMQTT;

namespace
{

    struct TestClassParameterSample
    {
        uint32_t id;
        std::string name;
        std::string type;
        uint32_t order;
        std::string programClassName;
        std::string codecName;
        bool readOnly;
    };
}

class TLoadConfigTest: public Testing::TLoggedFixture
{
protected:
    std::string TestRootDir;
    std::string SchemaFile;
    std::string ClassSchemaFile;

    void SetUp()
    {
        TestRootDir = Testing::TLoggedFixture::GetDataFilePath("config_test_data");
        SchemaFile = TestRootDir + "/../../wb-mqtt-smartweb.schema.json";
        ClassSchemaFile = TestRootDir + "/../../wb-mqtt-smartweb-class.schema.json";
    }

    std::shared_ptr<TSmartWebToMqttConfig> GetTestConfig()
    {
        auto classJson = WBMQTT::JSON::Parse(TestRootDir + "/classes/ROOM_DEVICE.json");
        auto pConfig = std::make_shared<TSmartWebToMqttConfig>();
        LoadSmartWebClass(*pConfig, classJson, TDeviceClassSource::USER);
        EXPECT_EQ(1, pConfig->Classes.size());
        return pConfig;
    }

    void ParameterEqHelper(const TestClassParameterSample& sample, const TSmartWebParameter& parameter)
    {
        EXPECT_EQ(sample.id, parameter.Id);
        EXPECT_EQ(sample.name, parameter.Name);
        EXPECT_EQ(sample.type, parameter.Type);
        EXPECT_EQ(sample.order, parameter.Order);
        EXPECT_EQ(sample.programClassName, parameter.ProgramClass->Name);
        EXPECT_EQ(sample.codecName, parameter.Codec->GetName());
        EXPECT_EQ(sample.readOnly, parameter.ReadOnly);
    }
};

TEST_F(TLoadConfigTest, ClassValidation)
{
    auto classSchema = WBMQTT::JSON::Parse(ClassSchemaFile);

    auto classJsonGood = WBMQTT::JSON::Parse(TestRootDir + "/classes/ROOM_DEVICE.json");
    WBMQTT::JSON::Validate(classJsonGood, classSchema);

    // missing fields
    for (size_t i = 1; i <= 8; ++i) {
        auto classJsonBad = WBMQTT::JSON::Parse(TestRootDir + "/classes/bad/bad" + std::to_string(i) + ".json");
        ASSERT_THROW(WBMQTT::JSON::Validate(classJsonBad, classSchema), std::runtime_error) << i;
    }
}

TEST_F(TLoadConfigTest, SmartWebToMqttConfigWoDat)
{
    auto classJson = WBMQTT::JSON::Parse(TestRootDir + "/classes/ROOM_DEVICE.json");
    TSmartWebToMqttConfig config;
    LoadSmartWebClass(config, classJson, TDeviceClassSource::USER);
    ASSERT_EQ(1, config.Classes.size());
    auto c = config.Classes.begin();
    const auto id = c->first;
    const auto smartWebClass = c->second;
    EXPECT_EQ(5, id);
    EXPECT_EQ("ROOM_DEVICE", smartWebClass->Name);
    EXPECT_EQ(5, smartWebClass->Type);
    ASSERT_EQ(1, smartWebClass->ParentClasses.size());
    auto parentClassIt = smartWebClass->ParentClasses.begin();
    EXPECT_EQ("PROGRAM", *parentClassIt);
}

TEST_F(TLoadConfigTest, SmartWebToMqttConfigInputs)
{
    auto config = GetTestConfig();
    const auto smartWebClass = config->Classes.begin()->second;

    EXPECT_EQ(6, smartWebClass->Inputs.size());
    auto input = smartWebClass->Inputs.at(2);

    TestClassParameterSample sample = {.id = 2,
                                       .name = "floorT",
                                       .type = "temperature",
                                       .order = 2,
                                       .programClassName = "ROOM_DEVICE",
                                       .codecName = "TSensorCodec",
                                       .readOnly = true};

    ParameterEqHelper(sample, *input);
}

TEST_F(TLoadConfigTest, SmartWebToMqttConfigOutputs)
{
    auto config = GetTestConfig();
    const auto smartWebClass = config->Classes.begin()->second;

    EXPECT_EQ(7, smartWebClass->Outputs.size());
    auto output = smartWebClass->Outputs.at(2);

    TestClassParameterSample sample = {.id = 2,
                                       .name = "addValve",
                                       .type = "relay",
                                       .order = 9,
                                       .programClassName = "ROOM_DEVICE",
                                       .codecName = "TOutputCodec",
                                       .readOnly = true};

    ParameterEqHelper(sample, *output);
}

TEST_F(TLoadConfigTest, SmartWebToMqttConfigParameters)
{
    auto config = GetTestConfig();
    const auto smartWebClass = config->Classes.begin()->second;

    EXPECT_EQ(34, smartWebClass->Parameters.size());
    auto parameter = smartWebClass->Parameters.at(2);

    TestClassParameterSample sample = {.id = 2,
                                       .name = "roomReducedTemperature",
                                       .type = "temperature",
                                       .order = 16,
                                       .programClassName = "ROOM_DEVICE",
                                       .codecName = "TIntCodec<signed 2, 10>",
                                       .readOnly = false};

    ParameterEqHelper(sample, *parameter);
}

TEST_F(TLoadConfigTest, LoadConfig)
{
    TConfig config;
    EXPECT_NO_THROW(LoadConfig(config,
                               TestRootDir + "/test_config.json",
                               TestRootDir + "/classes",
                               TestRootDir + "/builtin_classes",
                               SchemaFile,
                               ClassSchemaFile));

    EXPECT_TRUE(config.Debug);
    EXPECT_EQ("can1", config.InterfaceName);
    EXPECT_EQ(123, config.SmartWebToMqtt.PollInterval.count());

    EXPECT_EQ(3, config.SmartWebToMqtt.Classes.size());
    auto outdoorSensorDeviceClass = config.SmartWebToMqtt.Classes[2];

    ASSERT_NE(nullptr, outdoorSensorDeviceClass);
    EXPECT_EQ("OUTDOOR_SENSOR", outdoorSensorDeviceClass->Name);
    EXPECT_EQ(1, outdoorSensorDeviceClass->Inputs.size());
    EXPECT_EQ(0, outdoorSensorDeviceClass->Outputs.size());
    EXPECT_EQ(1, outdoorSensorDeviceClass->Parameters.size());

    auto roomDeviceClass = config.SmartWebToMqtt.Classes[5];
    ASSERT_NE(nullptr, roomDeviceClass);
    EXPECT_EQ("ROOM_DEVICE", roomDeviceClass->Name);
    EXPECT_EQ(6, roomDeviceClass->Inputs.size());
    EXPECT_EQ(7, roomDeviceClass->Outputs.size());
    EXPECT_EQ(34, roomDeviceClass->Parameters.size());

    auto temperatureSourceClass = config.SmartWebToMqtt.Classes[6];
    ASSERT_NE(nullptr, temperatureSourceClass);
    EXPECT_EQ("TEMPERATURE_SOURCE", temperatureSourceClass->Name);
    EXPECT_EQ(0, temperatureSourceClass->Inputs.size());
    EXPECT_EQ(0, temperatureSourceClass->Outputs.size());
    EXPECT_EQ(6, temperatureSourceClass->Parameters.size());
}

1	#include "config_parser.h"
2
3	#include <gtest/gtest.h>
4	#include <vector>
5
6	#include <wblib/json_utils.h>
7	#include <wblib/testing/testlog.h>
8
9	using namespace WBMQTT;
10
11	namespace
12	{
13
14	struct TestClassParameterSample
15	{
16	uint32_t id;
17	std::string name;
18	std::string type;
19	uint32_t order;
20	std::string programClassName;
21	std::string codecName;
22	bool readOnly;
23	};
24	}
25
26	class TLoadConfigTest: public Testing::TLoggedFixture
27	{
28	protected:
29	std::string TestRootDir;
30	std::string SchemaFile;
31	std::string ClassSchemaFile;
32
33	void SetUp()	6✔
34	{
35	TestRootDir = Testing::TLoggedFixture::GetDataFilePath("config_test_data");	6✔
36	SchemaFile = TestRootDir + "/../../wb-mqtt-smartweb.schema.json";	6✔
37	ClassSchemaFile = TestRootDir + "/../../wb-mqtt-smartweb-class.schema.json";	6✔
38	}	6✔
39
40	std::shared_ptr<TSmartWebToMqttConfig> GetTestConfig()	3✔
41	{
42	auto classJson = WBMQTT::JSON::Parse(TestRootDir + "/classes/ROOM_DEVICE.json");	3✔
43	auto pConfig = std::make_shared<TSmartWebToMqttConfig>();	3✔
44	LoadSmartWebClass(*pConfig, classJson, TDeviceClassSource::USER);	3✔
45	EXPECT_EQ(1, pConfig->Classes.size());	3✔
46	return pConfig;	3✔
47	}	3✔
48
49	void ParameterEqHelper(const TestClassParameterSample& sample, const TSmartWebParameter& parameter)	3✔
50	{
51	EXPECT_EQ(sample.id, parameter.Id);	3✔
52	EXPECT_EQ(sample.name, parameter.Name);	3✔
53	EXPECT_EQ(sample.type, parameter.Type);	3✔
54	EXPECT_EQ(sample.order, parameter.Order);	3✔
55	EXPECT_EQ(sample.programClassName, parameter.ProgramClass->Name);	3✔
56	EXPECT_EQ(sample.codecName, parameter.Codec->GetName());	3✔
57	EXPECT_EQ(sample.readOnly, parameter.ReadOnly);	3✔
58	}	3✔
59	};
60
61	TEST_F(TLoadConfigTest, ClassValidation)	8✔
62	{
63	auto classSchema = WBMQTT::JSON::Parse(ClassSchemaFile);	2✔
64
65	auto classJsonGood = WBMQTT::JSON::Parse(TestRootDir + "/classes/ROOM_DEVICE.json");	2✔
66	WBMQTT::JSON::Validate(classJsonGood, classSchema);	2✔
67
68	// missing fields
69	for (size_t i = 1; i <= 8; ++i) {	18✔
70	auto classJsonBad = WBMQTT::JSON::Parse(TestRootDir + "/classes/bad/bad" + std::to_string(i) + ".json");	16✔
71	ASSERT_THROW(WBMQTT::JSON::Validate(classJsonBad, classSchema), std::runtime_error) << i;	16✔
72	}	16✔
73	}	2✔
74
75	TEST_F(TLoadConfigTest, SmartWebToMqttConfigWoDat)	8✔
76	{
77	auto classJson = WBMQTT::JSON::Parse(TestRootDir + "/classes/ROOM_DEVICE.json");	2✔
78	TSmartWebToMqttConfig config;	2✔
79	LoadSmartWebClass(config, classJson, TDeviceClassSource::USER);	2✔
80	ASSERT_EQ(1, config.Classes.size());	2✔
81	auto c = config.Classes.begin();	2✔
82	const auto id = c->first;	2✔
83	const auto smartWebClass = c->second;	2✔
84	EXPECT_EQ(5, id);	2✔
85	EXPECT_EQ("ROOM_DEVICE", smartWebClass->Name);	2✔
86	EXPECT_EQ(5, smartWebClass->Type);	2✔
87	ASSERT_EQ(1, smartWebClass->ParentClasses.size());	2✔
88	auto parentClassIt = smartWebClass->ParentClasses.begin();	2✔
89	EXPECT_EQ("PROGRAM", *parentClassIt);	2✔
90	}	2✔
91
92	TEST_F(TLoadConfigTest, SmartWebToMqttConfigInputs)	8✔
93	{
94	auto config = GetTestConfig();	2✔
95	const auto smartWebClass = config->Classes.begin()->second;	2✔
96
97	EXPECT_EQ(6, smartWebClass->Inputs.size());	2✔
98	auto input = smartWebClass->Inputs.at(2);	2✔
99
100	TestClassParameterSample sample = {.id = 2,	2✔
101	.name = "floorT",	×
102	.type = "temperature",	2✔
103	.order = 2,
104	.programClassName = "ROOM_DEVICE",	2✔
105	.codecName = "TSensorCodec",	2✔
106	.readOnly = true};	10✔
107
108	ParameterEqHelper(sample, *input);	2✔
109	}	2✔
110
111	TEST_F(TLoadConfigTest, SmartWebToMqttConfigOutputs)	8✔
112	{
113	auto config = GetTestConfig();	2✔
114	const auto smartWebClass = config->Classes.begin()->second;	2✔
115
116	EXPECT_EQ(7, smartWebClass->Outputs.size());	2✔
117	auto output = smartWebClass->Outputs.at(2);	2✔
118
119	TestClassParameterSample sample = {.id = 2,	2✔
120	.name = "addValve",	×
121	.type = "relay",	2✔
122	.order = 9,
123	.programClassName = "ROOM_DEVICE",	2✔
124	.codecName = "TOutputCodec",	2✔
125	.readOnly = true};	10✔
126
127	ParameterEqHelper(sample, *output);	2✔
128	}	2✔
129
130	TEST_F(TLoadConfigTest, SmartWebToMqttConfigParameters)	8✔
131	{
132	auto config = GetTestConfig();	2✔
133	const auto smartWebClass = config->Classes.begin()->second;	2✔
134
135	EXPECT_EQ(34, smartWebClass->Parameters.size());	2✔
136	auto parameter = smartWebClass->Parameters.at(2);	2✔
137
138	TestClassParameterSample sample = {.id = 2,	2✔
139	.name = "roomReducedTemperature",	×
140	.type = "temperature",	2✔
141	.order = 16,
142	.programClassName = "ROOM_DEVICE",	2✔
143	.codecName = "TIntCodec<signed 2, 10>",	2✔
144	.readOnly = false};	10✔
145
146	ParameterEqHelper(sample, *parameter);	2✔
147	}	2✔
148
149	TEST_F(TLoadConfigTest, LoadConfig)	8✔
150	{
151	TConfig config;	2✔
152	EXPECT_NO_THROW(LoadConfig(config,	2✔
153	TestRootDir + "/test_config.json",
154	TestRootDir + "/classes",
155	TestRootDir + "/builtin_classes",
156	SchemaFile,
157	ClassSchemaFile));	2✔
158
159	EXPECT_TRUE(config.Debug);	2✔
160	EXPECT_EQ("can1", config.InterfaceName);	2✔
161	EXPECT_EQ(123, config.SmartWebToMqtt.PollInterval.count());	2✔
162
163	EXPECT_EQ(3, config.SmartWebToMqtt.Classes.size());	2✔
164	auto outdoorSensorDeviceClass = config.SmartWebToMqtt.Classes[2];	2✔
165
166	ASSERT_NE(nullptr, outdoorSensorDeviceClass);	2✔
167	EXPECT_EQ("OUTDOOR_SENSOR", outdoorSensorDeviceClass->Name);	2✔
168	EXPECT_EQ(1, outdoorSensorDeviceClass->Inputs.size());	2✔
169	EXPECT_EQ(0, outdoorSensorDeviceClass->Outputs.size());	2✔
170	EXPECT_EQ(1, outdoorSensorDeviceClass->Parameters.size());	2✔
171
172	auto roomDeviceClass = config.SmartWebToMqtt.Classes[5];	2✔
173	ASSERT_NE(nullptr, roomDeviceClass);	2✔
174	EXPECT_EQ("ROOM_DEVICE", roomDeviceClass->Name);	2✔
175	EXPECT_EQ(6, roomDeviceClass->Inputs.size());	2✔
176	EXPECT_EQ(7, roomDeviceClass->Outputs.size());	2✔
177	EXPECT_EQ(34, roomDeviceClass->Parameters.size());	2✔
178
179	auto temperatureSourceClass = config.SmartWebToMqtt.Classes[6];	2✔
180	ASSERT_NE(nullptr, temperatureSourceClass);	2✔
181	EXPECT_EQ("TEMPERATURE_SOURCE", temperatureSourceClass->Name);	2✔
182	EXPECT_EQ(0, temperatureSourceClass->Inputs.size());	2✔
183	EXPECT_EQ(0, temperatureSourceClass->Outputs.size());	2✔
184	EXPECT_EQ(6, temperatureSourceClass->Parameters.size());	2✔
185	}	2✔

wirenboard / wb-mqtt-smartweb / 47

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous