Mercurial > irccd

comparison tests/src/rule-move-command/main.cpp @ 581:a51b5dd5b761

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Tests: put everything in src/
author David Demelier <markand@malikania.fr>
date Mon, 04 Dec 2017 14:12:13 +0100
parents tests/rule-move-command/main.cpp@84ea13c850f4
children 029667d16d12
comparison
equal deleted inserted replaced
580:2e16c3623531 581:a51b5dd5b761
1 /*
2 * main.cpp -- test rule-move 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 #define BOOST_TEST_MODULE "rule-move"
20 #include <boost/test/unit_test.hpp>
21
22 #include <irccd/json_util.hpp>
23
24 #include <irccd/command.hpp>
25 #include <irccd/rule_service.hpp>
26
27 #include <command_test.hpp>
28
29 namespace irccd {
30
31 namespace {
32
33 class rule_move_test : public command_test<rule_move_command> {
34 public:
35 rule_move_test()
36 {
37 daemon_->commands().add(std::make_unique<rule_list_command>());
38 daemon_->rules().add(rule(
39 { "s0" },
40 { "c0" },
41 { "o0" },
42 { "p0" },
43 { "onMessage" },
44 rule::action_type::drop
45 ));
46 daemon_->rules().add(rule(
47 { "s1", },
48 { "c1", },
49 { "o1", },
50 { "p1", },
51 { "onMessage", },
52 rule::action_type::accept
53 ));
54 daemon_->rules().add(rule(
55 { "s2", },
56 { "c2", },
57 { "o2", },
58 { "p2", },
59 { "onMessage", },
60 rule::action_type::accept
61 ));
62 }
63 };
64
65 } // !namespace
66
67 BOOST_FIXTURE_TEST_SUITE(rule_move_test_suite, rule_move_test)
68
69 BOOST_AUTO_TEST_CASE(backward)
70 {
71 nlohmann::json result;
72
73 ctl_->send({
74 { "command", "rule-move" },
75 { "from", 2 },
76 { "to", 0 }
77 });
78 ctl_->recv([&] (auto, auto msg) {
79 result = msg;
80 });
81
82 wait_for([&] () {
83 return result.is_object();
84 });
85
86 BOOST_TEST(result.is_object());
87
88 result = nullptr;
89 ctl_->send({{ "command", "rule-list" }});
90 ctl_->recv([&] (auto, auto msg) {
91 result = msg;
92 });
93
94 wait_for([&] () {
95 return result.is_object();
96 });
97
98 BOOST_TEST(result.is_object());
99
100 // Rule 2.
101 {
102 auto servers = result["list"][0]["servers"];
103 auto channels = result["list"][0]["channels"];
104 auto plugins = result["list"][0]["plugins"];
105 auto events = result["list"][0]["events"];
106
107 BOOST_TEST(json_util::contains(servers, "s2"));
108 BOOST_TEST(json_util::contains(channels, "c2"));
109 BOOST_TEST(json_util::contains(plugins, "p2"));
110 BOOST_TEST(json_util::contains(events, "onMessage"));
111 BOOST_TEST(result["list"][0]["action"].get<std::string>() == "accept");
112 }
113
114 // Rule 0.
115 {
116 auto servers = result["list"][1]["servers"];
117 auto channels = result["list"][1]["channels"];
118 auto plugins = result["list"][1]["plugins"];
119 auto events = result["list"][1]["events"];
120
121 BOOST_TEST(json_util::contains(servers, "s0"));
122 BOOST_TEST(json_util::contains(channels, "c0"));
123 BOOST_TEST(json_util::contains(plugins, "p0"));
124 BOOST_TEST(json_util::contains(events, "onMessage"));
125 BOOST_TEST(result["list"][1]["action"].get<std::string>() == "drop");
126 }
127
128 // Rule 1.
129 {
130 auto servers = result["list"][2]["servers"];
131 auto channels = result["list"][2]["channels"];
132 auto plugins = result["list"][2]["plugins"];
133 auto events = result["list"][2]["events"];
134
135 BOOST_TEST(json_util::contains(servers, "s1"));
136 BOOST_TEST(json_util::contains(channels, "c1"));
137 BOOST_TEST(json_util::contains(plugins, "p1"));
138 BOOST_TEST(json_util::contains(events, "onMessage"));
139 BOOST_TEST(result["list"][2]["action"].get<std::string>() == "accept");
140 }
141 }
142
143 BOOST_AUTO_TEST_CASE(upward)
144 {
145 nlohmann::json result;
146
147 ctl_->send({
148 { "command", "rule-move" },
149 { "from", 0 },
150 { "to", 2 }
151 });
152 ctl_->recv([&] (auto, auto msg) {
153 result = msg;
154 });
155
156 wait_for([&] () {
157 return result.is_object();
158 });
159
160 BOOST_TEST(result.is_object());
161
162 result = nullptr;
163 ctl_->send({{ "command", "rule-list" }});
164 ctl_->recv([&] (auto, auto msg) {
165 result = msg;
166 });
167
168 wait_for([&] () {
169 return result.is_object();
170 });
171
172 BOOST_TEST(result.is_object());
173
174 // Rule 1.
175 {
176 auto servers = result["list"][0]["servers"];
177 auto channels = result["list"][0]["channels"];
178 auto plugins = result["list"][0]["plugins"];
179 auto events = result["list"][0]["events"];
180
181 BOOST_TEST(json_util::contains(servers, "s1"));
182 BOOST_TEST(json_util::contains(channels, "c1"));
183 BOOST_TEST(json_util::contains(plugins, "p1"));
184 BOOST_TEST(json_util::contains(events, "onMessage"));
185 BOOST_TEST(result["list"][0]["action"].get<std::string>() == "accept");
186 }
187
188 // Rule 2.
189 {
190 auto servers = result["list"][1]["servers"];
191 auto channels = result["list"][1]["channels"];
192 auto plugins = result["list"][1]["plugins"];
193 auto events = result["list"][1]["events"];
194
195 BOOST_TEST(json_util::contains(servers, "s2"));
196 BOOST_TEST(json_util::contains(channels, "c2"));
197 BOOST_TEST(json_util::contains(plugins, "p2"));
198 BOOST_TEST(json_util::contains(events, "onMessage"));
199 BOOST_TEST(result["list"][1]["action"].get<std::string>() == "accept");
200 }
201
202 // Rule 0.
203 {
204 auto servers = result["list"][2]["servers"];
205 auto channels = result["list"][2]["channels"];
206 auto plugins = result["list"][2]["plugins"];
207 auto events = result["list"][2]["events"];
208
209 BOOST_TEST(json_util::contains(servers, "s0"));
210 BOOST_TEST(json_util::contains(channels, "c0"));
211 BOOST_TEST(json_util::contains(plugins, "p0"));
212 BOOST_TEST(json_util::contains(events, "onMessage"));
213 BOOST_TEST(result["list"][2]["action"].get<std::string>() == "drop");
214 }
215 }
216
217 BOOST_AUTO_TEST_CASE(same)
218 {
219 nlohmann::json result;
220
221 ctl_->send({
222 { "command", "rule-move" },
223 { "from", 1 },
224 { "to", 1 }
225 });
226 ctl_->recv([&] (auto, auto msg) {
227 result = msg;
228 });
229
230 wait_for([&] () {
231 return result.is_object();
232 });
233
234 BOOST_TEST(result.is_object());
235
236 result = nullptr;
237 ctl_->send({{ "command", "rule-list" }});
238 ctl_->recv([&] (auto, auto msg) {
239 result = msg;
240 });
241
242 wait_for([&] () {
243 return result.is_object();
244 });
245
246 BOOST_TEST(result.is_object());
247
248 // Rule 0.
249 {
250 auto servers = result["list"][0]["servers"];
251 auto channels = result["list"][0]["channels"];
252 auto plugins = result["list"][0]["plugins"];
253 auto events = result["list"][0]["events"];
254
255 BOOST_TEST(json_util::contains(servers, "s0"));
256 BOOST_TEST(json_util::contains(channels, "c0"));
257 BOOST_TEST(json_util::contains(plugins, "p0"));
258 BOOST_TEST(json_util::contains(events, "onMessage"));
259 BOOST_TEST(result["list"][0]["action"].get<std::string>() == "drop");
260 }
261
262 // Rule 1.
263 {
264 auto servers = result["list"][1]["servers"];
265 auto channels = result["list"][1]["channels"];
266 auto plugins = result["list"][1]["plugins"];
267 auto events = result["list"][1]["events"];
268
269 BOOST_TEST(json_util::contains(servers, "s1"));
270 BOOST_TEST(json_util::contains(channels, "c1"));
271 BOOST_TEST(json_util::contains(plugins, "p1"));
272 BOOST_TEST(json_util::contains(events, "onMessage"));
273 BOOST_TEST(result["list"][1]["action"].get<std::string>() == "accept");
274 }
275
276 // Rule 2.
277 {
278 auto servers = result["list"][2]["servers"];
279 auto channels = result["list"][2]["channels"];
280 auto plugins = result["list"][2]["plugins"];
281 auto events = result["list"][2]["events"];
282
283 BOOST_TEST(json_util::contains(servers, "s2"));
284 BOOST_TEST(json_util::contains(channels, "c2"));
285 BOOST_TEST(json_util::contains(plugins, "p2"));
286 BOOST_TEST(json_util::contains(events, "onMessage"));
287 BOOST_TEST(result["list"][2]["action"].get<std::string>() == "accept");
288 }
289 }
290
291 BOOST_AUTO_TEST_CASE(beyond)
292 {
293 nlohmann::json result;
294
295 ctl_->send({
296 { "command", "rule-move" },
297 { "from", 0 },
298 { "to", 123 }
299 });
300 ctl_->recv([&] (auto, auto msg) {
301 result = msg;
302 });
303
304 wait_for([&] () {
305 return result.is_object();
306 });
307
308 BOOST_TEST(result.is_object());
309
310 result = nullptr;
311 ctl_->send({{ "command", "rule-list" }});
312 ctl_->recv([&] (auto, auto msg) {
313 result = msg;
314 });
315
316 wait_for([&] () {
317 return result.is_object();
318 });
319
320 BOOST_TEST(result.is_object());
321
322 // Rule 1.
323 {
324 auto servers = result["list"][0]["servers"];
325 auto channels = result["list"][0]["channels"];
326 auto plugins = result["list"][0]["plugins"];
327 auto events = result["list"][0]["events"];
328
329 BOOST_TEST(json_util::contains(servers, "s1"));
330 BOOST_TEST(json_util::contains(channels, "c1"));
331 BOOST_TEST(json_util::contains(plugins, "p1"));
332 BOOST_TEST(json_util::contains(events, "onMessage"));
333 BOOST_TEST(result["list"][0]["action"].get<std::string>() == "accept");
334 }
335
336 // Rule 2.
337 {
338 auto servers = result["list"][1]["servers"];
339 auto channels = result["list"][1]["channels"];
340 auto plugins = result["list"][1]["plugins"];
341 auto events = result["list"][1]["events"];
342
343 BOOST_TEST(json_util::contains(servers, "s2"));
344 BOOST_TEST(json_util::contains(channels, "c2"));
345 BOOST_TEST(json_util::contains(plugins, "p2"));
346 BOOST_TEST(json_util::contains(events, "onMessage"));
347 BOOST_TEST(result["list"][1]["action"].get<std::string>() == "accept");
348 }
349
350 // Rule 0.
351 {
352 auto servers = result["list"][2]["servers"];
353 auto channels = result["list"][2]["channels"];
354 auto plugins = result["list"][2]["plugins"];
355 auto events = result["list"][2]["events"];
356
357 BOOST_TEST(json_util::contains(servers, "s0"));
358 BOOST_TEST(json_util::contains(channels, "c0"));
359 BOOST_TEST(json_util::contains(plugins, "p0"));
360 BOOST_TEST(json_util::contains(events, "onMessage"));
361 BOOST_TEST(result["list"][2]["action"].get<std::string>() == "drop");
362 }
363 }
364
365 BOOST_AUTO_TEST_SUITE(errors)
366
367 BOOST_AUTO_TEST_CASE(invalid_index_1_from)
368 {
369 boost::system::error_code result;
370
371 ctl_->send({
372 { "command", "rule-move" },
373 { "from", -100 },
374 { "to", 0 }
375 });
376 ctl_->recv([&] (auto code, auto) {
377 result = code;
378 });
379
380 wait_for([&] {
381 return result;
382 });
383
384 BOOST_ASSERT(result == rule_error::invalid_index);
385 }
386
387 BOOST_AUTO_TEST_CASE(invalid_index_1_to)
388 {
389 boost::system::error_code result;
390
391 ctl_->send({
392 { "command", "rule-move" },
393 { "from", 0 },
394 { "to", -100 }
395 });
396 ctl_->recv([&] (auto code, auto) {
397 result = code;
398 });
399
400 wait_for([&] {
401 return result;
402 });
403
404 BOOST_ASSERT(result == rule_error::invalid_index);
405 }
406
407 BOOST_AUTO_TEST_CASE(invalid_index_2_from)
408 {
409 boost::system::error_code result;
410
411 ctl_->send({
412 { "command", "rule-move" },
413 { "from", 100 },
414 { "to", 0 }
415 });
416 ctl_->recv([&] (auto code, auto) {
417 result = code;
418 });
419
420 wait_for([&] {
421 return result;
422 });
423
424 BOOST_ASSERT(result == rule_error::invalid_index);
425 }
426
427 BOOST_AUTO_TEST_CASE(invalid_index_3_from)
428 {
429 boost::system::error_code result;
430
431 ctl_->send({
432 { "command", "rule-move" },
433 { "from", "notaint" },
434 { "to", 0 }
435 });
436 ctl_->recv([&] (auto code, auto) {
437 result = code;
438 });
439
440 wait_for([&] {
441 return result;
442 });
443
444 BOOST_ASSERT(result == rule_error::invalid_index);
445 }
446
447 BOOST_AUTO_TEST_CASE(invalid_index_3_to)
448 {
449 boost::system::error_code result;
450
451 ctl_->send({
452 { "command", "rule-move" },
453 { "from", 0 },
454 { "to", "notaint" }
455 });
456 ctl_->recv([&] (auto code, auto) {
457 result = code;
458 });
459
460 wait_for([&] {
461 return result;
462 });
463
464 BOOST_ASSERT(result == rule_error::invalid_index);
465 }
466
467 BOOST_AUTO_TEST_SUITE_END()
468
469 BOOST_AUTO_TEST_SUITE_END()
470
471 } // !irccd