Mercurial > irccd

comparison tests/cmd-rule-move/main.cpp @ 557:c729f06c6f27

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Tests: convert cmd-rule-*, #593
author David Demelier <markand@malikania.fr>
date Sat, 25 Nov 2017 14:34:20 +0100
parents 7e273b7f4f92
children 23fc81b1bd8f
comparison
equal deleted inserted replaced
556:c9b703f923d0 557:c729f06c6f27
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 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 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */ 17 */
18 18
19 #include <command.hpp> 19 #define BOOST_TEST_MODULE "rule-move"
20 #include <command-tester.hpp> 20 #include <boost/test/unit_test.hpp>
21 #include <service.hpp> 21
22 22 #include <irccd/json_util.hpp>
23 using namespace irccd; 23
24 24 #include <irccd/command.hpp>
25 class RuleMoveCommandTest : public CommandTester { 25 #include <irccd/rule_service.hpp>
26 protected: 26
27 nlohmann::json m_result; 27 #include <command_test.hpp>
28 28
29 /* 29 namespace irccd {
30 * Rule sets are unordered so use this function to search a string in 30
31 * the JSON array. 31 namespace {
32 */ 32
33 inline bool contains(const nlohmann::json &array, const std::string &str) 33 class rule_move_test : public command_test<rule_move_command> {
34 {
35 for (const auto &v : array)
36 if (v.is_string() && v == str)
37 return true;
38
39 return false;
40 }
41
42 public: 34 public:
43 RuleMoveCommandTest() 35 rule_move_test()
44 : CommandTester(std::make_unique<rule_move_command>()) 36 {
45 { 37 daemon_->commands().add(std::make_unique<rule_list_command>());
46 m_irccd.commands().add(std::make_unique<rule_list_command>()); 38 daemon_->rules().add(rule(
47 m_irccd.rules().add(rule(
48 { "s0" }, 39 { "s0" },
49 { "c0" }, 40 { "c0" },
50 { "o0" }, 41 { "o0" },
51 { "p0" }, 42 { "p0" },
52 { "onMessage" }, 43 { "onMessage" },
53 rule::action_type::drop 44 rule::action_type::drop
54 )); 45 ));
55 m_irccd.rules().add(rule( 46 daemon_->rules().add(rule(
56 { "s1", }, 47 { "s1", },
57 { "c1", }, 48 { "c1", },
58 { "o1", }, 49 { "o1", },
59 { "p1", }, 50 { "p1", },
60 { "onMessage", }, 51 { "onMessage", },
61 rule::action_type::accept 52 rule::action_type::accept
62 )); 53 ));
63 m_irccd.rules().add(rule( 54 daemon_->rules().add(rule(
64 { "s2", }, 55 { "s2", },
65 { "c2", }, 56 { "c2", },
66 { "o2", }, 57 { "o2", },
67 { "p2", }, 58 { "p2", },
68 { "onMessage", }, 59 { "onMessage", },
69 rule::action_type::accept 60 rule::action_type::accept
70 )); 61 ));
71 m_irccdctl.client().onMessage.connect([&] (auto result) {
72 m_result = result;
73 });
74 } 62 }
75 }; 63 };
76 64
77 TEST_F(RuleMoveCommandTest, backward) 65 } // !namespace
78 { 66
79 try { 67 BOOST_FIXTURE_TEST_SUITE(rule_move_test_suite, rule_move_test)
80 m_irccdctl.client().request({ 68
81 { "command", "rule-move" }, 69 BOOST_AUTO_TEST_CASE(backward)
82 { "from", 2 }, 70 {
83 { "to", 0 } 71 nlohmann::json result;
84 }); 72
85 73 ctl_->send({
86 poll([&] () { 74 { "command", "rule-move" },
87 return m_result.is_object(); 75 { "from", 2 },
88 }); 76 { "to", 0 }
89 77 });
90 ASSERT_TRUE(m_result.is_object()); 78 ctl_->recv([&] (auto, auto msg) {
91 ASSERT_TRUE(m_result["status"].get<bool>()); 79 result = msg;
92 80 });
93 m_result = nullptr; 81
94 m_irccdctl.client().request({{ "command", "rule-list" }}); 82 wait_for([&] () {
95 83 return result.is_object();
96 poll([&] () { 84 });
97 return m_result.is_object(); 85
98 }); 86 BOOST_TEST(result.is_object());
99 87
100 ASSERT_TRUE(m_result.is_object()); 88 result = nullptr;
101 ASSERT_TRUE(m_result["status"].get<bool>()); 89 ctl_->send({{ "command", "rule-list" }});
102 90 ctl_->recv([&] (auto, auto msg) {
103 // Rule 2. 91 result = msg;
104 { 92 });
105 auto servers = m_result["list"][0]["servers"]; 93
106 auto channels = m_result["list"][0]["channels"]; 94 wait_for([&] () {
107 auto plugins = m_result["list"][0]["plugins"]; 95 return result.is_object();
108 auto events = m_result["list"][0]["events"]; 96 });
109 97
110 ASSERT_TRUE(contains(servers, "s2")); 98 BOOST_TEST(result.is_object());
111 ASSERT_TRUE(contains(channels, "c2")); 99
112 ASSERT_TRUE(contains(plugins, "p2")); 100 // Rule 2.
113 ASSERT_TRUE(contains(events, "onMessage")); 101 {
114 ASSERT_EQ("accept", m_result["list"][0]["action"].get<std::string>()); 102 auto servers = result["list"][0]["servers"];
115 } 103 auto channels = result["list"][0]["channels"];
116 104 auto plugins = result["list"][0]["plugins"];
117 // Rule 0. 105 auto events = result["list"][0]["events"];
118 { 106
119 auto servers = m_result["list"][1]["servers"]; 107 BOOST_TEST(json_util::contains(servers, "s2"));
120 auto channels = m_result["list"][1]["channels"]; 108 BOOST_TEST(json_util::contains(channels, "c2"));
121 auto plugins = m_result["list"][1]["plugins"]; 109 BOOST_TEST(json_util::contains(plugins, "p2"));
122 auto events = m_result["list"][1]["events"]; 110 BOOST_TEST(json_util::contains(events, "onMessage"));
123 111 BOOST_TEST(result["list"][0]["action"].get<std::string>() == "accept");
124 ASSERT_TRUE(contains(servers, "s0")); 112 }
125 ASSERT_TRUE(contains(channels, "c0")); 113
126 ASSERT_TRUE(contains(plugins, "p0")); 114 // Rule 0.
127 ASSERT_TRUE(contains(events, "onMessage")); 115 {
128 ASSERT_EQ("drop", m_result["list"][1]["action"].get<std::string>()); 116 auto servers = result["list"][1]["servers"];
129 } 117 auto channels = result["list"][1]["channels"];
130 118 auto plugins = result["list"][1]["plugins"];
131 // Rule 1. 119 auto events = result["list"][1]["events"];
132 { 120
133 auto servers = m_result["list"][2]["servers"]; 121 BOOST_TEST(json_util::contains(servers, "s0"));
134 auto channels = m_result["list"][2]["channels"]; 122 BOOST_TEST(json_util::contains(channels, "c0"));
135 auto plugins = m_result["list"][2]["plugins"]; 123 BOOST_TEST(json_util::contains(plugins, "p0"));
136 auto events = m_result["list"][2]["events"]; 124 BOOST_TEST(json_util::contains(events, "onMessage"));
137 125 BOOST_TEST(result["list"][1]["action"].get<std::string>() == "drop");
138 ASSERT_TRUE(contains(servers, "s1")); 126 }
139 ASSERT_TRUE(contains(channels, "c1")); 127
140 ASSERT_TRUE(contains(plugins, "p1")); 128 // Rule 1.
141 ASSERT_TRUE(contains(events, "onMessage")); 129 {
142 ASSERT_EQ("accept", m_result["list"][2]["action"].get<std::string>()); 130 auto servers = result["list"][2]["servers"];
143 } 131 auto channels = result["list"][2]["channels"];
144 } catch (const std::exception& ex) { 132 auto plugins = result["list"][2]["plugins"];
145 FAIL() << ex.what(); 133 auto events = result["list"][2]["events"];
146 } 134
147 } 135 BOOST_TEST(json_util::contains(servers, "s1"));
148 136 BOOST_TEST(json_util::contains(channels, "c1"));
149 TEST_F(RuleMoveCommandTest, upward) 137 BOOST_TEST(json_util::contains(plugins, "p1"));
150 { 138 BOOST_TEST(json_util::contains(events, "onMessage"));
151 try { 139 BOOST_TEST(result["list"][2]["action"].get<std::string>() == "accept");
152 m_irccdctl.client().request({ 140 }
153 { "command", "rule-move" }, 141 }
154 { "from", 0 }, 142
155 { "to", 2 } 143 BOOST_AUTO_TEST_CASE(upward)
156 }); 144 {
157 145 nlohmann::json result;
158 poll([&] () { 146
159 return m_result.is_object(); 147 ctl_->send({
160 }); 148 { "command", "rule-move" },
161 149 { "from", 0 },
162 ASSERT_TRUE(m_result.is_object()); 150 { "to", 2 }
163 ASSERT_TRUE(m_result["status"].get<bool>()); 151 });
164 152 ctl_->recv([&] (auto, auto msg) {
165 m_result = nullptr; 153 result = msg;
166 m_irccdctl.client().request({{ "command", "rule-list" }}); 154 });
167 155
168 poll([&] () { 156 wait_for([&] () {
169 return m_result.is_object(); 157 return result.is_object();
170 }); 158 });
171 159
172 ASSERT_TRUE(m_result.is_object()); 160 BOOST_TEST(result.is_object());
173 ASSERT_TRUE(m_result["status"].get<bool>()); 161
174 162 result = nullptr;
175 // Rule 1. 163 ctl_->send({{ "command", "rule-list" }});
176 { 164 ctl_->recv([&] (auto, auto msg) {
177 auto servers = m_result["list"][0]["servers"]; 165 result = msg;
178 auto channels = m_result["list"][0]["channels"]; 166 });
179 auto plugins = m_result["list"][0]["plugins"]; 167
180 auto events = m_result["list"][0]["events"]; 168 wait_for([&] () {
181 169 return result.is_object();
182 ASSERT_TRUE(contains(servers, "s1")); 170 });
183 ASSERT_TRUE(contains(channels, "c1")); 171
184 ASSERT_TRUE(contains(plugins, "p1")); 172 BOOST_TEST(result.is_object());
185 ASSERT_TRUE(contains(events, "onMessage")); 173
186 ASSERT_EQ("accept", m_result["list"][0]["action"].get<std::string>()); 174 // Rule 1.
187 } 175 {
188 176 auto servers = result["list"][0]["servers"];
189 // Rule 2. 177 auto channels = result["list"][0]["channels"];
190 { 178 auto plugins = result["list"][0]["plugins"];
191 auto servers = m_result["list"][1]["servers"]; 179 auto events = result["list"][0]["events"];
192 auto channels = m_result["list"][1]["channels"]; 180
193 auto plugins = m_result["list"][1]["plugins"]; 181 BOOST_TEST(json_util::contains(servers, "s1"));
194 auto events = m_result["list"][1]["events"]; 182 BOOST_TEST(json_util::contains(channels, "c1"));
195 183 BOOST_TEST(json_util::contains(plugins, "p1"));
196 ASSERT_TRUE(contains(servers, "s2")); 184 BOOST_TEST(json_util::contains(events, "onMessage"));
197 ASSERT_TRUE(contains(channels, "c2")); 185 BOOST_TEST(result["list"][0]["action"].get<std::string>() == "accept");
198 ASSERT_TRUE(contains(plugins, "p2")); 186 }
199 ASSERT_TRUE(contains(events, "onMessage")); 187
200 ASSERT_EQ("accept", m_result["list"][1]["action"].get<std::string>()); 188 // Rule 2.
201 } 189 {
202 190 auto servers = result["list"][1]["servers"];
203 // Rule 0. 191 auto channels = result["list"][1]["channels"];
204 { 192 auto plugins = result["list"][1]["plugins"];
205 auto servers = m_result["list"][2]["servers"]; 193 auto events = result["list"][1]["events"];
206 auto channels = m_result["list"][2]["channels"]; 194
207 auto plugins = m_result["list"][2]["plugins"]; 195 BOOST_TEST(json_util::contains(servers, "s2"));
208 auto events = m_result["list"][2]["events"]; 196 BOOST_TEST(json_util::contains(channels, "c2"));
209 197 BOOST_TEST(json_util::contains(plugins, "p2"));
210 ASSERT_TRUE(contains(servers, "s0")); 198 BOOST_TEST(json_util::contains(events, "onMessage"));
211 ASSERT_TRUE(contains(channels, "c0")); 199 BOOST_TEST(result["list"][1]["action"].get<std::string>() == "accept");
212 ASSERT_TRUE(contains(plugins, "p0")); 200 }
213 ASSERT_TRUE(contains(events, "onMessage")); 201
214 ASSERT_EQ("drop", m_result["list"][2]["action"].get<std::string>()); 202 // Rule 0.
215 } 203 {
216 } catch (const std::exception& ex) { 204 auto servers = result["list"][2]["servers"];
217 FAIL() << ex.what(); 205 auto channels = result["list"][2]["channels"];
218 } 206 auto plugins = result["list"][2]["plugins"];
219 } 207 auto events = result["list"][2]["events"];
220 208
221 TEST_F(RuleMoveCommandTest, same) 209 BOOST_TEST(json_util::contains(servers, "s0"));
222 { 210 BOOST_TEST(json_util::contains(channels, "c0"));
223 try { 211 BOOST_TEST(json_util::contains(plugins, "p0"));
224 m_irccdctl.client().request({ 212 BOOST_TEST(json_util::contains(events, "onMessage"));
225 { "command", "rule-move" }, 213 BOOST_TEST(result["list"][2]["action"].get<std::string>() == "drop");
226 { "from", 1 }, 214 }
227 { "to", 1 } 215 }
228 }); 216
229 217 BOOST_AUTO_TEST_CASE(same)
230 poll([&] () { 218 {
231 return m_result.is_object(); 219 nlohmann::json result;
232 }); 220
233 221 ctl_->send({
234 ASSERT_TRUE(m_result.is_object()); 222 { "command", "rule-move" },
235 ASSERT_TRUE(m_result["status"].get<bool>()); 223 { "from", 1 },
236 224 { "to", 1 }
237 m_result = nullptr; 225 });
238 m_irccdctl.client().request({{ "command", "rule-list" }}); 226 ctl_->recv([&] (auto, auto msg) {
239 227 result = msg;
240 poll([&] () { 228 });
241 return m_result.is_object(); 229
242 }); 230 wait_for([&] () {
243 231 return result.is_object();
244 ASSERT_TRUE(m_result.is_object()); 232 });
245 ASSERT_TRUE(m_result["status"].get<bool>()); 233
246 234 BOOST_TEST(result.is_object());
247 // Rule 0. 235
248 { 236 result = nullptr;
249 auto servers = m_result["list"][0]["servers"]; 237 ctl_->send({{ "command", "rule-list" }});
250 auto channels = m_result["list"][0]["channels"]; 238 ctl_->recv([&] (auto, auto msg) {
251 auto plugins = m_result["list"][0]["plugins"]; 239 result = msg;
252 auto events = m_result["list"][0]["events"]; 240 });
253 241
254 ASSERT_TRUE(contains(servers, "s0")); 242 wait_for([&] () {
255 ASSERT_TRUE(contains(channels, "c0")); 243 return result.is_object();
256 ASSERT_TRUE(contains(plugins, "p0")); 244 });
257 ASSERT_TRUE(contains(events, "onMessage")); 245
258 ASSERT_EQ("drop", m_result["list"][0]["action"].get<std::string>()); 246 BOOST_TEST(result.is_object());
259 } 247
260 248 // Rule 0.
261 // Rule 1. 249 {
262 { 250 auto servers = result["list"][0]["servers"];
263 auto servers = m_result["list"][1]["servers"]; 251 auto channels = result["list"][0]["channels"];
264 auto channels = m_result["list"][1]["channels"]; 252 auto plugins = result["list"][0]["plugins"];
265 auto plugins = m_result["list"][1]["plugins"]; 253 auto events = result["list"][0]["events"];
266 auto events = m_result["list"][1]["events"]; 254
267 255 BOOST_TEST(json_util::contains(servers, "s0"));
268 ASSERT_TRUE(contains(servers, "s1")); 256 BOOST_TEST(json_util::contains(channels, "c0"));
269 ASSERT_TRUE(contains(channels, "c1")); 257 BOOST_TEST(json_util::contains(plugins, "p0"));
270 ASSERT_TRUE(contains(plugins, "p1")); 258 BOOST_TEST(json_util::contains(events, "onMessage"));
271 ASSERT_TRUE(contains(events, "onMessage")); 259 BOOST_TEST(result["list"][0]["action"].get<std::string>() == "drop");
272 ASSERT_EQ("accept", m_result["list"][1]["action"].get<std::string>()); 260 }
273 } 261
274 262 // Rule 1.
275 // Rule 2. 263 {
276 { 264 auto servers = result["list"][1]["servers"];
277 auto servers = m_result["list"][2]["servers"]; 265 auto channels = result["list"][1]["channels"];
278 auto channels = m_result["list"][2]["channels"]; 266 auto plugins = result["list"][1]["plugins"];
279 auto plugins = m_result["list"][2]["plugins"]; 267 auto events = result["list"][1]["events"];
280 auto events = m_result["list"][2]["events"]; 268
281 269 BOOST_TEST(json_util::contains(servers, "s1"));
282 ASSERT_TRUE(contains(servers, "s2")); 270 BOOST_TEST(json_util::contains(channels, "c1"));
283 ASSERT_TRUE(contains(channels, "c2")); 271 BOOST_TEST(json_util::contains(plugins, "p1"));
284 ASSERT_TRUE(contains(plugins, "p2")); 272 BOOST_TEST(json_util::contains(events, "onMessage"));
285 ASSERT_TRUE(contains(events, "onMessage")); 273 BOOST_TEST(result["list"][1]["action"].get<std::string>() == "accept");
286 ASSERT_EQ("accept", m_result["list"][2]["action"].get<std::string>()); 274 }
287 } 275
288 } catch (const std::exception& ex) { 276 // Rule 2.
289 FAIL() << ex.what(); 277 {
290 } 278 auto servers = result["list"][2]["servers"];
291 } 279 auto channels = result["list"][2]["channels"];
292 280 auto plugins = result["list"][2]["plugins"];
293 TEST_F(RuleMoveCommandTest, beyond) 281 auto events = result["list"][2]["events"];
294 { 282
295 try { 283 BOOST_TEST(json_util::contains(servers, "s2"));
296 m_irccdctl.client().request({ 284 BOOST_TEST(json_util::contains(channels, "c2"));
297 { "command", "rule-move" }, 285 BOOST_TEST(json_util::contains(plugins, "p2"));
298 { "from", 0 }, 286 BOOST_TEST(json_util::contains(events, "onMessage"));
299 { "to", 123 } 287 BOOST_TEST(result["list"][2]["action"].get<std::string>() == "accept");
300 }); 288 }
301 289 }
302 poll([&] () { 290
303 return m_result.is_object(); 291 BOOST_AUTO_TEST_CASE(beyond)
304 }); 292 {
305 293 nlohmann::json result;
306 ASSERT_TRUE(m_result.is_object()); 294
307 ASSERT_TRUE(m_result["status"].get<bool>()); 295 ctl_->send({
308 296 { "command", "rule-move" },
309 m_result = nullptr; 297 { "from", 0 },
310 m_irccdctl.client().request({{ "command", "rule-list" }}); 298 { "to", 123 }
311 299 });
312 poll([&] () { 300 ctl_->recv([&] (auto, auto msg) {
313 return m_result.is_object(); 301 result = msg;
314 }); 302 });
315 303
316 ASSERT_TRUE(m_result.is_object()); 304 wait_for([&] () {
317 ASSERT_TRUE(m_result["status"].get<bool>()); 305 return result.is_object();
318 306 });
319 // Rule 1. 307
320 { 308 BOOST_TEST(result.is_object());
321 auto servers = m_result["list"][0]["servers"]; 309
322 auto channels = m_result["list"][0]["channels"]; 310 result = nullptr;
323 auto plugins = m_result["list"][0]["plugins"]; 311 ctl_->send({{ "command", "rule-list" }});
324 auto events = m_result["list"][0]["events"]; 312 ctl_->recv([&] (auto, auto msg) {
325 313 result = msg;
326 ASSERT_TRUE(contains(servers, "s1")); 314 });
327 ASSERT_TRUE(contains(channels, "c1")); 315
328 ASSERT_TRUE(contains(plugins, "p1")); 316 wait_for([&] () {
329 ASSERT_TRUE(contains(events, "onMessage")); 317 return result.is_object();
330 ASSERT_EQ("accept", m_result["list"][0]["action"].get<std::string>()); 318 });
331 } 319
332 320 BOOST_TEST(result.is_object());
333 // Rule 2. 321
334 { 322 // Rule 1.
335 auto servers = m_result["list"][1]["servers"]; 323 {
336 auto channels = m_result["list"][1]["channels"]; 324 auto servers = result["list"][0]["servers"];
337 auto plugins = m_result["list"][1]["plugins"]; 325 auto channels = result["list"][0]["channels"];
338 auto events = m_result["list"][1]["events"]; 326 auto plugins = result["list"][0]["plugins"];
339 327 auto events = result["list"][0]["events"];
340 ASSERT_TRUE(contains(servers, "s2")); 328
341 ASSERT_TRUE(contains(channels, "c2")); 329 BOOST_TEST(json_util::contains(servers, "s1"));
342 ASSERT_TRUE(contains(plugins, "p2")); 330 BOOST_TEST(json_util::contains(channels, "c1"));
343 ASSERT_TRUE(contains(events, "onMessage")); 331 BOOST_TEST(json_util::contains(plugins, "p1"));
344 ASSERT_EQ("accept", m_result["list"][1]["action"].get<std::string>()); 332 BOOST_TEST(json_util::contains(events, "onMessage"));
345 } 333 BOOST_TEST(result["list"][0]["action"].get<std::string>() == "accept");
346 334 }
347 // Rule 0. 335
348 { 336 // Rule 2.
349 auto servers = m_result["list"][2]["servers"]; 337 {
350 auto channels = m_result["list"][2]["channels"]; 338 auto servers = result["list"][1]["servers"];
351 auto plugins = m_result["list"][2]["plugins"]; 339 auto channels = result["list"][1]["channels"];
352 auto events = m_result["list"][2]["events"]; 340 auto plugins = result["list"][1]["plugins"];
353 341 auto events = result["list"][1]["events"];
354 ASSERT_TRUE(contains(servers, "s0")); 342
355 ASSERT_TRUE(contains(channels, "c0")); 343 BOOST_TEST(json_util::contains(servers, "s2"));
356 ASSERT_TRUE(contains(plugins, "p0")); 344 BOOST_TEST(json_util::contains(channels, "c2"));
357 ASSERT_TRUE(contains(events, "onMessage")); 345 BOOST_TEST(json_util::contains(plugins, "p2"));
358 ASSERT_EQ("drop", m_result["list"][2]["action"].get<std::string>()); 346 BOOST_TEST(json_util::contains(events, "onMessage"));
359 } 347 BOOST_TEST(result["list"][1]["action"].get<std::string>() == "accept");
360 } catch (const std::exception& ex) { 348 }
361 FAIL() << ex.what(); 349
362 } 350 // Rule 0.
363 } 351 {
364 352 auto servers = result["list"][2]["servers"];
365 TEST_F(RuleMoveCommandTest, outOfBounds) 353 auto channels = result["list"][2]["channels"];
366 { 354 auto plugins = result["list"][2]["plugins"];
367 try { 355 auto events = result["list"][2]["events"];
368 m_irccdctl.client().request({ 356
369 { "command", "rule-move" }, 357 BOOST_TEST(json_util::contains(servers, "s0"));
370 { "from", 1024 }, 358 BOOST_TEST(json_util::contains(channels, "c0"));
371 { "to", 0 } 359 BOOST_TEST(json_util::contains(plugins, "p0"));
372 }); 360 BOOST_TEST(json_util::contains(events, "onMessage"));
373 361 BOOST_TEST(result["list"][2]["action"].get<std::string>() == "drop");
374 poll([&] () { 362 }
375 return m_result.is_object(); 363 }
376 }); 364
377 365 BOOST_AUTO_TEST_CASE(out_of_bounds)
378 ASSERT_TRUE(m_result.is_object()); 366 {
379 ASSERT_FALSE(m_result["status"].get<bool>()); 367 nlohmann::json result;
380 } catch (const std::exception& ex) { 368
381 FAIL() << ex.what(); 369 ctl_->send({
382 } 370 { "command", "rule-move" },
383 } 371 { "from", 1024 },
384 372 { "to", 0 }
385 int main(int argc, char **argv) 373 });
386 { 374 ctl_->recv([&] (auto, auto msg) {
387 testing::InitGoogleTest(&argc, argv); 375 result = msg;
388 376 });
389 return RUN_ALL_TESTS(); 377
390 } 378 wait_for([&] () {
379 return result.is_object();
380 });
381
382 // TODO: error code
383 BOOST_TEST(result.is_object());
384 BOOST_TEST(result.count("error"));
385 }
386
387 BOOST_AUTO_TEST_SUITE_END()
388
389 } // !irccd