Tatsh / ifup-systemd-resolved / #36

Committed 24 Jun 2025 01:12AM UTC coverage: 95.092% (-4.9%) from 100.0%

Build # #36

Build Type

push

travis-ci

Committed by

Tatsh

Commit Message

More build fixes

Run Details

310 of 326 relevant lines covered (95.09%)

1.88 hits per line

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

94.27

/src/test.cpp

#include <QtDBus/QtDBus>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "up.h"

using ::testing::_;
using ::testing::Return;

TEST(GenerateAddressesTests, EmptyVars) {
    auto x = generateAddresses();
    ASSERT_EQ(x.length(), 0);
}

TEST(GenerateAddressesTests, OneVarIPV4) {
    qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));
    auto x = generateAddresses();
    ASSERT_EQ(x.length(), 1);
    ASSERT_EQ(x[0].family, AF_INET);
}

TEST(GenerateAddressesTests, OneVarIPV6) {
    qputenv("DNS1", QByteArrayLiteral("2001:db8::ff00:42:8329"));
    auto x = generateAddresses();
    ASSERT_EQ(x.length(), 1);
    ASSERT_EQ(x[0].family, AF_INET6);
}

TEST(GenerateAddressesTests, TwoVarsMixed) {
    qputenv("DNS1", QByteArrayLiteral("2001:db8::ff00:42:8329"));
    qputenv("DNS2", QByteArrayLiteral("20.0.0.1"));
    auto x = generateAddresses();
    ASSERT_EQ(x.length(), 2);
    ASSERT_EQ(x[0].family, AF_INET6);
    ASSERT_EQ(x[1].family, AF_INET);
}

TEST(GenerateDomainsTests, EmptyVars) {
    auto x = generateDomains();
    ASSERT_EQ(x.length(), 0);
}

TEST(GenerateDomainsTests, Basic) {
    qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));
    auto x = generateDomains();
    ASSERT_EQ(x.length(), 2);
    ASSERT_EQ(x[0].domain, QStringLiteral("example.com"));
    ASSERT_EQ(x[1].domain, QStringLiteral("example.org"));
}

class MockReply {
public:
    void waitForFinished() {
    }
    bool isError() {
        return error_;
    }
    void setError(bool error) {
        error_ = error;
    }

private:
    bool error_ = false;
};

class MockResolve1Manager {
public:
    MOCK_METHOD(MockReply, SetLinkDNS, (int, const LinkDnsIpList &), (const));
    MOCK_METHOD(MockReply, SetLinkDomains, (int, const LinkDomainList &), (const));
    MOCK_METHOD(MockReply, SetLinkDNSSEC, (int, const QString &), (const));
    MOCK_METHOD(bool, isValid, (), (const));
    MOCK_METHOD(QString, lastError, (), (const));
};

class MockUp : public Up<MockResolve1Manager> {
public:
    MockUp(MockResolve1Manager &iface) : Up<MockResolve1Manager>(iface) {
    }
    MOCK_METHOD(bool, doSetLinkDns, (int), (override));
    MOCK_METHOD(bool, doSetLinkDomains, (int), (override));
    MOCK_METHOD(bool, doSetLinkDnssec, (int), (override));
};

TEST(DoSetLinkDnsTests, Failure) {
    qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));
    MockReply reply;
    reply.setError(true);
    MockResolve1Manager iface;
    Up<MockResolve1Manager> mup(iface);
    EXPECT_CALL(iface, SetLinkDNS(1, _)).WillOnce(Return(reply));
    ASSERT_FALSE(mup.doSetLinkDns(1));
}

TEST(DoSetLinkDnsTests, Success) {
    qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));
    MockReply reply;
    MockResolve1Manager iface;
    Up<MockResolve1Manager> mup(iface);
    EXPECT_CALL(iface, SetLinkDNS(1, _)).WillOnce(Return(reply));
    ASSERT_TRUE(mup.doSetLinkDns(1));
}

TEST(doSetLinkDomainsTests, Failure) {
    qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));
    MockReply reply;
    reply.setError(true);
    MockResolve1Manager iface;
    Up<MockResolve1Manager> mup(iface);
    EXPECT_CALL(iface, SetLinkDomains(1, _)).WillOnce(Return(reply));
    ASSERT_FALSE(mup.doSetLinkDomains(1));
}

TEST(doSetLinkDomainsTests, Success) {
    qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));
    MockReply reply;
    MockResolve1Manager iface;
    Up<MockResolve1Manager> mup(iface);
    EXPECT_CALL(iface, SetLinkDomains(1, _)).WillOnce(Return(reply));
    ASSERT_TRUE(mup.doSetLinkDomains(1));
}

TEST(doSetLinkDnssecTests, Failure) {
    qputenv("DNSSEC", QByteArrayLiteral("default"));
    MockReply reply;
    reply.setError(true);
    MockResolve1Manager iface;
    Up<MockResolve1Manager> mup(iface);
    EXPECT_CALL(iface, SetLinkDNSSEC(1, _)).WillOnce(Return(reply));
    ASSERT_FALSE(mup.doSetLinkDnssec(1));
}

TEST(doSetLinkDnssecTests, Success) {
    qputenv("DNSSEC", QByteArrayLiteral("default"));
    MockReply reply;
    MockResolve1Manager iface;
    Up<MockResolve1Manager> mup(iface);
    EXPECT_CALL(iface, SetLinkDNSSEC(1, _)).WillOnce(Return(reply));
    ASSERT_TRUE(mup.doSetLinkDnssec(1));
}

TEST(upTests, Success) {
    qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));
    qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));
    qputenv("DNSSEC", QByteArrayLiteral("default"));
    qputenv("PPP_IFACE", QByteArrayLiteral("lo"));
    MockResolve1Manager iface;
    MockUp mup(iface);
    int expectedDeviceIndex = QNetworkInterface::interfaceIndexFromName(QStringLiteral("lo"));
    EXPECT_CALL(iface, isValid()).WillOnce(Return(true));
    EXPECT_CALL(mup, doSetLinkDns(expectedDeviceIndex)).WillOnce(Return(true));
    EXPECT_CALL(mup, doSetLinkDomains(expectedDeviceIndex)).WillOnce(Return(true));
    EXPECT_CALL(mup, doSetLinkDnssec(expectedDeviceIndex)).WillOnce(Return(true));
    ASSERT_TRUE(mup.up());
}

TEST(upTests, Failure) {
    qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));
    qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));
    qputenv("DNSSEC", QByteArrayLiteral("default"));
    qputenv("PPP_IFACE", QByteArrayLiteral("lo"));
    MockResolve1Manager iface;
    MockUp mup(iface);
    int expectedDeviceIndex = QNetworkInterface::interfaceIndexFromName(QStringLiteral("lo"));
    EXPECT_CALL(iface, isValid()).WillOnce(Return(true));
    EXPECT_CALL(mup, doSetLinkDns(expectedDeviceIndex)).WillOnce(Return(true));
    EXPECT_CALL(mup, doSetLinkDomains(expectedDeviceIndex)).WillOnce(Return(true));
    EXPECT_CALL(mup, doSetLinkDnssec(expectedDeviceIndex)).WillOnce(Return(false));
    ASSERT_FALSE(mup.up());
}

TEST(upTests, FailureInvalidInterface) {
    qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));
    qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));
    qputenv("DNSSEC", QByteArrayLiteral("default"));
    qputenv("PPP_IFACE", QByteArrayLiteral("lo"));
    MockResolve1Manager iface;
    MockUp mup(iface);
    EXPECT_CALL(iface, isValid()).WillOnce(Return(false));
    ASSERT_FALSE(mup.up());
}

TEST(upTests, FailureInvalidDeviceIndex) {
    qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));
    qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));
    qputenv("DNSSEC", QByteArrayLiteral("default"));
    MockResolve1Manager iface;
    MockUp mup(iface);
    EXPECT_CALL(iface, isValid()).WillOnce(Return(true));
    ASSERT_FALSE(mup.up());
}

1	#include <QtDBus/QtDBus>
2	#include <gmock/gmock.h>
3	#include <gtest/gtest.h>
4
5	#include "up.h"
6
7	using ::testing::_;
8	using ::testing::Return;
9
10	TEST(GenerateAddressesTests, EmptyVars) {	3✔
11	auto x = generateAddresses();	1✔
12	ASSERT_EQ(x.length(), 0);	1✔
13	}
14		1✔
15	TEST(GenerateAddressesTests, OneVarIPV4) {	×
16	qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));	1✔
17	auto x = generateAddresses();	1✔
18	ASSERT_EQ(x.length(), 1);	1✔
19	ASSERT_EQ(x[0].family, AF_INET);
20	}
21		3✔
22	TEST(GenerateAddressesTests, OneVarIPV6) {	2✔
23	qputenv("DNS1", QByteArrayLiteral("2001:db8::ff00:42:8329"));	1✔
24	auto x = generateAddresses();	1✔
25	ASSERT_EQ(x.length(), 1);	2✔
26	ASSERT_EQ(x[0].family, AF_INET6);
27	}	1✔
28		×
29	TEST(GenerateAddressesTests, TwoVarsMixed) {	1✔
30	qputenv("DNS1", QByteArrayLiteral("2001:db8::ff00:42:8329"));	2✔
31	qputenv("DNS2", QByteArrayLiteral("20.0.0.1"));	1✔
32	auto x = generateAddresses();	1✔
33	ASSERT_EQ(x.length(), 2);	2✔
34	ASSERT_EQ(x[0].family, AF_INET6);
35	ASSERT_EQ(x[1].family, AF_INET);
36	}	3✔
37		2✔
38	TEST(GenerateDomainsTests, EmptyVars) {	1✔
39	auto x = generateDomains();	1✔
40	ASSERT_EQ(x.length(), 0);	2✔
41	}
42		1✔
43	TEST(GenerateDomainsTests, Basic) {	×
44	qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));	1✔
45	auto x = generateDomains();	2✔
46	ASSERT_EQ(x.length(), 2);	1✔
47	ASSERT_EQ(x[0].domain, QStringLiteral("example.com"));	1✔
48	ASSERT_EQ(x[1].domain, QStringLiteral("example.org"));	2✔
49	}
50
51	class MockReply {	3✔
52	public:	2✔
53	void waitForFinished() {	2✔
54	}	1✔
55	bool isError() {	1✔
56	return error_;	2✔
57	}	2✔
58	void setError(bool error) {
59	error_ = error;	1✔
60	}	×
61		1✔
62	private:	2✔
63	bool error_ = false;	2✔
64	};	1✔
65		1✔
66	class MockResolve1Manager {	2✔
67	public:	2✔
68	MOCK_METHOD(MockReply, SetLinkDNS, (int, const LinkDnsIpList &), (const));
69	MOCK_METHOD(MockReply, SetLinkDomains, (int, const LinkDomainList &), (const));
70	MOCK_METHOD(MockReply, SetLinkDNSSEC, (int, const QString &), (const));	3✔
71	MOCK_METHOD(bool, isValid, (), (const));	1✔
72	MOCK_METHOD(QString, lastError, (), (const));	1✔
73	};
74		1✔
75	class MockUp : public Up<MockResolve1Manager> {	×
76	public:	1✔
77	MockUp(MockResolve1Manager &iface) : Up<MockResolve1Manager>(iface) {	1✔
78	}	1✔
79	MOCK_METHOD(bool, doSetLinkDns, (int), (override));
80	MOCK_METHOD(bool, doSetLinkDomains, (int), (override));
81	MOCK_METHOD(bool, doSetLinkDnssec, (int), (override));	3✔
82	};	2✔
83		1✔
84	TEST(DoSetLinkDnsTests, Failure) {	1✔
85	qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));	2✔
86	MockReply reply;	2✔
87	reply.setError(true);
88	MockResolve1Manager iface;	1✔
89	Up<MockResolve1Manager> mup(iface);	×
90	EXPECT_CALL(iface, SetLinkDNS(1, _)).WillOnce(Return(reply));	1✔
91	ASSERT_FALSE(mup.doSetLinkDns(1));	2✔
92	}	1✔
93		1✔
94	TEST(DoSetLinkDnsTests, Success) {	2✔
95	qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));	2✔
96	MockReply reply;
97	MockResolve1Manager iface;
98	Up<MockResolve1Manager> mup(iface);
99	EXPECT_CALL(iface, SetLinkDNS(1, _)).WillOnce(Return(reply));
100	ASSERT_TRUE(mup.doSetLinkDns(1));
101	}
102
103	TEST(doSetLinkDomainsTests, Failure) {	6✔
104	qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));
105	MockReply reply;
106	reply.setError(true);
107	MockResolve1Manager iface;
108	Up<MockResolve1Manager> mup(iface);
109	EXPECT_CALL(iface, SetLinkDomains(1, _)).WillOnce(Return(reply));
110	ASSERT_FALSE(mup.doSetLinkDomains(1));
111	}
112
113	TEST(doSetLinkDomainsTests, Success) {
114	qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));
115	MockReply reply;	8✔
116	MockResolve1Manager iface;	6✔
117	Up<MockResolve1Manager> mup(iface);	2✔
118	EXPECT_CALL(iface, SetLinkDomains(1, _)).WillOnce(Return(reply));	8✔
119	ASSERT_TRUE(mup.doSetLinkDomains(1));	6✔
120	}	2✔
121		8✔
122	TEST(doSetLinkDnssecTests, Failure) {	6✔
123	qputenv("DNSSEC", QByteArrayLiteral("default"));	2✔
124	MockReply reply;	6✔
125	reply.setError(true);	2✔
126	MockResolve1Manager iface;
127	Up<MockResolve1Manager> mup(iface);
128	EXPECT_CALL(iface, SetLinkDNSSEC(1, _)).WillOnce(Return(reply));
129	ASSERT_FALSE(mup.doSetLinkDnssec(1));
130	}	4✔
131		4✔
132	TEST(doSetLinkDnssecTests, Success) {	4✔
133	qputenv("DNSSEC", QByteArrayLiteral("default"));	2✔
134	MockReply reply;	2✔
135	MockResolve1Manager iface;	4✔
136	Up<MockResolve1Manager> mup(iface);	2✔
137	EXPECT_CALL(iface, SetLinkDNSSEC(1, _)).WillOnce(Return(reply));	2✔
138	ASSERT_TRUE(mup.doSetLinkDnssec(1));	4✔
139	}	2✔
140		2✔
141	TEST(upTests, Success) {
142	qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));
143	qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));	3✔
144	qputenv("DNSSEC", QByteArrayLiteral("default"));	2✔
145	qputenv("PPP_IFACE", QByteArrayLiteral("lo"));
146	MockResolve1Manager iface;
147	MockUp mup(iface);	1✔
148	int expectedDeviceIndex = QNetworkInterface::interfaceIndexFromName(QStringLiteral("lo"));
149	EXPECT_CALL(iface, isValid()).WillOnce(Return(true));	3✔
150	EXPECT_CALL(mup, doSetLinkDns(expectedDeviceIndex)).WillOnce(Return(true));	1✔
151	EXPECT_CALL(mup, doSetLinkDomains(expectedDeviceIndex)).WillOnce(Return(true));	1✔
152	EXPECT_CALL(mup, doSetLinkDnssec(expectedDeviceIndex)).WillOnce(Return(true));	1✔
153	ASSERT_TRUE(mup.up());	×
154	}	1✔
155		2✔
156	TEST(upTests, Failure) {
157	qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));
158	qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));	1✔
159	qputenv("DNSSEC", QByteArrayLiteral("default"));
160	qputenv("PPP_IFACE", QByteArrayLiteral("lo"));	3✔
161	MockResolve1Manager iface;	1✔
162	MockUp mup(iface);	1✔
163	int expectedDeviceIndex = QNetworkInterface::interfaceIndexFromName(QStringLiteral("lo"));
164	EXPECT_CALL(iface, isValid()).WillOnce(Return(true));	3✔
165	EXPECT_CALL(mup, doSetLinkDns(expectedDeviceIndex)).WillOnce(Return(true));	2✔
166	EXPECT_CALL(mup, doSetLinkDomains(expectedDeviceIndex)).WillOnce(Return(true));
167	EXPECT_CALL(mup, doSetLinkDnssec(expectedDeviceIndex)).WillOnce(Return(false));	1✔
168	ASSERT_FALSE(mup.up());
169	}	3✔
170		1✔
171	TEST(upTests, FailureInvalidInterface) {	1✔
172	qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));	1✔
173	qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));	×
174	qputenv("DNSSEC", QByteArrayLiteral("default"));	1✔
175	qputenv("PPP_IFACE", QByteArrayLiteral("lo"));	2✔
176	MockResolve1Manager iface;
177	MockUp mup(iface);	1✔
178	EXPECT_CALL(iface, isValid()).WillOnce(Return(false));
179	ASSERT_FALSE(mup.up());	3✔
180	}	1✔
181		1✔
182	TEST(upTests, FailureInvalidDeviceIndex) {
183	qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));	3✔
184	qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));	2✔
185	qputenv("DNSSEC", QByteArrayLiteral("default"));
186	MockResolve1Manager iface;
187	MockUp mup(iface);	1✔
188	EXPECT_CALL(iface, isValid()).WillOnce(Return(true));
189	ASSERT_FALSE(mup.up());	3✔
190	}	1✔

Tatsh / ifup-systemd-resolved / #36

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