Merge lp:~alan-griffiths/miral/first-cut-at-test-server into lp:miral

[Alan Griffiths]

Add a TestServer fixture for writing miral tests

Add a TestServer fixture for writing miral tests

Prerequisite for writing further tests of miral

[lp:~alan-griffiths/miral/first-cut-at-test-server]

271. By Alan Griffiths on 2016-08-11

Don't report startup until after init

[Gerry Boland (gerboland)]

The mir test framework has a bunch of test servers, why is this needed? Isn't the HeadlessTestServer enough?

review: Needs Information

[Alan Griffiths (alan-griffiths)]

> The mir test framework has a bunch of test servers, why is this needed? Isn't
> the HeadlessTestServer enough?

The objective is to enable tests of the MirAL infrastructure.

A lot of the logic is similar to HeadlessTestServer, but it uses the MirAL infrastructure (MirRunner et alia) to start the server. Once we start to consolidate the MirAL work with Mir there will be opportunities to simplify.

[Gerry Boland (gerboland)]

ok, looks reasonable

review: Approve

=== modified file 'test/CMakeLists.txt'
--- test/CMakeLists.txt	2016-08-02 09:05:46 +0000
+++ test/CMakeLists.txt	2016-08-11 15:06:12 +0000
@@ -9,6 +9,7 @@
 add_executable(miral-test
     mru_window_list.cpp
     active_outputs.cpp
+    test_server.cpp         test_server.h
 )
 
 target_link_libraries(miral-test
 
=== added file 'test/test_server.cpp'
--- test/test_server.cpp	1970-01-01 00:00:00 +0000
+++ test/test_server.cpp	2016-08-11 15:06:12 +0000
@@ -0,0 +1,154 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alan Griffiths <[e-mail]>
+ */
+
+#include "test_server.h"
+
+#include <miral/canonical_window_manager.h>
+#include <miral/set_window_managment_policy.h>
+
+#include <mir_test_framework/executable_path.h>
+#include "mir_test_framework/stub_server_platform_factory.h"
+
+#include <mir/fd.h>
+#include <mir/main_loop.h>
+#include <mir/server.h>
+#include <mir/version.h>
+
+#include <boost/throw_exception.hpp>
+
+
+using namespace miral;
+using namespace testing;
+namespace mtf = mir_test_framework;
+
+namespace
+{
+std::chrono::seconds const timeout{20};
+char const* dummy_args[2] = { "TestServer", nullptr };
+}
+
+miral::TestServer::TestServer() :
+    runner{1, dummy_args}
+{
+    add_to_environment("MIR_SERVER_PLATFORM_GRAPHICS_LIB", mtf::server_platform("graphics-dummy.so").c_str());
+    add_to_environment("MIR_SERVER_PLATFORM_INPUT_LIB", mtf::server_platform("input-stub.so").c_str());
+}
+
+void miral::TestServer::SetUp()
+{
+#if MIR_SERVER_VERSION < MIR_VERSION_NUMBER(0, 25, 0)
+    mtf::set_next_preset_display({}); // Workaround for lp:1611337
+#endif
+
+    mir::test::AutoJoinThread t([this]
+         {
+            auto init = [this](mir::Server& server)
+                {
+                    server.add_init_callback([&]
+                        {
+                            auto const main_loop = server.the_main_loop();
+                            // By enqueuing the notification code in the main loop, we are
+                            // ensuring that the server has really and fully started before
+                            // leaving start_mir_server().
+                            main_loop->enqueue(this, [&]
+                                {
+                                     std::lock_guard<std::mutex> lock(mutex);
+                                     server_running = &server;
+                                     started.notify_one();
+                                });
+                        });
+                };
+
+            try
+            {
+                runner.run_with({init, set_window_managment_policy<TestWindowManagerPolicy>(*this)});
+            }
+            catch (std::exception const& e)
+            {
+                FAIL() << e.what();
+            }
+
+            std::lock_guard<std::mutex> lock(mutex);
+            server_running = nullptr;
+            started.notify_one();
+         });
+
+    std::unique_lock<std::mutex> lock(mutex);
+    started.wait_for(lock, timeout, [&] { return server_running; });
+
+    if (!server_running)
+        BOOST_THROW_EXCEPTION(std::runtime_error{"Failed to start server thread"});
+
+    server_thread = std::move(t);
+}
+
+void miral::TestServer::TearDown()
+{
+    std::unique_lock<std::mutex> lock(mutex);
+
+    if (server_running)
+        server_running->stop();
+
+    started.wait_for(lock, timeout, [&] { return !server_running; });
+
+    if (server_running)
+        BOOST_THROW_EXCEPTION(std::logic_error{"Failed to stop server"});
+
+    server_thread.stop();
+}
+
+auto miral::TestServer::connect_client(std::string name) -> toolkit::Connection
+{
+    std::lock_guard<std::mutex> lock(mutex);
+
+    if (!server_running)
+        BOOST_THROW_EXCEPTION(std::runtime_error{"Server not running"});
+
+    char connect_string[64] = {0};
+    sprintf(connect_string, "fd://%d", dup(server_running->open_client_socket()));
+
+    return toolkit::Connection{mir_connect_sync(connect_string, name.c_str())};
+}
+
+void miral::TestRuntimeEnvironment::add_to_environment(char const* key, char const* value)
+{
+    env.emplace_back(key, value);
+}
+
+struct miral::TestServer::TestWindowManagerPolicy : CanonicalWindowManagerPolicy
+{
+    TestWindowManagerPolicy(WindowManagerTools const& tools, TestServer& test_fixture) :
+        CanonicalWindowManagerPolicy{tools}
+    {
+        test_fixture.tools = tools;
+    }
+
+    bool handle_keyboard_event(MirKeyboardEvent const*) override { return false; }
+    bool handle_pointer_event(MirPointerEvent const*) override { return false; }
+    bool handle_touch_event(MirTouchEvent const*) override { return false; }
+};
+
+using miral::TestServer;
+
+// Minimal test to ensure the server runs and exits
+TEST_F(TestServer, connect_client_works)
+{
+    auto const connection = connect_client(__PRETTY_FUNCTION__);
+
+    EXPECT_TRUE(mir_connection_is_valid(connection));
+}
 
=== added file 'test/test_server.h'
--- test/test_server.h	1970-01-01 00:00:00 +0000
+++ test/test_server.h	2016-08-11 15:06:12 +0000
@@ -0,0 +1,70 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIRAL_TEST_SERVER_H
+#define MIRAL_TEST_SERVER_H
+
+#include <miral/toolkit/connection.h>
+
+#include <miral/runner.h>
+#include <miral/window_manager_tools.h>
+
+#include <mir/test/auto_unblock_thread.h>
+#include <mir_test_framework/temporary_environment_value.h>
+
+#include <gtest/gtest.h>
+
+#include <condition_variable>
+#include <list>
+#include <mutex>
+
+namespace miral
+{
+class TestRuntimeEnvironment
+{
+public:
+    void add_to_environment(char const* key, char const* value);
+
+private:
+    std::list<mir_test_framework::TemporaryEnvironmentValue> env;
+};
+
+struct TestServer : testing::Test, private TestRuntimeEnvironment
+{
+    TestServer();
+
+    void SetUp() override;
+    void TearDown() override;
+
+    auto connect_client(std::string name) -> toolkit::Connection;
+
+    using TestRuntimeEnvironment::add_to_environment;
+    WindowManagerTools tools{nullptr};
+
+private:
+    struct TestWindowManagerPolicy;
+
+    MirRunner runner;
+    mir::test::AutoJoinThread server_thread;
+    std::mutex mutex;
+    std::condition_variable started;
+    mir::Server* server_running{nullptr};
+};
+}
+
+#endif //MIRAL_TEST_SERVER_H