Line data Source code
1 : /**
2 : * @file
3 : *
4 : * @brief Tests for the Backend parser class
5 : *
6 : * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
7 : *
8 : */
9 :
10 : #define ELEKTRA_PLUGINSPEC_WITH_COMPARE
11 :
12 : #include <backendparser.hpp>
13 :
14 : #include <backendbuilder.hpp>
15 :
16 : #include <string>
17 :
18 : #include <toolexcept.hpp>
19 :
20 : #include <gtest/gtest.h>
21 :
22 :
23 20 : TEST (MountBackendBuilder, parsePluginArguments)
24 : {
25 : using namespace kdb;
26 : using namespace kdb::tools;
27 26 : EXPECT_EQ (KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), KS_END), parsePluginArguments ("a=5"));
28 26 : EXPECT_EQ (KeySet (5, *Key ("user", KEY_END), KS_END), parsePluginArguments ("="));
29 34 : EXPECT_EQ (KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), *Key ("user/ax", KEY_VALUE, "a", KEY_END),
30 : *Key ("user/ax/bx", KEY_VALUE, "8", KEY_END), KS_END),
31 0 : parsePluginArguments ("a=5,ax=a,ax/bx=8"));
32 34 : EXPECT_EQ (KeySet (5, *Key ("user", KEY_VALUE, "5", KEY_END), *Key ("user/ax", KEY_END, KEY_END),
33 : *Key ("user/ax/bx", KEY_VALUE, "8", KEY_END), KS_END),
34 0 : parsePluginArguments ("=5,ax=,ax/bx=8"));
35 34 : EXPECT_EQ (KeySet (5, *Key ("user", KEY_VALUE, "5", KEY_END), *Key ("user/ ax", KEY_END, KEY_END),
36 : *Key ("user/ ax/ bx", KEY_VALUE, "8", KEY_END), KS_END),
37 0 : parsePluginArguments ("=5, ax=, ax/ bx=8"));
38 34 : EXPECT_EQ (KeySet (5, *Key ("user", KEY_VALUE, "5", KEY_END), *Key ("user/ ax", KEY_END, KEY_END),
39 : *Key ("user/ ax/ bx", KEY_VALUE, "8", KEY_END), KS_END),
40 0 : parsePluginArguments ("=5, ax=, ax/ bx=8"));
41 34 : EXPECT_EQ (KeySet (5, *Key ("user", KEY_VALUE, "5", KEY_END), *Key ("user/ax", KEY_END, KEY_END),
42 : *Key ("user/ax\\/bx", KEY_VALUE, "8", KEY_END), KS_END),
43 0 : parsePluginArguments ("=5,ax=,ax\\/bx=8"));
44 34 : EXPECT_EQ (KeySet (5, *Key ("user", KEY_END), *Key ("user/ax", KEY_END, KEY_END), *Key ("user/ax\\/bx", KEY_VALUE, "8", KEY_END),
45 : KS_END),
46 0 : parsePluginArguments ("=,ax=,ax\\/bx=8"));
47 2 : }
48 :
49 :
50 : #define CMP_PSV(psv1, psv2) \
51 : do \
52 : { \
53 : EXPECT_EQ (psv1.size (), psv2.size ()); \
54 : if (psv1.size () != psv2.size ()) break; \
55 : for (size_t i = 0; i < psv1.size (); ++i) \
56 : { \
57 : EXPECT_EQ (psv1[i], psv2[i]) << "element " << i << " differs"; \
58 : if (!(psv1[i] == psv2[i])) break; \
59 : } \
60 : } while (false)
61 :
62 20 : TEST (MountBackendBuilder, parseArguments)
63 : {
64 : using namespace kdb;
65 : using namespace kdb::tools;
66 4 : PluginSpecVector psv1;
67 16 : psv1.push_back (PluginSpec ("a", KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), KS_END)));
68 12 : psv1.push_back (PluginSpec ("b"));
69 12 : psv1.push_back (PluginSpec ("c"));
70 10 : PluginSpecVector psv2 = parseArguments ("a a=5 b c");
71 58 : CMP_PSV (psv1, psv2);
72 10 : psv2 = parseArguments (" a a=5 b c ");
73 58 : CMP_PSV (psv1, psv2);
74 10 : psv2 = parseArguments (" a a=5 b c , ");
75 58 : CMP_PSV (psv1, psv2);
76 6 : EXPECT_THROW (parseArguments ("a=5 a b c"), ParseException);
77 6 : EXPECT_THROW (parseArguments ("a#a b c a#a"), ParseException);
78 2 : }
79 :
80 20 : TEST (MountBackendBuilder, parseVectorArguments)
81 : {
82 : using namespace kdb;
83 : using namespace kdb::tools;
84 4 : PluginSpecVector psv1;
85 : psv1.push_back (
86 20 : PluginSpec ("a", KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), *Key ("user/b", KEY_VALUE, "3", KEY_END), KS_END)));
87 12 : psv1.push_back (PluginSpec ("b"));
88 : psv1.push_back (
89 20 : PluginSpec ("c", KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), *Key ("user/b", KEY_VALUE, "3", KEY_END), KS_END)));
90 26 : PluginSpecVector psv2 = parseArguments ({ "a", "a=5,b=3", "b", "c", "a=5,b=3" });
91 58 : CMP_PSV (psv1, psv2);
92 26 : psv2 = parseArguments ({ "a", "a=5,b=3", "b", "c", "a=5,b=3" });
93 58 : CMP_PSV (psv1, psv2);
94 10 : psv2 = parseArguments (" a b=3,a=5 b c , a=5,b=3 ");
95 58 : CMP_PSV (psv1, psv2);
96 10 : psv2 = parseArguments (" a a=5,b=3 b c a=5, b=3 ");
97 58 : CMP_PSV (psv1, psv2);
98 10 : psv2 = parseArguments (" a b=3,a=5 b , c , a=5,b=3 ");
99 58 : CMP_PSV (psv1, psv2);
100 6 : EXPECT_THROW (parseArguments ("a=5 a b c"), ParseException);
101 6 : EXPECT_THROW (parseArguments ("a#a b c a#a"), ParseException);
102 2 : }
103 :
104 20 : TEST (MountBackendBuilder, parseArgumentsIdentical)
105 : {
106 : using namespace kdb;
107 : using namespace kdb::tools;
108 6 : EXPECT_THROW (parseArguments ("a#a a#a"), ParseException);
109 6 : EXPECT_THROW (parseArguments ("a#a b#a"), ParseException);
110 6 : EXPECT_THROW (parseArguments ("a#a a#0"), BadPluginName);
111 6 : EXPECT_THROW (parseArguments ("a#b b#b"), ParseException);
112 6 : EXPECT_THROW (parseArguments ("a#same b#same"), ParseException);
113 6 : EXPECT_THROW (parseArguments ("a#same b c#same"), ParseException);
114 6 : EXPECT_THROW (parseArguments ("a#same b c d#same"), ParseException);
115 6 : EXPECT_THROW (parseArguments ("a#same b c d e#same"), ParseException);
116 6 : EXPECT_THROW (parseArguments ("a#same b c d e#same f g h"), ParseException);
117 6 : EXPECT_THROW (parseArguments ("augeas#same1 logging#same2 code#same3 escape=% code#same1 escape=- "), ParseException);
118 6 : EXPECT_THROW (parseArguments ("augeas#same1 logging#same2 code#same3 escape=% code#same3 escape=- "), ParseException);
119 6 : EXPECT_THROW (parseArguments ("augeas#same1 logging#same2 code#same3 escape=% code#same3 escape=- "), ParseException);
120 6 : EXPECT_THROW (parseArguments ("augeas#same logging#same2 code#same3 escape=% code#same escape=- "), ParseException);
121 6 : EXPECT_THROW (parseArguments ("augeas#same1 logging#same code#same3 escape=% code#same escape=- "), ParseException);
122 6 : EXPECT_THROW (parseArguments ("augeas#same1 logging#same2 code#same escape=% code#same escape=- "), ParseException);
123 2 : }
124 :
125 20 : TEST (MountBackendBuilder, parseArgumentsNearlyIdentical)
126 : {
127 : using namespace kdb;
128 : using namespace kdb::tools;
129 4 : PluginSpecVector psv1;
130 18 : psv1.push_back (PluginSpec ("a", "a"));
131 10 : psv1.push_back (PluginSpec ("a", 0));
132 10 : PluginSpecVector psv2 = parseArguments ("a#a a");
133 44 : CMP_PSV (psv1, psv2);
134 2 : }
135 :
136 20 : TEST (MountBackendBuilder, parseArgumentsDoubleOccur)
137 : {
138 : using namespace kdb;
139 : using namespace kdb::tools;
140 4 : PluginSpecVector psv1;
141 16 : psv1.push_back (PluginSpec ("a", 0, KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), KS_END)));
142 12 : psv1.push_back (PluginSpec ("b"));
143 12 : psv1.push_back (PluginSpec ("c"));
144 16 : psv1.push_back (PluginSpec ("a", 1, KeySet (5, *Key ("user/b", KEY_VALUE, "c", KEY_END), KS_END)));
145 10 : PluginSpecVector psv2 = parseArguments ("a a=5 b c a b=c");
146 72 : CMP_PSV (psv1, psv2);
147 10 : psv2 = parseArguments (" a a=5 b c a b=c ");
148 72 : CMP_PSV (psv1, psv2);
149 10 : psv2 = parseArguments (" a a=5 b c , a b=c ");
150 72 : CMP_PSV (psv1, psv2);
151 6 : EXPECT_THROW (parseArguments ("a=5 a b c a b=c"), ParseException);
152 6 : EXPECT_THROW (parseArguments ("a a=5 b c a#0 b=c"), BadPluginName);
153 6 : EXPECT_THROW (parseArguments ("a a=5 b c # b=c"), BadPluginName);
154 6 : EXPECT_THROW (parseArguments ("a a=5 b c #a b=c"), BadPluginName);
155 2 : }
156 :
157 20 : TEST (MountBackendBuilder, parseArgumentsRef)
158 : {
159 : using namespace kdb;
160 : using namespace kdb::tools;
161 4 : PluginSpecVector psv1;
162 22 : psv1.push_back (PluginSpec ("a", "mya", KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), KS_END)));
163 18 : psv1.push_back (PluginSpec ("b", "myb"));
164 18 : psv1.push_back (PluginSpec ("c", "myc"));
165 22 : psv1.push_back (PluginSpec ("a", "othera", KeySet (5, *Key ("user/b", KEY_VALUE, "c", KEY_END), KS_END)));
166 10 : PluginSpecVector psv2 = parseArguments ("a#mya a=5 b#myb c#myc a#othera b=c");
167 72 : CMP_PSV (psv1, psv2);
168 10 : psv2 = parseArguments (" a#mya a=5 b#myb c#myc a#othera b=c ");
169 72 : CMP_PSV (psv1, psv2);
170 10 : psv2 = parseArguments (" a#mya a=5 b#myb c#myc , a#othera b=c ");
171 72 : CMP_PSV (psv1, psv2);
172 2 : }
173 :
174 :
175 20 : TEST (MountBackendBuilder, parseArgumentsProvider)
176 : {
177 : using namespace kdb;
178 : using namespace kdb::tools;
179 4 : PluginSpecVector psv1;
180 22 : psv1.push_back (PluginSpec ("augeas", "aaa", KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), KS_END)));
181 18 : psv1.push_back (PluginSpec ("logging", "logg"));
182 24 : psv1.push_back (PluginSpec ("code", "nee", KeySet (5, *Key ("user/escape", KEY_VALUE, "-", KEY_END), KS_END))),
183 22 : psv1.push_back (PluginSpec ("hexcode", "hexcode", KeySet (5, *Key ("user/escape", KEY_VALUE, "%", KEY_END), KS_END)));
184 10 : PluginSpecVector psv2 = parseArguments ("augeas#aaa a=5 logging#logg code#nee escape=% hexcode escape=-");
185 72 : CMP_PSV (psv1, psv2);
186 :
187 :
188 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
189 24 : mpd->data[PluginSpec ("ccode")]["provides"] = "code";
190 24 : mpd->data[PluginSpec ("syslog")]["provides"] = "logging";
191 22 : mpd->data[PluginSpec ("augeas")][""];
192 22 : mpd->data[PluginSpec ("hexcode")][""];
193 6 : BackendBuilderInit bbi (mpd);
194 4 : BackendBuilder bb (bbi);
195 16 : for (auto const & p : psv2)
196 : {
197 8 : bb.addPlugin (p);
198 : }
199 4 : PluginSpecVector psv3;
200 22 : psv3.push_back (PluginSpec ("augeas", "aaa", KeySet (5, *Key ("user/a", KEY_VALUE, "5", KEY_END), KS_END)));
201 18 : psv3.push_back (PluginSpec ("syslog", "logg"));
202 22 : psv3.push_back (PluginSpec ("ccode", "nee", KeySet (5, *Key ("user/escape", KEY_VALUE, "-", KEY_END), KS_END)));
203 22 : psv3.push_back (PluginSpec ("hexcode", "hexcode", KeySet (5, *Key ("user/escape", KEY_VALUE, "%", KEY_END), KS_END)));
204 10 : PluginSpecVector psv4 (bb.begin (), bb.end ());
205 72 : CMP_PSV (psv3, psv4);
206 2 : }
207 :
208 20 : TEST (MountBackendBuilder, parseArgumentsSameProvider)
209 : {
210 : using namespace kdb;
211 : using namespace kdb::tools;
212 4 : PluginSpecVector psv1;
213 18 : psv1.push_back (PluginSpec ("augeas", "a1"));
214 18 : psv1.push_back (PluginSpec ("logging", "a2"));
215 22 : psv1.push_back (PluginSpec ("code", "a3", KeySet (5, *Key ("user/escape", KEY_VALUE, "%", KEY_END), KS_END)));
216 22 : psv1.push_back (PluginSpec ("code", "a4", KeySet (5, *Key ("user/escape", KEY_VALUE, "-", KEY_END), KS_END)));
217 18 : psv1.push_back (PluginSpec ("code", "a5"));
218 10 : PluginSpecVector psv2 = parseArguments ("augeas#a1 logging#a2 code#a3 escape=% code#a4 escape=- code#a5");
219 86 : CMP_PSV (psv1, psv2);
220 :
221 :
222 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
223 24 : mpd->data[PluginSpec ("ccode")]["provides"] = "code";
224 24 : mpd->data[PluginSpec ("syslog")]["provides"] = "logging";
225 22 : mpd->data[PluginSpec ("augeas")][""];
226 22 : mpd->data[PluginSpec ("hexcode")][""];
227 6 : BackendBuilderInit bbi (mpd);
228 4 : BackendBuilder bb (bbi);
229 18 : for (auto const & p : psv2)
230 : {
231 10 : bb.addPlugin (p);
232 : }
233 4 : PluginSpecVector psv3;
234 10 : PluginSpecVector psv4 (bb.begin (), bb.end ());
235 18 : psv3.push_back (PluginSpec ("augeas", "a1"));
236 18 : psv3.push_back (PluginSpec ("syslog", "a2"));
237 22 : psv3.push_back (PluginSpec ("ccode", "a3", KeySet (5, *Key ("user/escape", KEY_VALUE, "%", KEY_END), KS_END)));
238 22 : psv3.push_back (PluginSpec ("ccode", "a4", KeySet (5, *Key ("user/escape", KEY_VALUE, "-", KEY_END), KS_END)));
239 18 : psv3.push_back (PluginSpec ("ccode", "a5"));
240 86 : CMP_PSV (psv3, psv4);
241 2 : }
242 :
243 :
244 20 : TEST (MountBackendBuilder, parseArgumentsSameProviderAgain)
245 : {
246 : using namespace kdb;
247 : using namespace kdb::tools;
248 4 : PluginSpecVector psv1;
249 18 : psv1.push_back (PluginSpec ("augeas", "same1"));
250 18 : psv1.push_back (PluginSpec ("logging", "same2"));
251 22 : psv1.push_back (PluginSpec ("code", "same3", KeySet (5, *Key ("user/escape", KEY_VALUE, "%", KEY_END), KS_END)));
252 22 : psv1.push_back (PluginSpec ("code", "same4", KeySet (5, *Key ("user/escape", KEY_VALUE, "-", KEY_END), KS_END)));
253 10 : PluginSpecVector psv2 = parseArguments ("augeas#same1 logging#same2 code#same3 escape=% code#same4 escape=- ");
254 72 : CMP_PSV (psv1, psv2);
255 :
256 :
257 2 : std::shared_ptr<MockPluginDatabase> mpd = std::make_shared<MockPluginDatabase> ();
258 24 : mpd->data[PluginSpec ("ccode")]["provides"] = "code";
259 24 : mpd->data[PluginSpec ("syslog")]["provides"] = "logging";
260 22 : mpd->data[PluginSpec ("augeas")][""];
261 22 : mpd->data[PluginSpec ("hexcode")][""];
262 6 : BackendBuilderInit bbi (mpd);
263 4 : BackendBuilder bb (bbi);
264 16 : for (auto const & p : psv2)
265 : {
266 8 : bb.addPlugin (p);
267 : }
268 4 : PluginSpecVector psv3;
269 10 : PluginSpecVector psv4 (bb.begin (), bb.end ());
270 18 : psv3.push_back (PluginSpec ("augeas", "same1"));
271 18 : psv3.push_back (PluginSpec ("syslog", "same2"));
272 22 : psv3.push_back (PluginSpec ("ccode", "same3", KeySet (5, *Key ("user/escape", KEY_VALUE, "%", KEY_END), KS_END)));
273 22 : psv3.push_back (PluginSpec ("ccode", "same4", KeySet (5, *Key ("user/escape", KEY_VALUE, "-", KEY_END), KS_END)));
274 72 : CMP_PSV (psv3, psv4);
275 8 : }
|