Mercurial > irccd
comparison tests/cmd-rule-edit/main.cpp @ 453:acb2d4990249
Irccdctl: implement rule-edit
author | David Demelier <markand@malikania.fr> |
---|---|
date | Thu, 20 Jul 2017 22:55:02 +0200 |
parents | |
children | 7e273b7f4f92 |
comparison
equal
deleted
inserted
replaced
452:2170aa0e38aa | 453:acb2d4990249 |
---|---|
1 /* | |
2 * main.cpp -- test rule-info remote command | |
3 * | |
4 * Copyright (c) 2013-2017 David Demelier <markand@malikania.fr> | |
5 * | |
6 * Permission to use, copy, modify, and/or distribute this software for any | |
7 * purpose with or without fee is hereby granted, provided that the above | |
8 * copyright notice and this permission notice appear in all copies. | |
9 * | |
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
17 */ | |
18 | |
19 #include <command.hpp> | |
20 #include <command-tester.hpp> | |
21 #include <service.hpp> | |
22 | |
23 using namespace irccd; | |
24 using namespace irccd::command; | |
25 | |
26 class RuleEditCommandTest : public CommandTester { | |
27 protected: | |
28 nlohmann::json m_result; | |
29 | |
30 /* | |
31 * Rule sets are unordered so use this function to search a string in | |
32 * the JSON array. | |
33 */ | |
34 inline bool contains(const nlohmann::json &array, const std::string &str) | |
35 { | |
36 for (const auto &v : array) | |
37 if (v.is_string() && v == str) | |
38 return true; | |
39 | |
40 return false; | |
41 } | |
42 | |
43 public: | |
44 RuleEditCommandTest() | |
45 : CommandTester(std::make_unique<RuleEditCommand>()) | |
46 { | |
47 m_irccd.commands().add(std::make_unique<RuleInfoCommand>()); | |
48 m_irccd.rules().add(Rule( | |
49 { "s1", "s2" }, | |
50 { "c1", "c2" }, | |
51 { "o1", "o2" }, | |
52 { "p1", "p2" }, | |
53 { "onMessage", "onCommand" }, | |
54 RuleAction::Drop | |
55 )); | |
56 m_irccdctl.client().onMessage.connect([&] (auto result) { | |
57 m_result = result; | |
58 }); | |
59 } | |
60 }; | |
61 | |
62 TEST_F(RuleEditCommandTest, addServer) | |
63 { | |
64 try { | |
65 m_irccdctl.client().request({ | |
66 { "command", "rule-edit" }, | |
67 { "add-servers", { "new-s3" } }, | |
68 { "index", 0 } | |
69 }); | |
70 | |
71 poll([&] () { | |
72 return m_result.is_object(); | |
73 }); | |
74 | |
75 ASSERT_TRUE(m_result.is_object()); | |
76 ASSERT_TRUE(m_result["status"].get<bool>()); | |
77 | |
78 m_result = nullptr; | |
79 m_irccdctl.client().request({ | |
80 { "command", "rule-info" }, | |
81 { "index", 0 } | |
82 }); | |
83 | |
84 poll([&] () { | |
85 return m_result.is_object(); | |
86 }); | |
87 | |
88 ASSERT_TRUE(m_result.is_object()); | |
89 ASSERT_TRUE(m_result["status"].get<bool>()); | |
90 ASSERT_TRUE(contains(m_result["servers"], "s1")); | |
91 ASSERT_TRUE(contains(m_result["servers"], "s2")); | |
92 ASSERT_TRUE(contains(m_result["servers"], "new-s3")); | |
93 ASSERT_TRUE(contains(m_result["channels"], "c1")); | |
94 ASSERT_TRUE(contains(m_result["channels"], "c2")); | |
95 ASSERT_TRUE(contains(m_result["plugins"], "p1")); | |
96 ASSERT_TRUE(contains(m_result["plugins"], "p2")); | |
97 ASSERT_TRUE(contains(m_result["events"], "onMessage")); | |
98 ASSERT_TRUE(contains(m_result["events"], "onCommand")); | |
99 ASSERT_EQ(m_result["action"].get<std::string>(), "drop"); | |
100 } catch (const std::exception &ex) { | |
101 FAIL() << ex.what(); | |
102 } | |
103 } | |
104 | |
105 TEST_F(RuleEditCommandTest, addChannel) | |
106 { | |
107 try { | |
108 m_irccdctl.client().request({ | |
109 { "command", "rule-edit" }, | |
110 { "add-channels", { "new-c3" } }, | |
111 { "index", 0 } | |
112 }); | |
113 | |
114 poll([&] () { | |
115 return m_result.is_object(); | |
116 }); | |
117 | |
118 ASSERT_TRUE(m_result.is_object()); | |
119 ASSERT_TRUE(m_result["status"].get<bool>()); | |
120 | |
121 m_result = nullptr; | |
122 m_irccdctl.client().request({ | |
123 { "command", "rule-info" }, | |
124 { "index", 0 } | |
125 }); | |
126 | |
127 poll([&] () { | |
128 return m_result.is_object(); | |
129 }); | |
130 | |
131 ASSERT_TRUE(m_result.is_object()); | |
132 ASSERT_TRUE(m_result["status"].get<bool>()); | |
133 ASSERT_TRUE(contains(m_result["servers"], "s1")); | |
134 ASSERT_TRUE(contains(m_result["servers"], "s2")); | |
135 ASSERT_TRUE(contains(m_result["channels"], "c1")); | |
136 ASSERT_TRUE(contains(m_result["channels"], "c2")); | |
137 ASSERT_TRUE(contains(m_result["channels"], "new-c3")); | |
138 ASSERT_TRUE(contains(m_result["plugins"], "p1")); | |
139 ASSERT_TRUE(contains(m_result["plugins"], "p2")); | |
140 ASSERT_TRUE(contains(m_result["events"], "onMessage")); | |
141 ASSERT_TRUE(contains(m_result["events"], "onCommand")); | |
142 ASSERT_EQ(m_result["action"].get<std::string>(), "drop"); | |
143 } catch (const std::exception &ex) { | |
144 FAIL() << ex.what(); | |
145 } | |
146 } | |
147 | |
148 TEST_F(RuleEditCommandTest, addPlugin) | |
149 { | |
150 try { | |
151 m_irccdctl.client().request({ | |
152 { "command", "rule-edit" }, | |
153 { "add-plugins", { "new-p3" } }, | |
154 { "index", 0 } | |
155 }); | |
156 | |
157 poll([&] () { | |
158 return m_result.is_object(); | |
159 }); | |
160 | |
161 ASSERT_TRUE(m_result.is_object()); | |
162 ASSERT_TRUE(m_result["status"].get<bool>()); | |
163 | |
164 m_result = nullptr; | |
165 m_irccdctl.client().request({ | |
166 { "command", "rule-info" }, | |
167 { "index", 0 } | |
168 }); | |
169 | |
170 poll([&] () { | |
171 return m_result.is_object(); | |
172 }); | |
173 | |
174 ASSERT_TRUE(m_result.is_object()); | |
175 ASSERT_TRUE(m_result["status"].get<bool>()); | |
176 ASSERT_TRUE(contains(m_result["servers"], "s1")); | |
177 ASSERT_TRUE(contains(m_result["servers"], "s2")); | |
178 ASSERT_TRUE(contains(m_result["channels"], "c1")); | |
179 ASSERT_TRUE(contains(m_result["channels"], "c2")); | |
180 ASSERT_TRUE(contains(m_result["plugins"], "p1")); | |
181 ASSERT_TRUE(contains(m_result["plugins"], "p2")); | |
182 ASSERT_TRUE(contains(m_result["plugins"], "new-p3")); | |
183 ASSERT_TRUE(contains(m_result["events"], "onMessage")); | |
184 ASSERT_TRUE(contains(m_result["events"], "onCommand")); | |
185 ASSERT_EQ(m_result["action"].get<std::string>(), "drop"); | |
186 } catch (const std::exception &ex) { | |
187 FAIL() << ex.what(); | |
188 } | |
189 } | |
190 | |
191 TEST_F(RuleEditCommandTest, addEvent) | |
192 { | |
193 try { | |
194 m_irccdctl.client().request({ | |
195 { "command", "rule-edit" }, | |
196 { "add-events", { "onQuery" } }, | |
197 { "index", 0 } | |
198 }); | |
199 | |
200 poll([&] () { | |
201 return m_result.is_object(); | |
202 }); | |
203 | |
204 ASSERT_TRUE(m_result.is_object()); | |
205 ASSERT_TRUE(m_result["status"].get<bool>()); | |
206 | |
207 m_result = nullptr; | |
208 m_irccdctl.client().request({ | |
209 { "command", "rule-info" }, | |
210 { "index", 0 } | |
211 }); | |
212 | |
213 poll([&] () { | |
214 return m_result.is_object(); | |
215 }); | |
216 | |
217 ASSERT_TRUE(m_result.is_object()); | |
218 ASSERT_TRUE(m_result["status"].get<bool>()); | |
219 ASSERT_TRUE(contains(m_result["servers"], "s1")); | |
220 ASSERT_TRUE(contains(m_result["servers"], "s2")); | |
221 ASSERT_TRUE(contains(m_result["channels"], "c1")); | |
222 ASSERT_TRUE(contains(m_result["channels"], "c2")); | |
223 ASSERT_TRUE(contains(m_result["plugins"], "p1")); | |
224 ASSERT_TRUE(contains(m_result["plugins"], "p2")); | |
225 ASSERT_TRUE(contains(m_result["events"], "onMessage")); | |
226 ASSERT_TRUE(contains(m_result["events"], "onCommand")); | |
227 ASSERT_TRUE(contains(m_result["events"], "onQuery")); | |
228 ASSERT_EQ(m_result["action"].get<std::string>(), "drop"); | |
229 } catch (const std::exception &ex) { | |
230 FAIL() << ex.what(); | |
231 } | |
232 } | |
233 | |
234 TEST_F(RuleEditCommandTest, addEventAndServer) | |
235 { | |
236 try { | |
237 m_irccdctl.client().request({ | |
238 { "command", "rule-edit" }, | |
239 { "add-servers", { "new-s3" } }, | |
240 { "add-events", { "onQuery" } }, | |
241 { "index", 0 } | |
242 }); | |
243 | |
244 poll([&] () { | |
245 return m_result.is_object(); | |
246 }); | |
247 | |
248 ASSERT_TRUE(m_result.is_object()); | |
249 ASSERT_TRUE(m_result["status"].get<bool>()); | |
250 | |
251 m_result = nullptr; | |
252 m_irccdctl.client().request({ | |
253 { "command", "rule-info" }, | |
254 { "index", 0 } | |
255 }); | |
256 | |
257 poll([&] () { | |
258 return m_result.is_object(); | |
259 }); | |
260 | |
261 ASSERT_TRUE(m_result.is_object()); | |
262 ASSERT_TRUE(m_result["status"].get<bool>()); | |
263 ASSERT_TRUE(contains(m_result["servers"], "s1")); | |
264 ASSERT_TRUE(contains(m_result["servers"], "s2")); | |
265 ASSERT_TRUE(contains(m_result["servers"], "new-s3")); | |
266 ASSERT_TRUE(contains(m_result["channels"], "c1")); | |
267 ASSERT_TRUE(contains(m_result["channels"], "c2")); | |
268 ASSERT_TRUE(contains(m_result["plugins"], "p1")); | |
269 ASSERT_TRUE(contains(m_result["plugins"], "p2")); | |
270 ASSERT_TRUE(contains(m_result["events"], "onMessage")); | |
271 ASSERT_TRUE(contains(m_result["events"], "onCommand")); | |
272 ASSERT_TRUE(contains(m_result["events"], "onQuery")); | |
273 ASSERT_EQ(m_result["action"].get<std::string>(), "drop"); | |
274 } catch (const std::exception &ex) { | |
275 FAIL() << ex.what(); | |
276 } | |
277 } | |
278 | |
279 TEST_F(RuleEditCommandTest, changeAction) | |
280 { | |
281 try { | |
282 m_irccdctl.client().request({ | |
283 { "command", "rule-edit" }, | |
284 { "action", "accept" }, | |
285 { "index", 0 } | |
286 }); | |
287 | |
288 poll([&] () { | |
289 return m_result.is_object(); | |
290 }); | |
291 | |
292 ASSERT_TRUE(m_result.is_object()); | |
293 ASSERT_TRUE(m_result["status"].get<bool>()); | |
294 | |
295 m_result = nullptr; | |
296 m_irccdctl.client().request({ | |
297 { "command", "rule-info" }, | |
298 { "index", 0 } | |
299 }); | |
300 | |
301 poll([&] () { | |
302 return m_result.is_object(); | |
303 }); | |
304 | |
305 ASSERT_TRUE(m_result.is_object()); | |
306 ASSERT_TRUE(m_result["status"].get<bool>()); | |
307 ASSERT_TRUE(contains(m_result["servers"], "s1")); | |
308 ASSERT_TRUE(contains(m_result["servers"], "s2")); | |
309 ASSERT_TRUE(contains(m_result["channels"], "c1")); | |
310 ASSERT_TRUE(contains(m_result["channels"], "c2")); | |
311 ASSERT_TRUE(contains(m_result["plugins"], "p1")); | |
312 ASSERT_TRUE(contains(m_result["plugins"], "p2")); | |
313 ASSERT_TRUE(contains(m_result["events"], "onMessage")); | |
314 ASSERT_TRUE(contains(m_result["events"], "onCommand")); | |
315 ASSERT_EQ(m_result["action"].get<std::string>(), "accept"); | |
316 } catch (const std::exception &ex) { | |
317 FAIL() << ex.what(); | |
318 } | |
319 } | |
320 | |
321 TEST_F(RuleEditCommandTest, removeServer) | |
322 { | |
323 try { | |
324 m_irccdctl.client().request({ | |
325 { "command", "rule-edit" }, | |
326 { "remove-servers", { "s2" } }, | |
327 { "index", 0 } | |
328 }); | |
329 | |
330 poll([&] () { | |
331 return m_result.is_object(); | |
332 }); | |
333 | |
334 ASSERT_TRUE(m_result.is_object()); | |
335 ASSERT_TRUE(m_result["status"].get<bool>()); | |
336 | |
337 m_result = nullptr; | |
338 m_irccdctl.client().request({ | |
339 { "command", "rule-info" }, | |
340 { "index", 0 } | |
341 }); | |
342 | |
343 poll([&] () { | |
344 return m_result.is_object(); | |
345 }); | |
346 | |
347 ASSERT_TRUE(m_result.is_object()); | |
348 ASSERT_TRUE(m_result["status"].get<bool>()); | |
349 ASSERT_TRUE(contains(m_result["servers"], "s1")); | |
350 ASSERT_FALSE(contains(m_result["servers"], "s2")); | |
351 ASSERT_TRUE(contains(m_result["channels"], "c1")); | |
352 ASSERT_TRUE(contains(m_result["channels"], "c2")); | |
353 ASSERT_TRUE(contains(m_result["plugins"], "p1")); | |
354 ASSERT_TRUE(contains(m_result["plugins"], "p2")); | |
355 ASSERT_TRUE(contains(m_result["events"], "onMessage")); | |
356 ASSERT_TRUE(contains(m_result["events"], "onCommand")); | |
357 ASSERT_EQ(m_result["action"].get<std::string>(), "drop"); | |
358 } catch (const std::exception &ex) { | |
359 FAIL() << ex.what(); | |
360 } | |
361 } | |
362 | |
363 TEST_F(RuleEditCommandTest, removeChannel) | |
364 { | |
365 try { | |
366 m_irccdctl.client().request({ | |
367 { "command", "rule-edit" }, | |
368 { "remove-channels", { "c2" } }, | |
369 { "index", 0 } | |
370 }); | |
371 | |
372 poll([&] () { | |
373 return m_result.is_object(); | |
374 }); | |
375 | |
376 ASSERT_TRUE(m_result.is_object()); | |
377 ASSERT_TRUE(m_result["status"].get<bool>()); | |
378 | |
379 m_result = nullptr; | |
380 m_irccdctl.client().request({ | |
381 { "command", "rule-info" }, | |
382 { "index", 0 } | |
383 }); | |
384 | |
385 poll([&] () { | |
386 return m_result.is_object(); | |
387 }); | |
388 | |
389 ASSERT_TRUE(m_result.is_object()); | |
390 ASSERT_TRUE(m_result["status"].get<bool>()); | |
391 ASSERT_TRUE(contains(m_result["servers"], "s1")); | |
392 ASSERT_TRUE(contains(m_result["servers"], "s2")); | |
393 ASSERT_TRUE(contains(m_result["channels"], "c1")); | |
394 ASSERT_FALSE(contains(m_result["channels"], "c2")); | |
395 ASSERT_TRUE(contains(m_result["plugins"], "p1")); | |
396 ASSERT_TRUE(contains(m_result["plugins"], "p2")); | |
397 ASSERT_TRUE(contains(m_result["events"], "onMessage")); | |
398 ASSERT_TRUE(contains(m_result["events"], "onCommand")); | |
399 ASSERT_EQ(m_result["action"].get<std::string>(), "drop"); | |
400 } catch (const std::exception &ex) { | |
401 FAIL() << ex.what(); | |
402 } | |
403 } | |
404 | |
405 TEST_F(RuleEditCommandTest, removePlugin) | |
406 { | |
407 try { | |
408 m_irccdctl.client().request({ | |
409 { "command", "rule-edit" }, | |
410 { "remove-plugins", { "p2" } }, | |
411 { "index", 0 } | |
412 }); | |
413 | |
414 poll([&] () { | |
415 return m_result.is_object(); | |
416 }); | |
417 | |
418 ASSERT_TRUE(m_result.is_object()); | |
419 ASSERT_TRUE(m_result["status"].get<bool>()); | |
420 | |
421 m_result = nullptr; | |
422 m_irccdctl.client().request({ | |
423 { "command", "rule-info" }, | |
424 { "index", 0 } | |
425 }); | |
426 | |
427 poll([&] () { | |
428 return m_result.is_object(); | |
429 }); | |
430 | |
431 ASSERT_TRUE(m_result.is_object()); | |
432 ASSERT_TRUE(m_result["status"].get<bool>()); | |
433 ASSERT_TRUE(contains(m_result["servers"], "s1")); | |
434 ASSERT_TRUE(contains(m_result["servers"], "s2")); | |
435 ASSERT_TRUE(contains(m_result["channels"], "c1")); | |
436 ASSERT_TRUE(contains(m_result["channels"], "c2")); | |
437 ASSERT_TRUE(contains(m_result["plugins"], "p1")); | |
438 ASSERT_FALSE(contains(m_result["plugins"], "p2")); | |
439 ASSERT_TRUE(contains(m_result["events"], "onMessage")); | |
440 ASSERT_TRUE(contains(m_result["events"], "onCommand")); | |
441 ASSERT_EQ(m_result["action"].get<std::string>(), "drop"); | |
442 } catch (const std::exception &ex) { | |
443 FAIL() << ex.what(); | |
444 } | |
445 } | |
446 | |
447 TEST_F(RuleEditCommandTest, removeEvent) | |
448 { | |
449 try { | |
450 m_irccdctl.client().request({ | |
451 { "command", "rule-edit" }, | |
452 { "remove-events", { "onCommand" } }, | |
453 { "index", 0 } | |
454 }); | |
455 | |
456 poll([&] () { | |
457 return m_result.is_object(); | |
458 }); | |
459 | |
460 ASSERT_TRUE(m_result.is_object()); | |
461 ASSERT_TRUE(m_result["status"].get<bool>()); | |
462 | |
463 m_result = nullptr; | |
464 m_irccdctl.client().request({ | |
465 { "command", "rule-info" }, | |
466 { "index", 0 } | |
467 }); | |
468 | |
469 poll([&] () { | |
470 return m_result.is_object(); | |
471 }); | |
472 | |
473 ASSERT_TRUE(m_result.is_object()); | |
474 ASSERT_TRUE(m_result["status"].get<bool>()); | |
475 ASSERT_TRUE(contains(m_result["servers"], "s1")); | |
476 ASSERT_TRUE(contains(m_result["servers"], "s2")); | |
477 ASSERT_TRUE(contains(m_result["channels"], "c1")); | |
478 ASSERT_TRUE(contains(m_result["channels"], "c2")); | |
479 ASSERT_TRUE(contains(m_result["plugins"], "p1")); | |
480 ASSERT_TRUE(contains(m_result["plugins"], "p2")); | |
481 ASSERT_TRUE(contains(m_result["events"], "onMessage")); | |
482 ASSERT_FALSE(contains(m_result["events"], "onCommand")); | |
483 ASSERT_EQ(m_result["action"].get<std::string>(), "drop"); | |
484 } catch (const std::exception &ex) { | |
485 FAIL() << ex.what(); | |
486 } | |
487 } | |
488 | |
489 TEST_F(RuleEditCommandTest, removeEventAndServer) | |
490 { | |
491 try { | |
492 m_irccdctl.client().request({ | |
493 { "command", "rule-edit" }, | |
494 { "remove-servers", { "s2" } }, | |
495 { "remove-events", { "onCommand" } }, | |
496 { "index", 0 } | |
497 }); | |
498 | |
499 poll([&] () { | |
500 return m_result.is_object(); | |
501 }); | |
502 | |
503 ASSERT_TRUE(m_result.is_object()); | |
504 ASSERT_TRUE(m_result["status"].get<bool>()); | |
505 | |
506 m_result = nullptr; | |
507 m_irccdctl.client().request({ | |
508 { "command", "rule-info" }, | |
509 { "index", 0 } | |
510 }); | |
511 | |
512 poll([&] () { | |
513 return m_result.is_object(); | |
514 }); | |
515 | |
516 ASSERT_TRUE(m_result.is_object()); | |
517 ASSERT_TRUE(m_result["status"].get<bool>()); | |
518 ASSERT_TRUE(contains(m_result["servers"], "s1")); | |
519 ASSERT_FALSE(contains(m_result["servers"], "s2")); | |
520 ASSERT_TRUE(contains(m_result["channels"], "c1")); | |
521 ASSERT_TRUE(contains(m_result["channels"], "c2")); | |
522 ASSERT_TRUE(contains(m_result["plugins"], "p1")); | |
523 ASSERT_TRUE(contains(m_result["plugins"], "p2")); | |
524 ASSERT_TRUE(contains(m_result["events"], "onMessage")); | |
525 ASSERT_FALSE(contains(m_result["events"], "onCommand")); | |
526 ASSERT_EQ(m_result["action"].get<std::string>(), "drop"); | |
527 } catch (const std::exception &ex) { | |
528 FAIL() << ex.what(); | |
529 } | |
530 } | |
531 | |
532 int main(int argc, char **argv) | |
533 { | |
534 testing::InitGoogleTest(&argc, argv); | |
535 | |
536 return RUN_ALL_TESTS(); | |
537 } |