Tatsh / ifup-systemd-resolved / #3

Committed 22 Jun 2025 11:41PM UTC coverage: 0.0%. Remained the same

Build # #3

Build Type

push

travis-ci

Committed by

Tatsh

Commit Message

tests: fix

Run Details

0 of 266 relevant lines covered (0.0%)

0.0 hits per line

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

0.0

/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) {	×
11	auto x = generateAddresses();	×
12	ASSERT_EQ(x.length(), 0);	×
13	}
14		×
15	TEST(GenerateAddressesTests, OneVarIPV4) {	×
16	qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));	×
17	auto x = generateAddresses();	×
18	ASSERT_EQ(x.length(), 1);	×
19	ASSERT_EQ(x[0].family, AF_INET);	×
20	}
21
22	TEST(GenerateAddressesTests, OneVarIPV6) {	×
23	qputenv("DNS1", QByteArrayLiteral("2001:db8::ff00:42:8329"));	×
24	auto x = generateAddresses();	×
25	ASSERT_EQ(x.length(), 1);	×
26	ASSERT_EQ(x[0].family, AF_INET6);	×
27	}
28		×
29	TEST(GenerateAddressesTests, TwoVarsMixed) {	×
30	qputenv("DNS1", QByteArrayLiteral("2001:db8::ff00:42:8329"));	×
31	qputenv("DNS2", QByteArrayLiteral("20.0.0.1"));	×
32	auto x = generateAddresses();	×
33	ASSERT_EQ(x.length(), 2);	×
34	ASSERT_EQ(x[0].family, AF_INET6);	×
35	ASSERT_EQ(x[1].family, AF_INET);	×
36	}
37
38	TEST(GenerateDomainsTests, EmptyVars) {	×
39	auto x = generateDomains();	×
40	ASSERT_EQ(x.length(), 0);	×
41	}	×
42		×
43	TEST(GenerateDomainsTests, Basic) {
44	qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));	×
45	auto x = generateDomains();	×
46	ASSERT_EQ(x.length(), 2);	×
47	ASSERT_EQ(x[0].domain, QStringLiteral("example.com"));	×
48	ASSERT_EQ(x[1].domain, QStringLiteral("example.org"));	×
49	}	×
50		×
51	class MockReply {	×
52	public:
53	void waitForFinished() {
54	}	×
55	bool isError() {	×
56	return error_;	×
57	}	×
58	void setError(bool error) {	×
59	error_ = error;	×
60	}	×
61
62	private:	×
63	bool error_ = false;	×
64	};	×
65		×
66	class MockResolve1Manager {	×
67	public:	×
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));	×
71	};	×
72
73	TEST(DoSetLinkDnsTests, Failure) {
74	qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));	×
75	MockReply reply;	×
76	reply.setError(true);	×
77	MockResolve1Manager iface;
78	Resolve1ManagerContainer<MockResolve1Manager> container{iface};	×
79	EXPECT_CALL(iface, SetLinkDNS(1, _)).WillOnce(Return(reply));	×
80	ASSERT_FALSE(doSetLinkDns(container, 1));	×
81	}	×
82		×
83	TEST(DoSetLinkDnsTests, Success) {	×
84	qputenv("DNS1", QByteArrayLiteral("20.0.0.1"));
85	MockReply reply;
86	MockResolve1Manager iface;	×
87	Resolve1ManagerContainer<MockResolve1Manager> container{iface};	×
88	EXPECT_CALL(iface, SetLinkDNS(1, _)).WillOnce(Return(reply));	×
89	ASSERT_TRUE(doSetLinkDns(container, 1));	×
90	}	×
91		×
92	TEST(doSetLinkDomainsTests, Failure) {
93	qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));	×
94	MockReply reply;	×
95	reply.setError(true);	×
96	MockResolve1Manager iface;	×
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) {
103	qputenv("DNS_SUFFIX", QByteArrayLiteral("example.com example.org"));
104	MockReply reply;
105	MockResolve1Manager iface;
106	Resolve1ManagerContainer<MockResolve1Manager> container{iface};	×
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;
116	Resolve1ManagerContainer<MockResolve1Manager> container{iface};
117	EXPECT_CALL(iface, SetLinkDNSSEC(1, _)).WillOnce(Return(reply));
118	ASSERT_FALSE(doSetLinkDnssec(container, 1));
119	}

Tatsh / ifup-systemd-resolved / #3

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