Mercurial > irccd

comparison tests/cmd-rule-move/main.cpp @ 451:1fdedd2977d2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Irccdctl: implement rule-move
author David Demelier <markand@malikania.fr>
date Fri, 07 Jul 2017 18:03:18 +0200
parents
children 7e273b7f4f92
comparison
equal deleted inserted replaced
450:c8c68d4bf555 451:1fdedd2977d2
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 #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 RuleMoveCommandTest : 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 RuleMoveCommandTest()
45 : CommandTester(std::make_unique<RuleMoveCommand>())
46 {
47 m_irccd.commands().add(std::make_unique<RuleListCommand>());
48 m_irccd.rules().add(Rule(
49 { "s0" },
50 { "c0" },
51 { "o0" },
52 { "p0" },
53 { "onMessage" },
54 RuleAction::Drop
55 ));
56 m_irccd.rules().add(Rule(
57 { "s1", },
58 { "c1", },
59 { "o1", },
60 { "p1", },
61 { "onMessage", },
62 RuleAction::Accept
63 ));
64 m_irccd.rules().add(Rule(
65 { "s2", },
66 { "c2", },
67 { "o2", },
68 { "p2", },
69 { "onMessage", },
70 RuleAction::Accept
71 ));
72 m_irccdctl.client().onMessage.connect([&] (auto result) {
73 m_result = result;
74 });
75 }
76 };
77
78 TEST_F(RuleMoveCommandTest, backward)
79 {
80 try {
81 m_irccdctl.client().request({
82 { "command", "rule-move" },
83 { "from", 2 },
84 { "to", 0 }
85 });
86
87 poll([&] () {
88 return m_result.is_object();
89 });
90
91 ASSERT_TRUE(m_result.is_object());
92 ASSERT_TRUE(m_result["status"].get<bool>());
93
94 m_result = nullptr;
95 m_irccdctl.client().request({{ "command", "rule-list" }});
96
97 poll([&] () {
98 return m_result.is_object();
99 });
100
101 ASSERT_TRUE(m_result.is_object());
102 ASSERT_TRUE(m_result["status"].get<bool>());
103
104 // Rule 2.
105 {
106 auto servers = m_result["list"][0]["servers"];
107 auto channels = m_result["list"][0]["channels"];
108 auto plugins = m_result["list"][0]["plugins"];
109 auto events = m_result["list"][0]["events"];
110
111 ASSERT_TRUE(contains(servers, "s2"));
112 ASSERT_TRUE(contains(channels, "c2"));
113 ASSERT_TRUE(contains(plugins, "p2"));
114 ASSERT_TRUE(contains(events, "onMessage"));
115 ASSERT_EQ("accept", m_result["list"][0]["action"].get<std::string>());
116 }
117
118 // Rule 0.
119 {
120 auto servers = m_result["list"][1]["servers"];
121 auto channels = m_result["list"][1]["channels"];
122 auto plugins = m_result["list"][1]["plugins"];
123 auto events = m_result["list"][1]["events"];
124
125 ASSERT_TRUE(contains(servers, "s0"));
126 ASSERT_TRUE(contains(channels, "c0"));
127 ASSERT_TRUE(contains(plugins, "p0"));
128 ASSERT_TRUE(contains(events, "onMessage"));
129 ASSERT_EQ("drop", m_result["list"][1]["action"].get<std::string>());
130 }
131
132 // Rule 1.
133 {
134 auto servers = m_result["list"][2]["servers"];
135 auto channels = m_result["list"][2]["channels"];
136 auto plugins = m_result["list"][2]["plugins"];
137 auto events = m_result["list"][2]["events"];
138
139 ASSERT_TRUE(contains(servers, "s1"));
140 ASSERT_TRUE(contains(channels, "c1"));
141 ASSERT_TRUE(contains(plugins, "p1"));
142 ASSERT_TRUE(contains(events, "onMessage"));
143 ASSERT_EQ("accept", m_result["list"][2]["action"].get<std::string>());
144 }
145 } catch (const std::exception& ex) {
146 FAIL() << ex.what();
147 }
148 }
149
150 TEST_F(RuleMoveCommandTest, upward)
151 {
152 try {
153 m_irccdctl.client().request({
154 { "command", "rule-move" },
155 { "from", 0 },
156 { "to", 2 }
157 });
158
159 poll([&] () {
160 return m_result.is_object();
161 });
162
163 ASSERT_TRUE(m_result.is_object());
164 ASSERT_TRUE(m_result["status"].get<bool>());
165
166 m_result = nullptr;
167 m_irccdctl.client().request({{ "command", "rule-list" }});
168
169 poll([&] () {
170 return m_result.is_object();
171 });
172
173 ASSERT_TRUE(m_result.is_object());
174 ASSERT_TRUE(m_result["status"].get<bool>());
175
176 // Rule 1.
177 {
178 auto servers = m_result["list"][0]["servers"];
179 auto channels = m_result["list"][0]["channels"];
180 auto plugins = m_result["list"][0]["plugins"];
181 auto events = m_result["list"][0]["events"];
182
183 ASSERT_TRUE(contains(servers, "s1"));
184 ASSERT_TRUE(contains(channels, "c1"));
185 ASSERT_TRUE(contains(plugins, "p1"));
186 ASSERT_TRUE(contains(events, "onMessage"));
187 ASSERT_EQ("accept", m_result["list"][0]["action"].get<std::string>());
188 }
189
190 // Rule 2.
191 {
192 auto servers = m_result["list"][1]["servers"];
193 auto channels = m_result["list"][1]["channels"];
194 auto plugins = m_result["list"][1]["plugins"];
195 auto events = m_result["list"][1]["events"];
196
197 ASSERT_TRUE(contains(servers, "s2"));
198 ASSERT_TRUE(contains(channels, "c2"));
199 ASSERT_TRUE(contains(plugins, "p2"));
200 ASSERT_TRUE(contains(events, "onMessage"));
201 ASSERT_EQ("accept", m_result["list"][1]["action"].get<std::string>());
202 }
203
204 // Rule 0.
205 {
206 auto servers = m_result["list"][2]["servers"];
207 auto channels = m_result["list"][2]["channels"];
208 auto plugins = m_result["list"][2]["plugins"];
209 auto events = m_result["list"][2]["events"];
210
211 ASSERT_TRUE(contains(servers, "s0"));
212 ASSERT_TRUE(contains(channels, "c0"));
213 ASSERT_TRUE(contains(plugins, "p0"));
214 ASSERT_TRUE(contains(events, "onMessage"));
215 ASSERT_EQ("drop", m_result["list"][2]["action"].get<std::string>());
216 }
217 } catch (const std::exception& ex) {
218 FAIL() << ex.what();
219 }
220 }
221
222 TEST_F(RuleMoveCommandTest, same)
223 {
224 try {
225 m_irccdctl.client().request({
226 { "command", "rule-move" },
227 { "from", 1 },
228 { "to", 1 }
229 });
230
231 poll([&] () {
232 return m_result.is_object();
233 });
234
235 ASSERT_TRUE(m_result.is_object());
236 ASSERT_TRUE(m_result["status"].get<bool>());
237
238 m_result = nullptr;
239 m_irccdctl.client().request({{ "command", "rule-list" }});
240
241 poll([&] () {
242 return m_result.is_object();
243 });
244
245 ASSERT_TRUE(m_result.is_object());
246 ASSERT_TRUE(m_result["status"].get<bool>());
247
248 // Rule 0.
249 {
250 auto servers = m_result["list"][0]["servers"];
251 auto channels = m_result["list"][0]["channels"];
252 auto plugins = m_result["list"][0]["plugins"];
253 auto events = m_result["list"][0]["events"];
254
255 ASSERT_TRUE(contains(servers, "s0"));
256 ASSERT_TRUE(contains(channels, "c0"));
257 ASSERT_TRUE(contains(plugins, "p0"));
258 ASSERT_TRUE(contains(events, "onMessage"));
259 ASSERT_EQ("drop", m_result["list"][0]["action"].get<std::string>());
260 }
261
262 // Rule 1.
263 {
264 auto servers = m_result["list"][1]["servers"];
265 auto channels = m_result["list"][1]["channels"];
266 auto plugins = m_result["list"][1]["plugins"];
267 auto events = m_result["list"][1]["events"];
268
269 ASSERT_TRUE(contains(servers, "s1"));
270 ASSERT_TRUE(contains(channels, "c1"));
271 ASSERT_TRUE(contains(plugins, "p1"));
272 ASSERT_TRUE(contains(events, "onMessage"));
273 ASSERT_EQ("accept", m_result["list"][1]["action"].get<std::string>());
274 }
275
276 // Rule 2.
277 {
278 auto servers = m_result["list"][2]["servers"];
279 auto channels = m_result["list"][2]["channels"];
280 auto plugins = m_result["list"][2]["plugins"];
281 auto events = m_result["list"][2]["events"];
282
283 ASSERT_TRUE(contains(servers, "s2"));
284 ASSERT_TRUE(contains(channels, "c2"));
285 ASSERT_TRUE(contains(plugins, "p2"));
286 ASSERT_TRUE(contains(events, "onMessage"));
287 ASSERT_EQ("accept", m_result["list"][2]["action"].get<std::string>());
288 }
289 } catch (const std::exception& ex) {
290 FAIL() << ex.what();
291 }
292 }
293
294 TEST_F(RuleMoveCommandTest, beyond)
295 {
296 try {
297 m_irccdctl.client().request({
298 { "command", "rule-move" },
299 { "from", 0 },
300 { "to", 123 }
301 });
302
303 poll([&] () {
304 return m_result.is_object();
305 });
306
307 ASSERT_TRUE(m_result.is_object());
308 ASSERT_TRUE(m_result["status"].get<bool>());
309
310 m_result = nullptr;
311 m_irccdctl.client().request({{ "command", "rule-list" }});
312
313 poll([&] () {
314 return m_result.is_object();
315 });
316
317 ASSERT_TRUE(m_result.is_object());
318 ASSERT_TRUE(m_result["status"].get<bool>());
319
320 // Rule 1.
321 {
322 auto servers = m_result["list"][0]["servers"];
323 auto channels = m_result["list"][0]["channels"];
324 auto plugins = m_result["list"][0]["plugins"];
325 auto events = m_result["list"][0]["events"];
326
327 ASSERT_TRUE(contains(servers, "s1"));
328 ASSERT_TRUE(contains(channels, "c1"));
329 ASSERT_TRUE(contains(plugins, "p1"));
330 ASSERT_TRUE(contains(events, "onMessage"));
331 ASSERT_EQ("accept", m_result["list"][0]["action"].get<std::string>());
332 }
333
334 // Rule 2.
335 {
336 auto servers = m_result["list"][1]["servers"];
337 auto channels = m_result["list"][1]["channels"];
338 auto plugins = m_result["list"][1]["plugins"];
339 auto events = m_result["list"][1]["events"];
340
341 ASSERT_TRUE(contains(servers, "s2"));
342 ASSERT_TRUE(contains(channels, "c2"));
343 ASSERT_TRUE(contains(plugins, "p2"));
344 ASSERT_TRUE(contains(events, "onMessage"));
345 ASSERT_EQ("accept", m_result["list"][1]["action"].get<std::string>());
346 }
347
348 // Rule 0.
349 {
350 auto servers = m_result["list"][2]["servers"];
351 auto channels = m_result["list"][2]["channels"];
352 auto plugins = m_result["list"][2]["plugins"];
353 auto events = m_result["list"][2]["events"];
354
355 ASSERT_TRUE(contains(servers, "s0"));
356 ASSERT_TRUE(contains(channels, "c0"));
357 ASSERT_TRUE(contains(plugins, "p0"));
358 ASSERT_TRUE(contains(events, "onMessage"));
359 ASSERT_EQ("drop", m_result["list"][2]["action"].get<std::string>());
360 }
361 } catch (const std::exception& ex) {
362 FAIL() << ex.what();
363 }
364 }
365
366 TEST_F(RuleMoveCommandTest, outOfBounds)
367 {
368 try {
369 m_irccdctl.client().request({
370 { "command", "rule-move" },
371 { "from", 1024 },
372 { "to", 0 }
373 });
374
375 poll([&] () {
376 return m_result.is_object();
377 });
378
379 ASSERT_TRUE(m_result.is_object());
380 ASSERT_FALSE(m_result["status"].get<bool>());
381 } catch (const std::exception& ex) {
382 FAIL() << ex.what();
383 }
384 }
385
386 int main(int argc, char **argv)
387 {
388 testing::InitGoogleTest(&argc, argv);
389
390 return RUN_ALL_TESTS();
391 }