← Back to branch summary

~ci-train-bot/unity/unity-ubuntu-yakkety-2192

« back to all changes in this revision

Viewing changes to tests/test_gnome_session_manager.cpp

  • Committer: CI bot
  • Author(s): Andrea Azzarone
  • Date: 2014-03-11 18:36:57 UTC
  • mfrom: (3566.5.457 unity)
  • Revision ID: ps-jenkins@lists.canonical.com-20140311183657-b3haqqvvr2ctp9u9
Implement the lockscreen in Unity that looks like unity-greeter. Also allow to fallback to lightdm + greeter (tty switching) in case you need more pam power. Fixes: 878836, 1266464, 1282798

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_gnome_session_manager.cpp
37
37
const std::string SHELL_OBJECT_PATH = "/org/gnome/SessionManager/EndSessionDialog";
38
38
 
39
39
const std::string UPOWER_PATH = "/org/freedesktop/UPower";
40
 
const std::string LOGIND_PATH = "/org/freedesktop/login1";
 
40
const std::string LOGIND_MANAGER_PATH = "/org/freedesktop/login1";
 
41
const std::string LOGIND_SESSION_PATH = "/org/freedesktop/login1/session/id0";
41
42
const std::string CONSOLE_KIT_PATH = "/org/freedesktop/ConsoleKit/Manager";
42
 
const std::string SCREEN_SAVER_PATH = "/org/gnome/ScreenSaver";
43
43
const std::string SESSION_MANAGER_PATH = "/org/gnome/SessionManager";
44
44
 
45
45
const std::string SESSION_OPTIONS = "com.canonical.indicator.session";
62
62
  </interface>
63
63
</node>)";
64
64
 
65
 
const std::string LOGIND =
 
65
const std::string LOGIND_MANAGER =
66
66
R"(<node>
67
67
  <interface name="org.freedesktop.login1.Manager">
68
68
    <method name="CanSuspend">
89
89
  </interface>
90
90
</node>)";
91
91
 
 
92
const std::string LOGIND_SESSION =
 
93
R"(<node>
 
94
  <interface name="org.freedesktop.login1.Session">
 
95
    <signal name="Lock" />
 
96
    <signal name="Unlock" />
 
97
  </interface>
 
98
</node>)";
 
99
 
92
100
const std::string CONSOLE_KIT =
93
101
R"(<node>
94
102
  <interface name="org.freedesktop.ConsoleKit.Manager">
100
108
  </interface>
101
109
</node>)";
102
110
 
103
 
const std::string SCREEN_SAVER =
104
 
R"(<node>
105
 
  <interface name="org.gnome.ScreenSaver">
106
 
    <method name="Lock"/>
107
 
    <method name="SimulateUserActivity"/>
108
 
  </interface>
109
 
</node>)";
110
 
 
111
111
const std::string SESSION_MANAGER =
112
112
R"(<node>
113
113
  <interface name="org.gnome.SessionManager">
162
162
    });
163
163
 
164
164
    logind_ = std::make_shared<DBusServer>();
165
 
    logind_->AddObjects(introspection::LOGIND, LOGIND_PATH);
 
165
    logind_->AddObjects(introspection::LOGIND_MANAGER, LOGIND_MANAGER_PATH);
 
166
    logind_->AddObjects(introspection::LOGIND_SESSION, LOGIND_SESSION_PATH);
166
167
    logind_->GetObjects().front()->SetMethodsCallsHandler([&] (std::string const& method, GVariant*) -> GVariant* {
167
168
      if (method == "CanSuspend")
168
169
      {
181
182
    console_kit_ = std::make_shared<DBusServer>();
182
183
    console_kit_->AddObjects(introspection::CONSOLE_KIT, CONSOLE_KIT_PATH);
183
184
 
184
 
    screen_saver_ = std::make_shared<DBusServer>();
185
 
    screen_saver_->AddObjects(introspection::SCREEN_SAVER, SCREEN_SAVER_PATH);
186
 
 
187
185
    session_manager_ = std::make_shared<DBusServer>();
188
186
    session_manager_->AddObjects(introspection::SESSION_MANAGER, SESSION_MANAGER_PATH);
189
187
    session_manager_->GetObjects().front()->SetMethodsCallsHandler([&] (std::string const& method, GVariant*) -> GVariant* {
215
213
    Utils::WaitUntilMSec([] { return upower_->IsConnected(); });
216
214
    Utils::WaitUntilMSec([] { return logind_->IsConnected(); });
217
215
    Utils::WaitUntilMSec([] { return console_kit_->IsConnected(); });
218
 
    Utils::WaitUntilMSec([] { return screen_saver_->IsConnected(); });
219
216
    Utils::WaitUntilMSec([] { return session_manager_->IsConnected(); });
220
217
    Utils::WaitUntilMSec([] { return shell_proxy_->IsConnected();});
221
218
    ASSERT_TRUE(shell_proxy_->IsConnected());
267
264
    upower_.reset();
268
265
    logind_.reset();
269
266
    console_kit_.reset();
270
 
    screen_saver_.reset();
271
267
    session_manager_.reset();
272
268
  }
273
269
 
327
323
  static DBusServer::Ptr upower_;
328
324
  static DBusServer::Ptr console_kit_;
329
325
  static DBusServer::Ptr logind_;
330
 
  static DBusServer::Ptr screen_saver_;
331
326
  static DBusServer::Ptr session_manager_;
332
327
  static DBusProxy::Ptr shell_proxy_;
333
328
};
336
331
DBusServer::Ptr TestGnomeSessionManager::upower_;
337
332
DBusServer::Ptr TestGnomeSessionManager::console_kit_;
338
333
DBusServer::Ptr TestGnomeSessionManager::logind_;
339
 
DBusServer::Ptr TestGnomeSessionManager::screen_saver_;
340
334
DBusServer::Ptr TestGnomeSessionManager::session_manager_;
341
335
DBusProxy::Ptr TestGnomeSessionManager::shell_proxy_;
342
336
bool TestGnomeSessionManager::can_shutdown_;
375
369
 
376
370
TEST_F(TestGnomeSessionManager, LockScreen)
377
371
{
378
 
  bool lock_called = false;
379
 
  bool simulate_activity_called = false;
380
 
 
381
 
  screen_saver_->GetObjects().front()->SetMethodsCallsHandler([&] (std::string const& method, GVariant*) -> GVariant* {
382
 
    if (method == "Lock")
383
 
    {
384
 
      lock_called = true;
385
 
      EXPECT_FALSE(simulate_activity_called);
386
 
    }
387
 
    else if (method == "SimulateUserActivity")
388
 
    {
389
 
      simulate_activity_called = true;
390
 
      EXPECT_TRUE(lock_called);
391
 
    }
392
 
 
393
 
    return nullptr;
 
372
  bool lock_emitted = false;
 
373
 
 
374
  manager->lock_requested.connect([&lock_emitted]()
 
375
  {
 
376
    lock_emitted = true;
394
377
  });
395
378
 
396
379
  manager->LockScreen();
397
380
 
398
 
  Utils::WaitUntilMSec(lock_called);
399
 
  EXPECT_TRUE(lock_called);
400
 
 
401
 
  Utils::WaitUntilMSec(simulate_activity_called);
402
 
  EXPECT_TRUE(simulate_activity_called);
 
381
  Utils::WaitUntilMSec(lock_emitted);
 
382
  EXPECT_TRUE(lock_emitted);
403
383
}
404
384
 
405
385
TEST_F(TestGnomeSessionManager, Logout)
1004
984
  EXPECT_TRUE(closed);
1005
985
}
1006
986
 
 
987
TEST_F(TestGnomeSessionManager, DISABLED_LogindLock)
 
988
{
 
989
  bool lock_emitted = false;
 
990
 
 
991
  manager->lock_requested.connect([&lock_emitted]()
 
992
  {
 
993
    lock_emitted = true;
 
994
  });
 
995
 
 
996
  logind_->GetObject("org.freedesktop.login1.Session")->EmitSignal("Lock");
 
997
 
 
998
  Utils::WaitUntilMSec(lock_emitted);
 
999
  EXPECT_TRUE(lock_emitted);
 
1000
}
 
1001
 
 
1002
TEST_F(TestGnomeSessionManager, LogindUnLock)
 
1003
{
 
1004
  bool unlock_emitted = false;
 
1005
 
 
1006
  manager->unlock_requested.connect([&unlock_emitted]()
 
1007
  {
 
1008
    unlock_emitted = true;
 
1009
  });
 
1010
 
 
1011
  logind_->GetObject("org.freedesktop.login1.Session")->EmitSignal("Unlock");
 
1012
 
 
1013
  Utils::WaitUntilMSec(unlock_emitted);
 
1014
  EXPECT_TRUE(unlock_emitted);
 
1015
}
 
1016
 
1007
1017
} // Namespace