Mercurial > irccd

comparison tests/cmd-rule-add/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-add"
20 #include <command-tester.hpp> 20 #include <boost/test/unit_test.hpp>
21 #include <service.hpp>
22 21
23 using namespace irccd; 22 #include <irccd/json_util.hpp>
24 23
25 class RuleAddCommandTest : public CommandTester { 24 #include <irccd/command.hpp>
26 protected: 25 #include <irccd/rule_service.hpp>
27 nlohmann::json m_result;
28 26
29 /* 27 #include <command_test.hpp>
30 * Rule sets are unordered so use this function to search a string in 28
31 * the JSON array. 29 namespace irccd {
32 */ 30
33 inline bool contains(const nlohmann::json &array, const std::string &str) 31 namespace {
32
33 class rule_add_test : public command_test<rule_add_command> {
34 public:
35 rule_add_test()
34 { 36 {
35 for (const auto &v : array) 37 daemon_->commands().add(std::make_unique<rule_list_command>());
36 if (v.is_string() && v == str)
37 return true;
38
39 return false;
40 }
41
42 public:
43 RuleAddCommandTest()
44 : CommandTester(std::make_unique<rule_add_command>())
45 {
46 m_irccd.commands().add(std::make_unique<rule_list_command>());
47 m_irccdctl.client().onMessage.connect([&] (auto result) {
48 m_result = result;
49 });
50 } 38 }
51 }; 39 };
52 40
53 TEST_F(RuleAddCommandTest, basic) 41 } // !namespace
42
43 BOOST_FIXTURE_TEST_SUITE(rule_add_test_suite, rule_add_test)
44
45 BOOST_AUTO_TEST_CASE(basic)
54 { 46 {
55 m_irccdctl.client().request({ 47 nlohmann::json result;
48
49 ctl_->send({
56 { "command", "rule-add" }, 50 { "command", "rule-add" },
57 { "servers", { "s1", "s2" } }, 51 { "servers", { "s1", "s2" } },
58 { "channels", { "c1", "c2" } }, 52 { "channels", { "c1", "c2" } },
59 { "plugins", { "p1", "p2" } }, 53 { "plugins", { "p1", "p2" } },
60 { "events", { "onMessage" } }, 54 { "events", { "onMessage" } },
61 { "action", "accept" }, 55 { "action", "accept" },
62 { "index", 0 } 56 { "index", 0 }
63 }); 57 });
58 ctl_->recv([&] (auto, auto msg) {
59 result = msg;
60 });
64 61
65 try { 62 wait_for([&] () {
66 poll([&] () { 63 return result.is_object();
67 return m_result.is_object(); 64 });
68 });
69 65
70 ASSERT_TRUE(m_result.is_object()); 66 BOOST_TEST(result.is_object());
71 ASSERT_TRUE(m_result["status"].get<bool>());
72 67
73 m_result = nullptr; 68 result = nullptr;
74 m_irccdctl.client().request({{ "command", "rule-list" }}); 69 ctl_->send({{"command", "rule-list"}});
70 ctl_->recv([&] (auto, auto msg) {
71 result = msg;
72 });
75 73
76 poll([&] () { 74 wait_for([&] () {
77 return m_result.is_object(); 75 return result.is_object();
78 }); 76 });
79 77
80 ASSERT_TRUE(m_result.is_object()); 78 BOOST_TEST(result.is_object());
81 ASSERT_TRUE(m_result["status"].get<bool>());
82 79
83 auto servers = m_result["list"][0]["servers"]; 80 auto servers = result["list"][0]["servers"];
84 auto channels = m_result["list"][0]["channels"]; 81 auto channels = result["list"][0]["channels"];
85 auto plugins = m_result["list"][0]["plugins"]; 82 auto plugins = result["list"][0]["plugins"];
86 auto events = m_result["list"][0]["events"]; 83 auto events = result["list"][0]["events"];
87 84
88 ASSERT_TRUE(contains(servers, "s1")); 85 BOOST_TEST(json_util::contains(servers, "s1"));
89 ASSERT_TRUE(contains(servers, "s2")); 86 BOOST_TEST(json_util::contains(servers, "s2"));
90 ASSERT_TRUE(contains(channels, "c1")); 87 BOOST_TEST(json_util::contains(channels, "c1"));
91 ASSERT_TRUE(contains(channels, "c2")); 88 BOOST_TEST(json_util::contains(channels, "c2"));
92 ASSERT_TRUE(contains(plugins, "p1")); 89 BOOST_TEST(json_util::contains(plugins, "p1"));
93 ASSERT_TRUE(contains(plugins, "p2")); 90 BOOST_TEST(json_util::contains(plugins, "p2"));
94 ASSERT_TRUE(contains(events, "onMessage")); 91 BOOST_TEST(json_util::contains(events, "onMessage"));
95 ASSERT_EQ("accept", m_result["list"][0]["action"]); 92 BOOST_TEST(result["list"][0]["action"].get<std::string>() == "accept");
96 } catch (const std::exception &ex) { 93 }
97 FAIL() << ex.what(); 94
95 BOOST_AUTO_TEST_CASE(append)
96 {
97 nlohmann::json result;
98
99 ctl_->send({
100 { "command", "rule-add" },
101 { "servers", { "s1" } },
102 { "channels", { "c1" } },
103 { "plugins", { "p1" } },
104 { "events", { "onMessage" } },
105 { "action", "accept" },
106 { "index", 0 }
107 });
108 ctl_->recv([&] (auto, auto msg) {
109 result = msg;
110 });
111
112 wait_for([&] () {
113 return result.is_object();
114 });
115
116 BOOST_TEST(result.is_object());
117
118 result = nullptr;
119 ctl_->send({
120 { "command", "rule-add" },
121 { "servers", { "s2" } },
122 { "channels", { "c2" } },
123 { "plugins", { "p2" } },
124 { "events", { "onMessage" } },
125 { "action", "drop" },
126 { "index", 1 }
127 });
128 ctl_->recv([&] (auto, auto msg) {
129 result = msg;
130 });
131
132 wait_for([&] () {
133 return result.is_object();
134 });
135
136 BOOST_TEST(result.is_object());
137
138 result = nullptr;
139 ctl_->send({{"command", "rule-list"}});
140 ctl_->recv([&] (auto, auto msg) {
141 result = msg;
142 });
143
144 wait_for([&] () {
145 return result.is_object();
146 });
147
148 BOOST_TEST(result.is_object());
149 BOOST_TEST(result["list"].size() == 2U);
150
151 // Rule 0.
152 {
153 auto servers = result["list"][0]["servers"];
154 auto channels = result["list"][0]["channels"];
155 auto plugins = result["list"][0]["plugins"];
156 auto events = result["list"][0]["events"];
157
158 BOOST_TEST(json_util::contains(servers, "s1"));
159 BOOST_TEST(json_util::contains(channels, "c1"));
160 BOOST_TEST(json_util::contains(plugins, "p1"));
161 BOOST_TEST(json_util::contains(events, "onMessage"));
162 BOOST_TEST(result["list"][0]["action"].get<std::string>() == "accept");
163 }
164
165 // Rule 1.
166 {
167 auto servers = result["list"][1]["servers"];
168 auto channels = result["list"][1]["channels"];
169 auto plugins = result["list"][1]["plugins"];
170 auto events = result["list"][1]["events"];
171
172 BOOST_TEST(json_util::contains(servers, "s2"));
173 BOOST_TEST(json_util::contains(channels, "c2"));
174 BOOST_TEST(json_util::contains(plugins, "p2"));
175 BOOST_TEST(json_util::contains(events, "onMessage"));
176 BOOST_TEST(result["list"][1]["action"].get<std::string>() == "drop");
98 } 177 }
99 } 178 }
100 179
101 TEST_F(RuleAddCommandTest, append) 180 BOOST_AUTO_TEST_SUITE_END()
102 {
103 try {
104 m_irccdctl.client().request({
105 { "command", "rule-add" },
106 { "servers", { "s1" } },
107 { "channels", { "c1" } },
108 { "plugins", { "p1" } },
109 { "events", { "onMessage" } },
110 { "action", "accept" },
111 { "index", 0 }
112 });
113 181
114 poll([&] () { 182 } // !irccd
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-add" },
124 { "servers", { "s2" } },
125 { "channels", { "c2" } },
126 { "plugins", { "p2" } },
127 { "events", { "onMessage" } },
128 { "action", "drop" },
129 { "index", 1 }
130 });
131
132 poll([&] () {
133 return m_result.is_object();
134 });
135
136 ASSERT_TRUE(m_result.is_object());
137 ASSERT_TRUE(m_result["status"].get<bool>());
138
139 m_result = nullptr;
140 m_irccdctl.client().request({{ "command", "rule-list" }});
141
142 poll([&] () {
143 return m_result.is_object();
144 });
145
146 ASSERT_TRUE(m_result.is_object());
147 ASSERT_TRUE(m_result["status"].get<bool>());
148 ASSERT_EQ(2U, m_result["list"].size());
149
150 // Rule 0.
151 {
152 auto servers = m_result["list"][0]["servers"];
153 auto channels = m_result["list"][0]["channels"];
154 auto plugins = m_result["list"][0]["plugins"];
155 auto events = m_result["list"][0]["events"];
156
157 ASSERT_TRUE(contains(servers, "s1"));
158 ASSERT_TRUE(contains(channels, "c1"));
159 ASSERT_TRUE(contains(plugins, "p1"));
160 ASSERT_TRUE(contains(events, "onMessage"));
161 ASSERT_EQ("accept", m_result["list"][0]["action"]);
162 }
163
164 // Rule 1.
165 {
166 auto servers = m_result["list"][1]["servers"];
167 auto channels = m_result["list"][1]["channels"];
168 auto plugins = m_result["list"][1]["plugins"];
169 auto events = m_result["list"][1]["events"];
170
171 ASSERT_TRUE(contains(servers, "s2"));
172 ASSERT_TRUE(contains(channels, "c2"));
173 ASSERT_TRUE(contains(plugins, "p2"));
174 ASSERT_TRUE(contains(events, "onMessage"));
175 ASSERT_EQ("drop", m_result["list"][1]["action"]);
176 }
177 } catch (const std::exception &ex) {
178 FAIL() << ex.what();
179 }
180 }
181
182 int main(int argc, char **argv)
183 {
184 testing::InitGoogleTest(&argc, argv);
185
186 return RUN_ALL_TESTS();
187 }