Merge lp:~alan-griffiths/mir/another-acceptance-test-uses-mir-Server-API into lp:mir

[Alan Griffiths]

test: Move another of the acceptance test suites [PromptSessionClientAPI.*] to the mir::Server based API

test: Move another of the acceptance test suites [PromptSessionClientAPI.*] to the mir::Server based API

It cleans up the "HeadlessInProcessServer" fixture from the prerequisite branch.

[lp:~alan-griffiths/mir/another-acceptance-test-uses-mir-Server-API]

2003. By Alan Griffiths on 2014-10-24

merge lp:~alan-griffiths/mir/some-acceptance-tests-use-mir-Server-API

2004. By Alan Griffiths on 2014-10-24

Revert accidental deletions in debian

2005. By Alan Griffiths on 2014-10-24

Delete debug code

2006. By Alan Griffiths on 2014-10-24

Reduce diff

2007. By Alan Griffiths on 2014-10-24

merge lp:~alan-griffiths/mir/some-acceptance-tests-use-mir-Server-API

Unmerged revisions

2007. By Alan Griffiths on 2014-10-24

merge lp:~alan-griffiths/mir/some-acceptance-tests-use-mir-Server-API

=== modified file 'include/server/mir/server.h'
--- include/server/mir/server.h	2014-10-24 18:38:24 +0000
+++ include/server/mir/server.h	2014-10-24 18:38:25 +0000
@@ -35,6 +35,7 @@
 class PlacementStrategy;
 class SessionListener;
 class PromptSessionListener;
+class PromptSessionManager;
 class SurfaceConfigurator;
 class SessionCoordinator;
 class SurfaceCoordinator;
@@ -211,6 +212,9 @@
     /// \return the prompt session listener.
     auto the_prompt_session_listener() const -> std::shared_ptr<scene::PromptSessionListener>;
 
+    /// \return the prompt session manager.
+    auto the_prompt_session_manager() const ->std::shared_ptr<scene::PromptSessionManager>;
+
     /// \return the session authorizer.
     auto the_session_authorizer() const -> std::shared_ptr<frontend::SessionAuthorizer>;
 
@@ -247,6 +251,11 @@
     /// using the format "fd://%d".
     /// \param connect_handler callback to be invoked when the client connects
     auto open_client_socket(ConnectHandler const& connect_handler) -> int;
+
+    /// Get a file descriptor that can be used to connect a prompt provider
+    /// It can be passed to another process, or used directly with mir_connect()
+    /// using the format "fd://%d".
+    auto open_prompt_socket() -> int;
 /** @} */
 private:
     void apply_settings() const;

=== modified file 'server-ABI-sha1sums'
--- server-ABI-sha1sums	2014-10-24 18:38:24 +0000
+++ server-ABI-sha1sums	2014-10-24 18:38:25 +0000
@@ -95,7 +95,7 @@
 993e9f458ffc4288d304413f3fa0b1dcc95a093d  include/server/mir/scene/surface_observer.h
 7ef3e99901168cda296d74d05a979f47bf9c3ff1  include/server/mir/server_action_queue.h
 8d83a51c278b8b71866d2178d9b6387c1f91a7d0  include/server/mir/server_configuration.h
-2ead070cf169e59015edfd94ca84295ac5adcdd6  include/server/mir/server.h
+54faba134ab52958228db3ccc19d45aff7068ca6  include/server/mir/server.h
 86098b500339bfccd07a9bed8298f75a68b18f5c  include/server/mir/server_status_listener.h
 860c04f32b60e680140148dc9dc2295de145b9c1  include/server/mir/shell/display_layout.h
 6a2107b01feae13060d5c305804906e53c52e0be  include/server/mir/shell/focus_controller.h

=== modified file 'src/server/server.cpp'
--- src/server/server.cpp	2014-10-24 18:38:24 +0000
+++ src/server/server.cpp	2014-10-24 18:38:25 +0000
@@ -61,6 +61,7 @@
     MACRO(the_session_authorizer)\
     MACRO(the_session_coordinator)\
     MACRO(the_session_listener)\
+    MACRO(the_prompt_session_manager)\
     MACRO(the_shell_display_layout)\
     MACRO(the_surface_configurator)\
     MACRO(the_surface_coordinator)
@@ -310,6 +311,14 @@
     BOOST_THROW_EXCEPTION(std::logic_error("Cannot open connection when not running"));
 }
 
+auto mir::Server::open_prompt_socket() -> int
+{
+    if (auto const config = self->server_config)
+        return config->the_prompt_connector()->client_socket_fd();
+
+    BOOST_THROW_EXCEPTION(std::logic_error("Cannot open connection when not running"));
+}
+
 auto mir::Server::open_client_socket(ConnectHandler const& connect_handler) -> int
 {
     if (auto const config = self->server_config)

=== modified file 'src/server/symbols.map'
--- src/server/symbols.map	2014-10-24 18:38:24 +0000
+++ src/server/symbols.map	2014-10-24 18:38:25 +0000
@@ -394,6 +394,7 @@
     mir::Server::exited_normally*;
     mir::Server::get_options*;
     mir::Server::open_client_socket*;
+    mir::Server::open_prompt_socket*;
     mir::Server::override_the_compositor*;
     mir::Server::override_the_cursor_listener*;
     mir::Server::override_the_gl_config*;
@@ -423,6 +424,7 @@
     mir::Server::the_graphics_platform*;
     mir::Server::the_main_loop*;
     mir::Server::the_prompt_session_listener*;
+    mir::Server::the_prompt_session_manager*;
     mir::Server::the_session_authorizer*;
     mir::Server::the_session_coordinator*;
     mir::Server::the_session_listener*;

=== modified file 'tests/acceptance-tests/test_client_library.cpp'
--- tests/acceptance-tests/test_client_library.cpp	2014-10-24 18:38:24 +0000
+++ tests/acceptance-tests/test_client_library.cpp	2014-10-24 18:38:25 +0000
@@ -19,7 +19,7 @@
 #include "mir_toolkit/mir_client_library.h"
 #include "mir_toolkit/mir_client_library_debug.h"
 
-#include "mir_test_framework/headless_test.h"
+#include "mir_test_framework/headless_in_process_server.h"
 #include "mir_test_framework/using_stub_client_platform.h"
 
 #include "src/client/client_buffer.h"
@@ -50,28 +50,9 @@
 namespace mc = mir::compositor;
 namespace mcl = mir::client;
 namespace mtf = mir_test_framework;
-
 namespace
 {
-struct HeadlessInProcessServer : mir_test_framework::HeadlessTest
-{
-    HeadlessInProcessServer()
-    {
-        add_to_environment("MIR_SERVER_NO_FILE", "");
-    }
-
-    void SetUp() override
-    {
-        start_server();
-    }
-
-    void TearDown() override
-    {
-        stop_server();
-    }
-};
-
-struct ClientLibrary : HeadlessInProcessServer
+struct ClientLibrary : mtf::HeadlessInProcessServer
 {
     mtf::UsingStubClientPlatform using_stub_client_platform;
 

=== modified file 'tests/acceptance-tests/test_prompt_session_client_api.cpp'
--- tests/acceptance-tests/test_prompt_session_client_api.cpp	2014-10-21 16:21:14 +0000
+++ tests/acceptance-tests/test_prompt_session_client_api.cpp	2014-10-24 18:38:25 +0000
@@ -21,13 +21,14 @@
 #include "mir/scene/prompt_session.h"
 #include "mir/scene/prompt_session_manager.h"
 #include "mir/scene/session.h"
+#include "mir/shell/session_coordinator_wrapper.h"
 #include "mir/frontend/session_credentials.h"
 #include "mir/frontend/shell.h"
+#include "mir/cached_ptr.h"
 #include "mir/fd.h"
 
 #include "mir_test_doubles/stub_session_authorizer.h"
-#include "mir_test_framework/stubbed_server_configuration.h"
-#include "mir_test_framework/in_process_server.h"
+#include "mir_test_framework/headless_in_process_server.h"
 #include "mir_test_framework/using_stub_client_platform.h"
 #include "mir_test/popen.h"
 
@@ -40,6 +41,7 @@
 namespace mtd = mir::test::doubles;
 namespace mtf = mir_test_framework;
 namespace ms = mir::scene;
+namespace msh = mir::shell;
 namespace mf = mir::frontend;
 
 using namespace testing;
@@ -48,20 +50,8 @@
 {
 struct MockPromptSessionListener : ms::PromptSessionListener
 {
-    MockPromptSessionListener(std::shared_ptr<ms::PromptSessionListener> const& wrapped) :
-        wrapped(wrapped)
+    MockPromptSessionListener()
     {
-        ON_CALL(*this, starting(_)).WillByDefault(Invoke(
-            wrapped.get(), &ms::PromptSessionListener::starting));
-
-        ON_CALL(*this, stopping(_)).WillByDefault(Invoke(
-            wrapped.get(), &ms::PromptSessionListener::stopping));
-
-        ON_CALL(*this, prompt_provider_added(_, _)).WillByDefault(Invoke(
-            wrapped.get(), &ms::PromptSessionListener::prompt_provider_added));
-
-        ON_CALL(*this, prompt_provider_removed(_, _)).WillByDefault(Invoke(
-            wrapped.get(), &ms::PromptSessionListener::prompt_provider_removed));
     }
 
     MOCK_METHOD1(starting, void(std::shared_ptr<ms::PromptSession> const& prompt_session));
@@ -72,8 +62,6 @@
 
     MOCK_METHOD2(prompt_provider_removed,
         void(ms::PromptSession const& session, std::shared_ptr<ms::Session> const& provider));
-
-    std::shared_ptr<ms::PromptSessionListener> const wrapped;
 };
 
 struct MockSessionAuthorizer : public mtd::StubSessionAuthorizer
@@ -88,110 +76,136 @@
     MOCK_METHOD1(prompt_session_is_allowed, bool(mf::SessionCredentials const&));
 };
 
-struct PromptSessionTestConfiguration : mtf::StubbedServerConfiguration
+// We need to fake the client_pid for the as that is used to identify sessions
+class HookSessionCoordinator : public msh::SessionCoordinatorWrapper
 {
-    std::shared_ptr<ms::PromptSessionListener> the_prompt_session_listener() override
-    {
-        return prompt_session_listener([this]()
-           ->std::shared_ptr<ms::PromptSessionListener>
-           {
-               return the_mock_prompt_session_listener();
-           });
-    }
-
-    std::shared_ptr<MockPromptSessionListener> the_mock_prompt_session_listener()
-    {
-        return mock_prompt_session_listener([this]
-            {
-                return std::make_shared<NiceMock<MockPromptSessionListener>>(
-                    mtf::StubbedServerConfiguration::the_prompt_session_listener());
-            });
-    }
-
-    std::shared_ptr<mf::SessionAuthorizer> the_session_authorizer() override
-    {
-        return session_authorizer([this]()
-           ->std::shared_ptr<mf::SessionAuthorizer>
-           {
-               return the_mock_session_authorizer();
-           });
-    }
-
-    std::shared_ptr<MockSessionAuthorizer> the_mock_session_authorizer()
-    {
-        return mock_prompt_session_authorizer([this]
-            {
-                return std::make_shared<NiceMock<MockSessionAuthorizer>>();
-            });
-    }
-
-    mir::CachedPtr<MockPromptSessionListener> mock_prompt_session_listener;
-    mir::CachedPtr<MockSessionAuthorizer> mock_prompt_session_authorizer;
+public:
+    HookSessionCoordinator(
+        std::shared_ptr<ms::SessionCoordinator> const& wrapped,
+        std::vector<pid_t> const& pids) :
+            msh::SessionCoordinatorWrapper(wrapped),
+        pids(pids)
+    {
+    }
+
+    auto open_session(
+        pid_t client_pid,
+        std::string const& name,
+        std::shared_ptr<mf::EventSink> const& sink)
+            -> std::shared_ptr<mf::Session> override
+    {
+        auto const override_pid = (next != pids.end()) ? *next++ : client_pid;
+
+        return wrapped->open_session(override_pid, name, sink);
+    }
+
+private:
+    std::vector<pid_t> const pids;
+    std::vector<pid_t>::const_iterator next{pids.begin()};
 };
 
-struct PromptSessionClientAPI : mtf::InProcessServer
+struct PromptSessionClientAPI : mtf::HeadlessInProcessServer
 {
-    PromptSessionTestConfiguration server_configuration;
-
-    mir::DefaultServerConfiguration& server_config() override
-        { return server_configuration; }
-
     MirConnection* connection = nullptr;
 
     static constexpr pid_t application_session_pid = __LINE__;
     std::shared_ptr<mf::Session> application_session;
+    MirConnection* application_connection{nullptr};
 
     std::shared_ptr<ms::PromptSession> server_prompt_session;
     mtf::UsingStubClientPlatform using_stub_client_platform;
 
+    mir::CachedPtr<MockPromptSessionListener> mock_prompt_session_listener;
+    mir::CachedPtr<MockSessionAuthorizer> mock_prompt_session_authorizer;
+
+    std::shared_ptr<MockSessionAuthorizer> the_mock_session_authorizer()
+    {
+        return mock_prompt_session_authorizer([this]
+            {
+                return std::make_shared<NiceMock<MockSessionAuthorizer>>();
+            });
+    }
+
+    std::shared_ptr<MockPromptSessionListener> the_mock_prompt_session_listener()
+    {
+        return mock_prompt_session_listener([]
+            {
+                return std::make_shared<NiceMock<MockPromptSessionListener>>();
+            });
+    }
+
+    auto new_prompt_connection() -> std::string
+    {
+        auto const prompt_fd = server.open_prompt_socket();
+        return HeadlessInProcessServer::connection(prompt_fd);
+    }
+
+    void start_application_session()
+    {
+        std::mutex application_session_mutex;
+        std::condition_variable application_session_cv;
+
+        auto connect_handler = [&](std::shared_ptr<mf::Session> const& session)
+            {
+                std::lock_guard<std::mutex> lock(application_session_mutex);
+                application_session = session;
+                application_session_cv.notify_one();
+            };
+
+        auto const fd = server.open_client_socket(connect_handler);
+
+        application_connection = mir_connect_sync(HeadlessInProcessServer::connection(fd).c_str(), __PRETTY_FUNCTION__);
+
+        std::unique_lock<std::mutex> lock(application_session_mutex);
+        application_session_cv.wait(lock, [&] { return !!application_session; });
+    }
+
     void SetUp() override
     {
-        mtf::InProcessServer::SetUp();
-
-        std::shared_ptr<mf::EventSink> dummy_event_sink;
-        auto const the_frontend_shell = server_config().the_frontend_shell();
-
-        application_session = the_frontend_shell->open_session(
-            application_session_pid, __PRETTY_FUNCTION__, dummy_event_sink);
+        auto session_coordinator_wrapper = [&](std::shared_ptr<ms::SessionCoordinator> const& wrapped)
+            -> std::shared_ptr<ms::SessionCoordinator>
+            {
+                std::vector<pid_t> fake_pids;
+                fake_pids.push_back(application_session_pid);
+
+                return std::make_shared<HookSessionCoordinator>(wrapped, fake_pids);
+            };
+
+        server.override_the_session_authorizer([this]()
+            ->std::shared_ptr<mf::SessionAuthorizer>
+            {
+                return the_mock_session_authorizer();
+            });
+
+        server.override_the_prompt_session_listener([this]
+            {
+                 return the_mock_prompt_session_listener();
+            });
+
+        server.wrap_session_coordinator(session_coordinator_wrapper);
+
+        mtf::HeadlessInProcessServer::SetUp();
+
+        start_application_session();
     }
 
     void capture_server_prompt_session()
     {
         EXPECT_CALL(*the_mock_prompt_session_listener(), starting(_)).
-            WillOnce(DoAll(
-                Invoke(
-                    the_mock_prompt_session_listener()->wrapped.get(),
-                    &ms::PromptSessionListener::starting),
-                SaveArg<0>(&server_prompt_session)));
+            WillOnce(SaveArg<0>(&server_prompt_session));
     }
 
     void TearDown() override
     {
-        // TODO It really shouldn't be necessary to close these sessions.
-        // TODO But the MediatingDisplayChanger id destroyed without deregistering
-        // TODO callbacks from the BroadcastingSessionEventSink which gets called in
-        // TODO SessionManager::~SessionManager() in code that the comments claim
-        // TODO works around broken ownership.
-        auto const the_frontend_shell = server_config().the_frontend_shell();
-        the_frontend_shell->close_session(application_session);
-
+        application_session.reset();
+        if (application_connection) mir_connection_release(application_connection);
         if (connection) mir_connection_release(connection);
-        mtf::InProcessServer::TearDown();
-    }
-
-    MockPromptSessionListener* the_mock_prompt_session_listener()
-    {
-        return server_configuration.the_mock_prompt_session_listener().get();
-    }
-
-    MockSessionAuthorizer& the_mock_session_authorizer()
-    {
-        return *server_configuration.the_mock_session_authorizer();
+        mtf::HeadlessInProcessServer::TearDown();
     }
 
     std::shared_ptr<ms::PromptSessionManager> the_prompt_session_manager()
     {
-        return server_config().the_prompt_session_manager();
+        return server.the_prompt_session_manager();
     }
 
     MOCK_METHOD2(prompt_session_state_change,
@@ -240,6 +254,8 @@
     };
 };
 
+constexpr pid_t PromptSessionClientAPI::application_session_pid;
+
 mir_prompt_session_state_change_callback const null_state_change_callback{nullptr};
 constexpr char const* const PromptSessionClientAPI::provider_name[];
 
@@ -417,7 +433,7 @@
     the_prompt_session_manager()->stop_prompt_session(server_prompt_session);
 
     // Verify we have got the "stopped" notification before we go on and release the session
-    Mock::VerifyAndClearExpectations(the_mock_prompt_session_listener());
+    Mock::VerifyAndClearExpectations(the_mock_prompt_session_listener().get());
 
     mir_prompt_session_release_sync(prompt_session);
 }
@@ -493,7 +509,7 @@
 
 TEST_F(PromptSessionClientAPI, cannot_start_a_prompt_session_without_authorization)
 {
-    EXPECT_CALL(the_mock_session_authorizer(), prompt_session_is_allowed(_))
+    EXPECT_CALL(*the_mock_session_authorizer(), prompt_session_is_allowed(_))
         .WillOnce(Return(false));
 
     connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
@@ -513,9 +529,9 @@
 TEST_F(PromptSessionClientAPI,
     can_start_a_prompt_session_without_authorization_on_prompt_connection)
 {
-    ON_CALL(the_mock_session_authorizer(), prompt_session_is_allowed(_))
+    ON_CALL(*the_mock_session_authorizer(), prompt_session_is_allowed(_))
         .WillByDefault(Return(false));
-    EXPECT_CALL(the_mock_session_authorizer(), prompt_session_is_allowed(_)).Times(0);
+    EXPECT_CALL(*the_mock_session_authorizer(), prompt_session_is_allowed(_)).Times(0);
 
     connection = mir_connect_sync(new_prompt_connection().c_str(), __PRETTY_FUNCTION__);
 
@@ -539,7 +555,7 @@
 {
     connection = mir_connect_sync(new_prompt_connection().c_str(), __PRETTY_FUNCTION__);
 
-    EXPECT_CALL(the_mock_session_authorizer(), connection_is_allowed(_)).Times(0);
+    EXPECT_CALL(*the_mock_session_authorizer(), connection_is_allowed(_)).Times(0);
 
     MirPromptSession* prompt_session = mir_connection_create_prompt_session_sync(
         connection, application_session_pid, null_state_change_callback, this);

=== added file 'tests/include/mir_test_framework/headless_in_process_server.h'
--- tests/include/mir_test_framework/headless_in_process_server.h	1970-01-01 00:00:00 +0000
+++ tests/include/mir_test_framework/headless_in_process_server.h	2014-10-24 18:38:25 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright © 2014 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 MIR_TEST_FRAMEWORK_HEADLESS_IN_PROCESS_SERVER_H_
+#define MIR_TEST_FRAMEWORK_HEADLESS_IN_PROCESS_SERVER_H_
+
+#include "mir_test_framework/headless_test.h"
+
+namespace mir_test_framework
+{
+struct HeadlessInProcessServer : HeadlessTest
+{
+    HeadlessInProcessServer();
+
+    void SetUp() override;
+
+    void TearDown() override;
+};
+}
+
+#endif /* MIR_TEST_FRAMEWORK_HEADLESS_IN_PROCESS_SERVER_H_ */

=== modified file 'tests/include/mir_test_framework/headless_test.h'
--- tests/include/mir_test_framework/headless_test.h	2014-10-24 18:38:24 +0000
+++ tests/include/mir_test_framework/headless_test.h	2014-10-24 18:38:25 +0000
@@ -54,6 +54,9 @@
     /// \return a connection string for a new client to connect to the server
     auto new_connection() -> std::string;
 
+    /// \return a connection string for a client to connect to the server
+    auto connection(int fd) -> std::string;
+
     mir::Server server;
 
 private:

=== modified file 'tests/mir_test_framework/CMakeLists.txt'
--- tests/mir_test_framework/CMakeLists.txt	2014-10-24 18:38:24 +0000
+++ tests/mir_test_framework/CMakeLists.txt	2014-10-24 18:38:25 +0000
@@ -15,6 +15,7 @@
   executable_path.cpp
   command_line_server_configuration.cpp
   cross_process_sync.cpp
+  headless_in_process_server.cpp
   headless_test.cpp
   server_runner.cpp
   temporary_environment_value.cpp

=== added file 'tests/mir_test_framework/headless_in_process_server.cpp'
--- tests/mir_test_framework/headless_in_process_server.cpp	1970-01-01 00:00:00 +0000
+++ tests/mir_test_framework/headless_in_process_server.cpp	2014-10-24 18:38:25 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright © 2014 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 "mir_test_framework/headless_in_process_server.h"
+
+namespace mtf = mir_test_framework;
+
+mtf::HeadlessInProcessServer::HeadlessInProcessServer()
+{
+    add_to_environment("MIR_SERVER_NO_FILE", "");
+}
+
+void mtf::HeadlessInProcessServer::SetUp()
+{
+    start_server();
+}
+
+void mtf::HeadlessInProcessServer::TearDown()
+{
+    stop_server();
+}

=== modified file 'tests/mir_test_framework/headless_test.cpp'
--- tests/mir_test_framework/headless_test.cpp	2014-10-24 18:38:24 +0000
+++ tests/mir_test_framework/headless_test.cpp	2014-10-24 18:38:25 +0000
@@ -103,7 +103,12 @@
 
 auto mtf::HeadlessTest::new_connection() -> std::string
 {
+    return connection(server.open_client_socket());
+}
+
+auto mtf::HeadlessTest::connection(int fd) -> std::string
+{
     char connect_string[64] = {0};
-    sprintf(connect_string, "fd://%d", server.open_client_socket());
+    sprintf(connect_string, "fd://%d", fd);
     return connect_string;
 }