Tatsh / ifup-systemd-resolved / #8

Committed 22 Jun 2025 11:46PM UTC coverage: 86.738% (-3.9%) from 90.604%

Build # #8

Build Type

push

travis-ci

Committed by

Tatsh

Commit Message

tests: fix

Run Details

242 of 279 relevant lines covered (86.74%)

2.47 hits per line

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

94.21

/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));
};

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

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

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

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

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

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);	2✔
13	}	1✔
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);	2✔
19	ASSERT_EQ(x[0].family, AF_INET);	1✔
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);	3✔
26	ASSERT_EQ(x[0].family, AF_INET6);	1✔
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);	3✔
34	ASSERT_EQ(x[0].family, AF_INET6);	1✔
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);	3✔
41	}	1✔
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"));	3✔
49	}	1✔
50
51	class MockReply {	3✔
52	public:	2✔
53	void waitForFinished() {	2✔
54	}	1✔
55	bool isError() {	1✔
56	return error_;	2✔
57	}	3✔
58	void setError(bool error) {	1✔
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:	3✔
68	MOCK_METHOD(MockReply, SetLinkDNS, (int, const LinkDnsIpList &), (const));	1✔
69	MOCK_METHOD(MockReply, SetLinkDomains, (int, const LinkDomainList &), (const));
70	MOCK_METHOD(MockReply, SetLinkDNSSEC, (int, const QString &), (const));	3✔
71	};	1✔
72		2✔
73	TEST(DoSetLinkDnsTests, Failure) {	1✔
74	qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));	1✔
75	MockReply reply;	×
76	reply.setError(true);	1✔
77	MockResolve1Manager iface;	1✔
78	Resolve1ManagerContainer<MockResolve1Manager> container{iface};	2✔
79	EXPECT_CALL(iface, SetLinkDNS(1, _)).WillOnce(Return(reply));	1✔
80	ASSERT_FALSE(doSetLinkDns(container, 1));
81	}	3✔
82		2✔
83	TEST(DoSetLinkDnsTests, Success) {	1✔
84	qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));	1✔
85	MockReply reply;	2✔
86	MockResolve1Manager iface;	3✔
87	Resolve1ManagerContainer<MockResolve1Manager> container{iface};	1✔
88	EXPECT_CALL(iface, SetLinkDNS(1, _)).WillOnce(Return(reply));	1✔
89	ASSERT_TRUE(doSetLinkDns(container, 1));	×
90	}	1✔
91		2✔
92	TEST(doSetLinkDomainsTests, Failure) {	1✔
93	qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));	1✔
94	MockReply reply;	2✔
95	reply.setError(true);	3✔
96	MockResolve1Manager iface;	1✔
97	Resolve1ManagerContainer<MockResolve1Manager> container{iface};
98	EXPECT_CALL(iface, SetLinkDomains(1, _)).WillOnce(Return(reply));
99	ASSERT_FALSE(doSetLinkDomains(container, 1));
100	}
101
102	TEST(doSetLinkDomainsTests, Success) {	5✔
103	qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));	5✔
104	MockReply reply;
105	MockResolve1Manager iface;
106	Resolve1ManagerContainer<MockResolve1Manager> container{iface};	3✔
107	EXPECT_CALL(iface, SetLinkDomains(1, _)).WillOnce(Return(reply));
108	ASSERT_TRUE(doSetLinkDomains(container, 1));
109	}
110
111	TEST(doSetLinkDnssecTests, Failure) {
112	qputenv("DNSSEC", QByteArrayLiteral("default"));
113	MockReply reply;
114	reply.setError(true);
115	MockResolve1Manager iface;	4✔
116	Resolve1ManagerContainer<MockResolve1Manager> container{iface};	2✔
117	EXPECT_CALL(iface, SetLinkDNSSEC(1, _)).WillOnce(Return(reply));	2✔
118	ASSERT_FALSE(doSetLinkDnssec(container, 1));	4✔
119	}	2✔

Tatsh / ifup-systemd-resolved / #8

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