wirenboard / wb-mqtt-smartweb / 2

Committed 31 Jul 2026 10:01AM UTC coverage: 33.897% (-0.4%) from 34.328%

Build # 2

Build Type

Pull #40

github

Specific Base 476708

Committed by

ekateluv

Commit Message

Lower coverage threshold to 33

Pull Request Pull Request #40: Use exported vars instead of MAKEFLAGS for coverage options

Coverage Stats

307 of 744 branches covered (41.26%)

501 of 1478 relevant lines covered (33.9%)

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

wirenboard / wb-mqtt-smartweb / 2

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