--- a/tests/cmd-rule-move/main.cpp	Fri Nov 24 21:20:17 2017 +0100
+++ b/tests/cmd-rule-move/main.cpp	Sat Nov 25 14:34:20 2017 +0100
@@ -16,35 +16,26 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <command.hpp>
-#include <command-tester.hpp>
-#include <service.hpp>
+#define BOOST_TEST_MODULE "rule-move"
+#include <boost/test/unit_test.hpp>
+
+#include <irccd/json_util.hpp>
 
-using namespace irccd;
+#include <irccd/command.hpp>
+#include <irccd/rule_service.hpp>
 
-class RuleMoveCommandTest : public CommandTester {
-protected:
-    nlohmann::json m_result;
+#include <command_test.hpp>
 
-    /*
-     * Rule sets are unordered so use this function to search a string in
-     * the JSON array.
-     */
-    inline bool contains(const nlohmann::json &array, const std::string &str)
-    {
-        for (const auto &v : array)
-            if (v.is_string() && v == str)
-                return true;
+namespace irccd {
+
+namespace {
 
-        return false;
-    }
-
+class rule_move_test : public command_test<rule_move_command> {
 public:
-    RuleMoveCommandTest()
-        : CommandTester(std::make_unique<rule_move_command>())
+    rule_move_test()
     {
-        m_irccd.commands().add(std::make_unique<rule_list_command>());
-        m_irccd.rules().add(rule(
+        daemon_->commands().add(std::make_unique<rule_list_command>());
+        daemon_->rules().add(rule(
             { "s0" },
             { "c0" },
             { "o0" },
@@ -52,7 +43,7 @@
             { "onMessage" },
             rule::action_type::drop
         ));
-        m_irccd.rules().add(rule(
+        daemon_->rules().add(rule(
             { "s1", },
             { "c1", },
             { "o1", },
@@ -60,7 +51,7 @@
             { "onMessage", },
             rule::action_type::accept
         ));
-        m_irccd.rules().add(rule(
+        daemon_->rules().add(rule(
             { "s2", },
             { "c2", },
             { "o2", },
@@ -68,323 +59,331 @@
             { "onMessage", },
             rule::action_type::accept
         ));
-        m_irccdctl.client().onMessage.connect([&] (auto result) {
-            m_result = result;
-        });
     }
 };
 
-TEST_F(RuleMoveCommandTest, backward)
+} // !namespace
+
+BOOST_FIXTURE_TEST_SUITE(rule_move_test_suite, rule_move_test)
+
+BOOST_AUTO_TEST_CASE(backward)
 {
-    try {
-        m_irccdctl.client().request({
-            { "command",    "rule-move" },
-            { "from",       2           },
-            { "to",         0           }
-        });
+    nlohmann::json result;
 
-        poll([&] () {
-            return m_result.is_object();
-        });
-
-        ASSERT_TRUE(m_result.is_object());
-        ASSERT_TRUE(m_result["status"].get<bool>());
+    ctl_->send({
+        { "command",    "rule-move" },
+        { "from",       2           },
+        { "to",         0           }
+    });
+    ctl_->recv([&] (auto, auto msg) {
+        result = msg;
+    });
 
-        m_result = nullptr;
-        m_irccdctl.client().request({{ "command", "rule-list" }});
+    wait_for([&] () {
+        return result.is_object();
+    });
 
-        poll([&] () {
-            return m_result.is_object();
-        });
+    BOOST_TEST(result.is_object());
 
-        ASSERT_TRUE(m_result.is_object());
-        ASSERT_TRUE(m_result["status"].get<bool>());
+    result = nullptr;
+    ctl_->send({{ "command", "rule-list" }});
+    ctl_->recv([&] (auto, auto msg) {
+        result = msg;
+    });
 
-        // Rule 2.
-        {
-            auto servers = m_result["list"][0]["servers"];
-            auto channels = m_result["list"][0]["channels"];
-            auto plugins = m_result["list"][0]["plugins"];
-            auto events = m_result["list"][0]["events"];
+    wait_for([&] () {
+        return result.is_object();
+    });
+
+    BOOST_TEST(result.is_object());
 
-            ASSERT_TRUE(contains(servers, "s2"));
-            ASSERT_TRUE(contains(channels, "c2"));
-            ASSERT_TRUE(contains(plugins, "p2"));
-            ASSERT_TRUE(contains(events, "onMessage"));
-            ASSERT_EQ("accept", m_result["list"][0]["action"].get<std::string>());
-        }
+    // Rule 2.
+    {
+        auto servers = result["list"][0]["servers"];
+        auto channels = result["list"][0]["channels"];
+        auto plugins = result["list"][0]["plugins"];
+        auto events = result["list"][0]["events"];
 
-        // Rule 0.
-        {
-            auto servers = m_result["list"][1]["servers"];
-            auto channels = m_result["list"][1]["channels"];
-            auto plugins = m_result["list"][1]["plugins"];
-            auto events = m_result["list"][1]["events"];
+        BOOST_TEST(json_util::contains(servers, "s2"));
+        BOOST_TEST(json_util::contains(channels, "c2"));
+        BOOST_TEST(json_util::contains(plugins, "p2"));
+        BOOST_TEST(json_util::contains(events, "onMessage"));
+        BOOST_TEST(result["list"][0]["action"].get<std::string>() == "accept");
+    }
 
-            ASSERT_TRUE(contains(servers, "s0"));
-            ASSERT_TRUE(contains(channels, "c0"));
-            ASSERT_TRUE(contains(plugins, "p0"));
-            ASSERT_TRUE(contains(events, "onMessage"));
-            ASSERT_EQ("drop", m_result["list"][1]["action"].get<std::string>());
-        }
+    // Rule 0.
+    {
+        auto servers = result["list"][1]["servers"];
+        auto channels = result["list"][1]["channels"];
+        auto plugins = result["list"][1]["plugins"];
+        auto events = result["list"][1]["events"];
 
-        // Rule 1.
-        {
-            auto servers = m_result["list"][2]["servers"];
-            auto channels = m_result["list"][2]["channels"];
-            auto plugins = m_result["list"][2]["plugins"];
-            auto events = m_result["list"][2]["events"];
+        BOOST_TEST(json_util::contains(servers, "s0"));
+        BOOST_TEST(json_util::contains(channels, "c0"));
+        BOOST_TEST(json_util::contains(plugins, "p0"));
+        BOOST_TEST(json_util::contains(events, "onMessage"));
+        BOOST_TEST(result["list"][1]["action"].get<std::string>() == "drop");
+    }
 
-            ASSERT_TRUE(contains(servers, "s1"));
-            ASSERT_TRUE(contains(channels, "c1"));
-            ASSERT_TRUE(contains(plugins, "p1"));
-            ASSERT_TRUE(contains(events, "onMessage"));
-            ASSERT_EQ("accept", m_result["list"][2]["action"].get<std::string>());
-        }
-    } catch (const std::exception& ex) {
-        FAIL() << ex.what();
+    // Rule 1.
+    {
+        auto servers = result["list"][2]["servers"];
+        auto channels = result["list"][2]["channels"];
+        auto plugins = result["list"][2]["plugins"];
+        auto events = result["list"][2]["events"];
+
+        BOOST_TEST(json_util::contains(servers, "s1"));
+        BOOST_TEST(json_util::contains(channels, "c1"));
+        BOOST_TEST(json_util::contains(plugins, "p1"));
+        BOOST_TEST(json_util::contains(events, "onMessage"));
+        BOOST_TEST(result["list"][2]["action"].get<std::string>() == "accept");
     }
 }
 
-TEST_F(RuleMoveCommandTest, upward)
+BOOST_AUTO_TEST_CASE(upward)
 {
-    try {
-        m_irccdctl.client().request({
-            { "command",    "rule-move" },
-            { "from",       0           },
-            { "to",         2           }
-        });
+    nlohmann::json result;
 
-        poll([&] () {
-            return m_result.is_object();
-        });
-
-        ASSERT_TRUE(m_result.is_object());
-        ASSERT_TRUE(m_result["status"].get<bool>());
+    ctl_->send({
+        { "command",    "rule-move" },
+        { "from",       0           },
+        { "to",         2           }
+    });
+    ctl_->recv([&] (auto, auto msg) {
+        result = msg;
+    });
 
-        m_result = nullptr;
-        m_irccdctl.client().request({{ "command", "rule-list" }});
+    wait_for([&] () {
+        return result.is_object();
+    });
 
-        poll([&] () {
-            return m_result.is_object();
-        });
+    BOOST_TEST(result.is_object());
 
-        ASSERT_TRUE(m_result.is_object());
-        ASSERT_TRUE(m_result["status"].get<bool>());
+    result = nullptr;
+    ctl_->send({{ "command", "rule-list" }});
+    ctl_->recv([&] (auto, auto msg) {
+        result = msg;
+    });
 
-        // Rule 1.
-        {
-            auto servers = m_result["list"][0]["servers"];
-            auto channels = m_result["list"][0]["channels"];
-            auto plugins = m_result["list"][0]["plugins"];
-            auto events = m_result["list"][0]["events"];
+    wait_for([&] () {
+        return result.is_object();
+    });
+
+    BOOST_TEST(result.is_object());
 
-            ASSERT_TRUE(contains(servers, "s1"));
-            ASSERT_TRUE(contains(channels, "c1"));
-            ASSERT_TRUE(contains(plugins, "p1"));
-            ASSERT_TRUE(contains(events, "onMessage"));
-            ASSERT_EQ("accept", m_result["list"][0]["action"].get<std::string>());
-        }
+    // Rule 1.
+    {
+        auto servers = result["list"][0]["servers"];
+        auto channels = result["list"][0]["channels"];
+        auto plugins = result["list"][0]["plugins"];
+        auto events = result["list"][0]["events"];
 
-        // Rule 2.
-        {
-            auto servers = m_result["list"][1]["servers"];
-            auto channels = m_result["list"][1]["channels"];
-            auto plugins = m_result["list"][1]["plugins"];
-            auto events = m_result["list"][1]["events"];
+        BOOST_TEST(json_util::contains(servers, "s1"));
+        BOOST_TEST(json_util::contains(channels, "c1"));
+        BOOST_TEST(json_util::contains(plugins, "p1"));
+        BOOST_TEST(json_util::contains(events, "onMessage"));
+        BOOST_TEST(result["list"][0]["action"].get<std::string>() == "accept");
+    }
 
-            ASSERT_TRUE(contains(servers, "s2"));
-            ASSERT_TRUE(contains(channels, "c2"));
-            ASSERT_TRUE(contains(plugins, "p2"));
-            ASSERT_TRUE(contains(events, "onMessage"));
-            ASSERT_EQ("accept", m_result["list"][1]["action"].get<std::string>());
-        }
+    // Rule 2.
+    {
+        auto servers = result["list"][1]["servers"];
+        auto channels = result["list"][1]["channels"];
+        auto plugins = result["list"][1]["plugins"];
+        auto events = result["list"][1]["events"];
 
-        // Rule 0.
-        {
-            auto servers = m_result["list"][2]["servers"];
-            auto channels = m_result["list"][2]["channels"];
-            auto plugins = m_result["list"][2]["plugins"];
-            auto events = m_result["list"][2]["events"];
+        BOOST_TEST(json_util::contains(servers, "s2"));
+        BOOST_TEST(json_util::contains(channels, "c2"));
+        BOOST_TEST(json_util::contains(plugins, "p2"));
+        BOOST_TEST(json_util::contains(events, "onMessage"));
+        BOOST_TEST(result["list"][1]["action"].get<std::string>() == "accept");
+    }
 
-            ASSERT_TRUE(contains(servers, "s0"));
-            ASSERT_TRUE(contains(channels, "c0"));
-            ASSERT_TRUE(contains(plugins, "p0"));
-            ASSERT_TRUE(contains(events, "onMessage"));
-            ASSERT_EQ("drop", m_result["list"][2]["action"].get<std::string>());
-        }
-    } catch (const std::exception& ex) {
-        FAIL() << ex.what();
+    // Rule 0.
+    {
+        auto servers = result["list"][2]["servers"];
+        auto channels = result["list"][2]["channels"];
+        auto plugins = result["list"][2]["plugins"];
+        auto events = result["list"][2]["events"];
+
+        BOOST_TEST(json_util::contains(servers, "s0"));
+        BOOST_TEST(json_util::contains(channels, "c0"));
+        BOOST_TEST(json_util::contains(plugins, "p0"));
+        BOOST_TEST(json_util::contains(events, "onMessage"));
+        BOOST_TEST(result["list"][2]["action"].get<std::string>() == "drop");
     }
 }
 
-TEST_F(RuleMoveCommandTest, same)
+BOOST_AUTO_TEST_CASE(same)
 {
-    try {
-        m_irccdctl.client().request({
-            { "command",    "rule-move" },
-            { "from",       1           },
-            { "to",         1           }
-        });
+    nlohmann::json result;
 
-        poll([&] () {
-            return m_result.is_object();
-        });
-
-        ASSERT_TRUE(m_result.is_object());
-        ASSERT_TRUE(m_result["status"].get<bool>());
+    ctl_->send({
+        { "command",    "rule-move" },
+        { "from",       1           },
+        { "to",         1           }
+    });
+    ctl_->recv([&] (auto, auto msg) {
+        result = msg;
+    });
 
-        m_result = nullptr;
-        m_irccdctl.client().request({{ "command", "rule-list" }});
+    wait_for([&] () {
+        return result.is_object();
+    });
 
-        poll([&] () {
-            return m_result.is_object();
-        });
+    BOOST_TEST(result.is_object());
 
-        ASSERT_TRUE(m_result.is_object());
-        ASSERT_TRUE(m_result["status"].get<bool>());
+    result = nullptr;
+    ctl_->send({{ "command", "rule-list" }});
+    ctl_->recv([&] (auto, auto msg) {
+        result = msg;
+    });
 
-        // Rule 0.
-        {
-            auto servers = m_result["list"][0]["servers"];
-            auto channels = m_result["list"][0]["channels"];
-            auto plugins = m_result["list"][0]["plugins"];
-            auto events = m_result["list"][0]["events"];
+    wait_for([&] () {
+        return result.is_object();
+    });
+
+    BOOST_TEST(result.is_object());
 
-            ASSERT_TRUE(contains(servers, "s0"));
-            ASSERT_TRUE(contains(channels, "c0"));
-            ASSERT_TRUE(contains(plugins, "p0"));
-            ASSERT_TRUE(contains(events, "onMessage"));
-            ASSERT_EQ("drop", m_result["list"][0]["action"].get<std::string>());
-        }
+    // Rule 0.
+    {
+        auto servers = result["list"][0]["servers"];
+        auto channels = result["list"][0]["channels"];
+        auto plugins = result["list"][0]["plugins"];
+        auto events = result["list"][0]["events"];
 
-        // Rule 1.
-        {
-            auto servers = m_result["list"][1]["servers"];
-            auto channels = m_result["list"][1]["channels"];
-            auto plugins = m_result["list"][1]["plugins"];
-            auto events = m_result["list"][1]["events"];
+        BOOST_TEST(json_util::contains(servers, "s0"));
+        BOOST_TEST(json_util::contains(channels, "c0"));
+        BOOST_TEST(json_util::contains(plugins, "p0"));
+        BOOST_TEST(json_util::contains(events, "onMessage"));
+        BOOST_TEST(result["list"][0]["action"].get<std::string>() == "drop");
+    }
 
-            ASSERT_TRUE(contains(servers, "s1"));
-            ASSERT_TRUE(contains(channels, "c1"));
-            ASSERT_TRUE(contains(plugins, "p1"));
-            ASSERT_TRUE(contains(events, "onMessage"));
-            ASSERT_EQ("accept", m_result["list"][1]["action"].get<std::string>());
-        }
+    // Rule 1.
+    {
+        auto servers = result["list"][1]["servers"];
+        auto channels = result["list"][1]["channels"];
+        auto plugins = result["list"][1]["plugins"];
+        auto events = result["list"][1]["events"];
 
-        // Rule 2.
-        {
-            auto servers = m_result["list"][2]["servers"];
-            auto channels = m_result["list"][2]["channels"];
-            auto plugins = m_result["list"][2]["plugins"];
-            auto events = m_result["list"][2]["events"];
+        BOOST_TEST(json_util::contains(servers, "s1"));
+        BOOST_TEST(json_util::contains(channels, "c1"));
+        BOOST_TEST(json_util::contains(plugins, "p1"));
+        BOOST_TEST(json_util::contains(events, "onMessage"));
+        BOOST_TEST(result["list"][1]["action"].get<std::string>() == "accept");
+    }
 
-            ASSERT_TRUE(contains(servers, "s2"));
-            ASSERT_TRUE(contains(channels, "c2"));
-            ASSERT_TRUE(contains(plugins, "p2"));
-            ASSERT_TRUE(contains(events, "onMessage"));
-            ASSERT_EQ("accept", m_result["list"][2]["action"].get<std::string>());
-        }
-    } catch (const std::exception& ex) {
-        FAIL() << ex.what();
+    // Rule 2.
+    {
+        auto servers = result["list"][2]["servers"];
+        auto channels = result["list"][2]["channels"];
+        auto plugins = result["list"][2]["plugins"];
+        auto events = result["list"][2]["events"];
+
+        BOOST_TEST(json_util::contains(servers, "s2"));
+        BOOST_TEST(json_util::contains(channels, "c2"));
+        BOOST_TEST(json_util::contains(plugins, "p2"));
+        BOOST_TEST(json_util::contains(events, "onMessage"));
+        BOOST_TEST(result["list"][2]["action"].get<std::string>() == "accept");
     }
 }
 
-TEST_F(RuleMoveCommandTest, beyond)
+BOOST_AUTO_TEST_CASE(beyond)
 {
-    try {
-        m_irccdctl.client().request({
-            { "command",    "rule-move" },
-            { "from",       0           },
-            { "to",         123         }
-        });
+    nlohmann::json result;
 
-        poll([&] () {
-            return m_result.is_object();
-        });
-
-        ASSERT_TRUE(m_result.is_object());
-        ASSERT_TRUE(m_result["status"].get<bool>());
+    ctl_->send({
+        { "command",    "rule-move" },
+        { "from",       0           },
+        { "to",         123         }
+    });
+    ctl_->recv([&] (auto, auto msg) {
+        result = msg;
+    });
 
-        m_result = nullptr;
-        m_irccdctl.client().request({{ "command", "rule-list" }});
+    wait_for([&] () {
+        return result.is_object();
+    });
 
-        poll([&] () {
-            return m_result.is_object();
-        });
+    BOOST_TEST(result.is_object());
 
-        ASSERT_TRUE(m_result.is_object());
-        ASSERT_TRUE(m_result["status"].get<bool>());
+    result = nullptr;
+    ctl_->send({{ "command", "rule-list" }});
+    ctl_->recv([&] (auto, auto msg) {
+        result = msg;
+    });
 
-        // Rule 1.
-        {
-            auto servers = m_result["list"][0]["servers"];
-            auto channels = m_result["list"][0]["channels"];
-            auto plugins = m_result["list"][0]["plugins"];
-            auto events = m_result["list"][0]["events"];
+    wait_for([&] () {
+        return result.is_object();
+    });
+
+    BOOST_TEST(result.is_object());
 
-            ASSERT_TRUE(contains(servers, "s1"));
-            ASSERT_TRUE(contains(channels, "c1"));
-            ASSERT_TRUE(contains(plugins, "p1"));
-            ASSERT_TRUE(contains(events, "onMessage"));
-            ASSERT_EQ("accept", m_result["list"][0]["action"].get<std::string>());
-        }
+    // Rule 1.
+    {
+        auto servers = result["list"][0]["servers"];
+        auto channels = result["list"][0]["channels"];
+        auto plugins = result["list"][0]["plugins"];
+        auto events = result["list"][0]["events"];
 
-        // Rule 2.
-        {
-            auto servers = m_result["list"][1]["servers"];
-            auto channels = m_result["list"][1]["channels"];
-            auto plugins = m_result["list"][1]["plugins"];
-            auto events = m_result["list"][1]["events"];
+        BOOST_TEST(json_util::contains(servers, "s1"));
+        BOOST_TEST(json_util::contains(channels, "c1"));
+        BOOST_TEST(json_util::contains(plugins, "p1"));
+        BOOST_TEST(json_util::contains(events, "onMessage"));
+        BOOST_TEST(result["list"][0]["action"].get<std::string>() == "accept");
+    }
 
-            ASSERT_TRUE(contains(servers, "s2"));
-            ASSERT_TRUE(contains(channels, "c2"));
-            ASSERT_TRUE(contains(plugins, "p2"));
-            ASSERT_TRUE(contains(events, "onMessage"));
-            ASSERT_EQ("accept", m_result["list"][1]["action"].get<std::string>());
-        }
+    // Rule 2.
+    {
+        auto servers = result["list"][1]["servers"];
+        auto channels = result["list"][1]["channels"];
+        auto plugins = result["list"][1]["plugins"];
+        auto events = result["list"][1]["events"];
 
-        // Rule 0.
-        {
-            auto servers = m_result["list"][2]["servers"];
-            auto channels = m_result["list"][2]["channels"];
-            auto plugins = m_result["list"][2]["plugins"];
-            auto events = m_result["list"][2]["events"];
+        BOOST_TEST(json_util::contains(servers, "s2"));
+        BOOST_TEST(json_util::contains(channels, "c2"));
+        BOOST_TEST(json_util::contains(plugins, "p2"));
+        BOOST_TEST(json_util::contains(events, "onMessage"));
+        BOOST_TEST(result["list"][1]["action"].get<std::string>() == "accept");
+    }
 
-            ASSERT_TRUE(contains(servers, "s0"));
-            ASSERT_TRUE(contains(channels, "c0"));
-            ASSERT_TRUE(contains(plugins, "p0"));
-            ASSERT_TRUE(contains(events, "onMessage"));
-            ASSERT_EQ("drop", m_result["list"][2]["action"].get<std::string>());
-        }
-    } catch (const std::exception& ex) {
-        FAIL() << ex.what();
+    // Rule 0.
+    {
+        auto servers = result["list"][2]["servers"];
+        auto channels = result["list"][2]["channels"];
+        auto plugins = result["list"][2]["plugins"];
+        auto events = result["list"][2]["events"];
+
+        BOOST_TEST(json_util::contains(servers, "s0"));
+        BOOST_TEST(json_util::contains(channels, "c0"));
+        BOOST_TEST(json_util::contains(plugins, "p0"));
+        BOOST_TEST(json_util::contains(events, "onMessage"));
+        BOOST_TEST(result["list"][2]["action"].get<std::string>() == "drop");
     }
 }
 
-TEST_F(RuleMoveCommandTest, outOfBounds)
+BOOST_AUTO_TEST_CASE(out_of_bounds)
 {
-    try {
-        m_irccdctl.client().request({
-            { "command",    "rule-move" },
-            { "from",       1024        },
-            { "to",         0           }
-        });
+    nlohmann::json result;
 
-        poll([&] () {
-            return m_result.is_object();
-        });
+    ctl_->send({
+        { "command",    "rule-move" },
+        { "from",       1024        },
+        { "to",         0           }
+    });
+    ctl_->recv([&] (auto, auto msg) {
+        result = msg;
+    });
 
-        ASSERT_TRUE(m_result.is_object());
-        ASSERT_FALSE(m_result["status"].get<bool>());
-    } catch (const std::exception& ex) {
-        FAIL() << ex.what();
-    }
+    wait_for([&] () {
+        return result.is_object();
+    });
+
+    // TODO: error code
+    BOOST_TEST(result.is_object());
+    BOOST_TEST(result.count("error"));
 }
 
-int main(int argc, char **argv)
-{
-    testing::InitGoogleTest(&argc, argv);
+BOOST_AUTO_TEST_SUITE_END()
 
-    return RUN_ALL_TESTS();
-}
+} // !irccd