Mercurial > irccd

comparison tests/cmd-rule-edit/main.cpp @ 453:acb2d4990249

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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 }