Merge lp:~azzar1/unity/sc_dbus_manager_tests into lp:unity

[Andrea Azzarone]

Add unit tests for unity::lockscreen::DBusManager.

Add unit tests for unity::lockscreen::DBusManager.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3782
http://jenkins.qa.ubuntu.com/job/unity-ci/878/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/414
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/410
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/412

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-ci/878/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3783
http://jenkins.qa.ubuntu.com/job/unity-ci/881/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/417
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/413
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/415

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-ci/881/rebuild

review: Approve (continuous-integration)

[Marco Trevisan (Treviño) (3v1n0)]

Lovely!

review: Approve

=== modified file 'lockscreen/ScreenSaverDBusManager.cpp'
--- lockscreen/ScreenSaverDBusManager.cpp	2014-04-10 04:47:58 +0000
+++ lockscreen/ScreenSaverDBusManager.cpp	2015-09-08 02:34:14 +0000
@@ -18,6 +18,7 @@
  */
 
 #include "ScreenSaverDBusManager.h"
+#include "ScreenSaverDBusManagerImpl.h"
 
 #include "LockScreenSettings.h"
 #include "GLibDBusProxy.h"
@@ -30,6 +31,7 @@
 namespace dbus
 {
 const std::string NAME = "org.gnome.ScreenSaver";
+const std::string TEST_NAME = "org.gnome.Test.ScreenSaver";
 const std::string INTERFACE = "org.gnome.ScreenSaver";
 const std::string OBJECT_PATH = "/org/gnome/ScreenSaver";
 const std::string INTROSPECTION_XML =
@@ -53,16 +55,22 @@
 </node>)";
 }
 
-DBusManager::DBusManager(session::Manager::Ptr const& session)
-  : active(false)
+//
+// Start Private Implementation
+//
+
+DBusManager::Impl::Impl(DBusManager* manager, session::Manager::Ptr const& session, bool test_mode)
+  : manager_(manager)
   , session_(session)
+  , test_mode_(test_mode)
   , object_(std::make_shared<glib::DBusObject>(dbus::INTROSPECTION_XML, dbus::INTERFACE))
   , time_(0)
 {
-  active.changed.connect(sigc::mem_fun(this, &DBusManager::SetActive));
+  manager_->active = false;
+  manager_->active.changed.connect(sigc::mem_fun(this, &DBusManager::Impl::SetActive));
 
   // This is a workaround we use to fallback to use gnome-screensaver if the screen reader is enabled
-  Settings::Instance().use_legacy.changed.connect(sigc::hide(sigc::mem_fun(this, &DBusManager::EnsureService)));
+  Settings::Instance().use_legacy.changed.connect(sigc::hide(sigc::mem_fun(this, &Impl::EnsureService)));
 
   object_->SetMethodsCallsHandler([this] (std::string const& method, GVariant* parameters) -> GVariant* {
     if (method == "Lock")
@@ -71,7 +79,7 @@
     }
     else if (method == "GetActive")
     {
-      return g_variant_new("(b)", active() ? TRUE : FALSE);
+      return g_variant_new("(b)", manager_->active() ? TRUE : FALSE);
     }
     else if (method == "GetActiveTime")
     {
@@ -86,7 +94,7 @@
     }
     else if (method == "SimulateUserActivity")
     {
-      simulate_activity.emit();
+      manager_->simulate_activity.emit();
     }
 
     return nullptr;
@@ -95,13 +103,14 @@
   EnsureService();
 }
 
-void DBusManager::EnsureService()
+void DBusManager::Impl::EnsureService()
 {
   if (!Settings::Instance().use_legacy())
   {
     if (!server_)
     {
-      server_ = std::make_shared<glib::DBusServer>(dbus::NAME, G_BUS_TYPE_SESSION, G_BUS_NAME_OWNER_FLAGS_REPLACE);
+      server_ = std::make_shared<glib::DBusServer>(test_mode_ ? dbus::TEST_NAME : dbus::NAME,
+                                                   G_BUS_TYPE_SESSION, G_BUS_NAME_OWNER_FLAGS_REPLACE);
       server_->AddObject(object_, dbus::OBJECT_PATH);
     }
   }
@@ -115,11 +124,26 @@
   }
 }
 
-void DBusManager::SetActive(bool active)
+void DBusManager::Impl::SetActive(bool active)
 {
   time_ = active ? time(nullptr) : 0;
   object_->EmitSignal("ActiveChanged", g_variant_new("(b)", active ? TRUE : FALSE));
 }
 
+//
+// End private implemenation
+//
+
+DBusManager::DBusManager(session::Manager::Ptr const& session)
+  : impl_(new Impl(this, session, /* test_mode */ false))
+{}
+
+DBusManager::DBusManager(session::Manager::Ptr const& session, DBusManager::TestMode const&)
+  : impl_(new Impl(this, session, /* test_mode */ true))
+{}
+
+DBusManager::~DBusManager()
+{}
+
 } // lockscreen
 } // unity

=== modified file 'lockscreen/ScreenSaverDBusManager.h'
--- lockscreen/ScreenSaverDBusManager.h	2014-04-10 04:47:58 +0000
+++ lockscreen/ScreenSaverDBusManager.h	2015-09-08 02:34:14 +0000
@@ -29,29 +29,30 @@
 namespace lockscreen
 {
 
-class DBusManager : public sigc::trackable
+class DBusManager
 {
 public:
   typedef std::shared_ptr<DBusManager> Ptr;
 
   DBusManager(session::Manager::Ptr const&);
+  ~DBusManager();
 
   nux::Property<bool> active;
 
   sigc::signal<void> simulate_activity;
 
+protected:
+  struct TestMode {};
+  DBusManager(session::Manager::Ptr const&, TestMode const&);
+
 private:
-  void SetActive(bool active);
-  void EnsureService();
-
-  session::Manager::Ptr session_;
-  glib::DBusServer::Ptr server_;
-  glib::DBusObject::Ptr object_;
-
-  time_t time_;
+  struct Impl;
+  std::unique_ptr<Impl> impl_;
+
+  friend struct TestScreenSaverDBusManager;
 };
 
-} // session
+} // lockscreen
 } // unity
 
 #endif

=== added file 'lockscreen/ScreenSaverDBusManagerImpl.h'
--- lockscreen/ScreenSaverDBusManagerImpl.h	1970-01-01 00:00:00 +0000
+++ lockscreen/ScreenSaverDBusManagerImpl.h	2015-09-08 02:34:14 +0000
@@ -0,0 +1,50 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 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: Andrea Azzarone <[e-mail]>
+*/
+
+#ifndef UNITYSHELL_SCREENSAVER_DBUS_MANAGER_IMPL_H
+#define UNITYSHELL_SCREENSAVER_DBUS_MANAGER_IMPL_H
+
+#include <UnityCore/GLibDBusServer.h>
+#include <UnityCore/SessionManager.h>
+
+namespace unity
+{
+namespace lockscreen
+{
+
+struct DBusManager::Impl : sigc::trackable
+{
+  Impl(DBusManager*, session::Manager::Ptr const& session, bool test_mode);
+
+  void SetActive(bool active);
+  void EnsureService();
+
+  DBusManager* manager_;
+  session::Manager::Ptr session_;
+  bool test_mode_;
+  glib::DBusServer::Ptr server_;
+  glib::DBusObject::Ptr object_;
+
+  time_t time_;
+};
+
+}
+}
+
+#endif

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-11-04 19:00:40 +0000
+++ tests/CMakeLists.txt	2015-09-08 02:34:14 +0000
@@ -269,6 +269,7 @@
                  test_resultviewgrid.cpp
                  test_scope_bar.cpp
                  test_scope_view.cpp
+                 test_screensaver_dbus_manager.cpp
                  test_searchbar.cpp
                  test_session_button.cpp
                  test_session_controller.cpp

=== added file 'tests/test_screensaver_dbus_manager.cpp'
--- tests/test_screensaver_dbus_manager.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_screensaver_dbus_manager.cpp	2015-09-08 02:34:14 +0000
@@ -0,0 +1,206 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 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: Andrea Azzarone <[e-mail]>
+*/
+
+#include <gtest/gtest.h>
+using namespace testing;
+
+
+#include "lockscreen/LockScreenSettings.h"
+#include "lockscreen/ScreenSaverDBusManager.h"
+#include "lockscreen/ScreenSaverDBusManagerImpl.h"
+#include "test_mock_session_manager.h"
+#include "test_utils.h"
+
+#include "GLibDBusProxy.h"
+#include "Variant.h"
+
+namespace unity
+{
+namespace lockscreen
+{
+
+struct TestScreenSaverDBusManager : Test
+{
+  TestScreenSaverDBusManager()
+    : session_manager(std::make_shared<session::MockManager>())
+    , sc_dbus_manager(std::make_shared<WrapperDBusManager>(session_manager))
+  {
+    gs_proxy = std::make_shared<glib::DBusProxy>("org.gnome.Test.ScreenSaver",
+                                                 "/org/gnome/ScreenSaver",
+                                                 "org.gnome.ScreenSaver");
+
+    Utils::WaitUntilMSec([this] { return gs_proxy->IsConnected(); });
+  }
+
+  struct WrapperDBusManager : DBusManager
+  {
+    WrapperDBusManager(session::Manager::Ptr const& session_manager)
+      : DBusManager(session_manager, DBusManager::TestMode())
+    {}
+
+    using DBusManager::impl_;
+  };
+
+  unity::lockscreen::Settings lockscreen_settings;
+  session::MockManager::Ptr session_manager;
+  WrapperDBusManager::Ptr sc_dbus_manager;
+  glib::DBusProxy::Ptr gs_proxy;
+};
+
+TEST_F(TestScreenSaverDBusManager, Contructor)
+{
+  EXPECT_FALSE(sc_dbus_manager->active());
+}
+
+TEST_F(TestScreenSaverDBusManager, ContructorLegacy)
+{
+  lockscreen_settings.use_legacy = true;
+  auto sc_dbus_manager_tmp = std::make_shared<WrapperDBusManager>(session_manager);
+
+  ASSERT_EQ(nullptr, sc_dbus_manager_tmp->impl_->server_.get());
+}
+
+TEST_F(TestScreenSaverDBusManager, ContructorNoLegacy)
+{
+  lockscreen_settings.use_legacy = false;
+  auto sc_dbus_manager_tmp = std::make_shared<WrapperDBusManager>(session_manager);
+
+  ASSERT_NE(nullptr, sc_dbus_manager_tmp->impl_->server_.get());
+}
+
+TEST_F(TestScreenSaverDBusManager, Lock)
+{
+  EXPECT_CALL(*session_manager, LockScreen())
+    .Times(1);
+
+  bool call_finished = false;
+  gs_proxy->Call("Lock", nullptr, [&call_finished](GVariant*) {
+    call_finished = true;
+  });
+
+  Utils::WaitUntil(call_finished);
+}
+
+TEST_F(TestScreenSaverDBusManager, SetActiveTrue)
+{
+  EXPECT_CALL(*session_manager, ScreenSaverActivate())
+    .Times(1);
+
+  bool call_finished = false;
+  gs_proxy->Call("SetActive", g_variant_new("(b)", TRUE), [&call_finished](GVariant*) {
+    call_finished = true;
+  });
+
+  Utils::WaitUntil(call_finished);
+}
+
+TEST_F(TestScreenSaverDBusManager, SetActiveFalse)
+{
+  EXPECT_CALL(*session_manager, ScreenSaverDeactivate())
+    .Times(1);
+
+  bool call_finished = false;
+  gs_proxy->Call("SetActive", g_variant_new("(b)", FALSE), [&call_finished](GVariant*) {
+    call_finished = true;
+  });
+
+  Utils::WaitUntil(call_finished);
+}
+
+TEST_F(TestScreenSaverDBusManager, GetActive)
+{
+  bool call_finished = false;
+  bool active = false;
+
+  auto get_active_cb = [&call_finished, &active](GVariant* value) {
+    call_finished = true;
+    active = glib::Variant(value).GetBool();
+  };
+
+  gs_proxy->Call("GetActive", nullptr, get_active_cb);
+
+  Utils::WaitUntil(call_finished);
+  ASSERT_FALSE(active);
+
+  /* simulate SetActive */
+  sc_dbus_manager->active = true;
+
+  call_finished = false;
+  gs_proxy->Call("GetActive", nullptr, get_active_cb);
+
+  Utils::WaitUntil(call_finished);
+  ASSERT_TRUE(active);
+}
+
+TEST_F(TestScreenSaverDBusManager, GetActiveTime)
+{
+  bool call_finished = false;
+  time_t active_time;
+
+  auto get_active_time_cb = [&call_finished, &active_time](GVariant* value) {
+    call_finished = true;
+    active_time = glib::Variant(value).GetUInt32();
+  };
+
+  gs_proxy->Call("GetActiveTime", nullptr, get_active_time_cb);
+
+  Utils::WaitUntil(call_finished);
+  ASSERT_EQ(0, active_time);
+
+  /* simulate SetActive */
+  sc_dbus_manager->active = true;
+
+  // GetActiveTime counts the number of seconds so we need to wait a while.
+  Utils::WaitForTimeout(2);
+
+  call_finished = false;
+  gs_proxy->Call("GetActiveTime", nullptr, get_active_time_cb);
+
+  Utils::WaitUntil(call_finished);
+  ASSERT_NE(0, active_time);
+}
+
+TEST_F(TestScreenSaverDBusManager, ActiveChanged)
+{
+  bool call_finished = false;
+  time_t active;
+
+  gs_proxy->Connect("ActiveChanged", [&call_finished, &active](GVariant* value) {
+    call_finished = true;
+    active = glib::Variant(value).GetBool();
+  });
+
+  /* simulate SetActive */
+  sc_dbus_manager->active = true;
+
+  Utils::WaitUntil(call_finished);
+  ASSERT_TRUE(active);
+
+  /* simulate SetActive */
+  call_finished = false;
+  sc_dbus_manager->active = false;
+
+  Utils::WaitUntil(call_finished);
+  ASSERT_FALSE(active);
+}
+
+
+
+}
+}