← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/test_lockscreen_controller.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_lockscreen_controller.cpp
 
1
// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 
2
/*
 
3
* Copyright (C) 2014 Canonical Ltd
 
4
*
 
5
* This program is free software: you can redistribute it and/or modify
 
6
* it under the terms of the GNU General Public License version 3 as
 
7
* published by the Free Software Foundation.
 
8
*
 
9
* This program is distributed in the hope that it will be useful,
 
10
* but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
* GNU General Public License for more details.
 
13
*
 
14
* You should have received a copy of the GNU General Public License
 
15
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
16
*
 
17
* Authored by: Andrea Azzarone <andrea.azzarone@canonical.com>
 
18
*/
 
19
 
 
20
#include <gmock/gmock.h>
 
21
using namespace testing;
 
22
 
 
23
#include "lockscreen/LockScreenController.h"
 
24
 
 
25
#include <Nux/NuxTimerTickSource.h>
 
26
#include <NuxCore/AnimationController.h>
 
27
#include <UnityCore/GLibDBusServer.h>
 
28
 
 
29
 
 
30
#include "lockscreen/LockScreenSettings.h"
 
31
#include "unity-shared/PanelStyle.h"
 
32
#include "unity-shared/UScreen.h"
 
33
#include "unity-shared/UnitySettings.h"
 
34
#include "test_mock_session_manager.h"
 
35
#include "test_uscreen_mock.h"
 
36
#include "test_utils.h"
 
37
 
 
38
namespace unity
 
39
{
 
40
namespace lockscreen
 
41
{
 
42
namespace
 
43
{
 
44
 
 
45
const unsigned ANIMATION_DURATION = 400 * 1000; // in microseconds
 
46
const unsigned TICK_DURATION =  10 * 1000;
 
47
 
 
48
const std::string TEST_SERVER_NAME = "com.canonical.Unity.Test.DisplayManager";
 
49
const std::string LIGHTDM_PATH = "/org/freedesktop/DisplayManager/Session0";
 
50
 
 
51
}
 
52
 
 
53
namespace introspection
 
54
{
 
55
 
 
56
const std::string LIGHTDM =
 
57
R"(<node>
 
58
  <interface name="org.freedesktop.DisplayManager.Session">
 
59
    <method name="Lock"/>
 
60
  </interface>
 
61
</node>)";
 
62
 
 
63
}
 
64
 
 
65
struct ShieldFactoryMock : ShieldFactoryInterface
 
66
{
 
67
  nux::ObjectPtr<AbstractShield> CreateShield(session::Manager::Ptr const&, int, bool) override
 
68
  {
 
69
    return nux::ObjectPtr<AbstractShield>(new AbstractShield(nullptr, 0, false));
 
70
  }
 
71
};
 
72
 
 
73
struct TestLockScreenController : Test
 
74
{
 
75
  TestLockScreenController()
 
76
    : animation_controller(tick_source)
 
77
    , session_manager(std::make_shared<NiceMock<session::MockManager>>())
 
78
    , upstart_wrapper(std::make_shared<UpstartWrapper>())
 
79
    , shield_factory(std::make_shared<ShieldFactoryMock>())
 
80
    , controller(session_manager, upstart_wrapper, shield_factory)
 
81
  {
 
82
    lightdm_ = std::make_shared<glib::DBusServer>(TEST_SERVER_NAME);
 
83
    lightdm_->AddObjects(introspection::LIGHTDM, LIGHTDM_PATH);
 
84
 
 
85
    Utils::WaitUntilMSec([] { return lightdm_->IsConnected(); });
 
86
  }
 
87
 
 
88
  struct ControllerWrap : Controller
 
89
  {
 
90
    ControllerWrap(session::Manager::Ptr const& session_manager,
 
91
                   UpstartWrapper::Ptr const& upstart_wrapper,
 
92
                   ShieldFactoryInterface::Ptr const& shield_factory)
 
93
      : Controller(session_manager, upstart_wrapper, shield_factory, /* test_mode */ true)
 
94
    {}
 
95
 
 
96
    using Controller::shields_;
 
97
  };
 
98
 
 
99
  nux::NuxTimerTickSource tick_source;
 
100
  nux::animation::AnimationController animation_controller;
 
101
 
 
102
  MockUScreen uscreen;
 
103
  unity::Settings unity_settings;
 
104
  unity::panel::Style panel_style;
 
105
  unity::lockscreen::Settings lockscreen_settings;
 
106
  static glib::DBusServer::Ptr lightdm_;
 
107
  session::MockManager::Ptr session_manager;
 
108
  unity::UpstartWrapper::Ptr upstart_wrapper;
 
109
 
 
110
  ShieldFactoryMock::Ptr shield_factory;
 
111
  ControllerWrap controller;
 
112
};
 
113
 
 
114
glib::DBusServer::Ptr TestLockScreenController::lightdm_;
 
115
 
 
116
TEST_F(TestLockScreenController, Construct)
 
117
{
 
118
  EXPECT_TRUE(controller.shields_.empty());
 
119
}
 
120
 
 
121
TEST_F(TestLockScreenController, DisconnectUScreenSignalsOnDestruction)
 
122
{
 
123
  size_t before = uscreen.changed.size();
 
124
  {
 
125
    Controller dummy(session_manager);
 
126
  }
 
127
  ASSERT_EQ(before, uscreen.changed.size());
 
128
 
 
129
  std::vector<nux::Geometry> monitors;
 
130
  uscreen.changed.emit(0, monitors);
 
131
}
 
132
 
 
133
TEST_F(TestLockScreenController, DisconnectSessionManagerSignalsOnDestruction)
 
134
{
 
135
  size_t before = session_manager->unlock_requested.size();
 
136
  {
 
137
    Controller dummy(session_manager);
 
138
  }
 
139
  ASSERT_EQ(before, session_manager->unlock_requested.size());
 
140
 
 
141
  session_manager->unlock_requested.emit();
 
142
}
 
143
 
 
144
TEST_F(TestLockScreenController, UScreenChangedIgnoredOnScreenUnlocked)
 
145
{
 
146
  uscreen.SetupFakeMultiMonitor(/*primary*/ 0, /*emit_change*/ true);
 
147
  EXPECT_TRUE(controller.shields_.empty());
 
148
}
 
149
 
 
150
TEST_F(TestLockScreenController, LockScreenTypeNone)
 
151
{
 
152
  lockscreen_settings.lockscreen_type = Type::NONE;
 
153
  session_manager->lock_requested.emit();
 
154
 
 
155
  ASSERT_EQ(0, controller.shields_.size());
 
156
}
 
157
 
 
158
TEST_F(TestLockScreenController, LockScreenTypeLightdmOnSingleMonitor)
 
159
{
 
160
  g_setenv("XDG_SESSION_PATH", LIGHTDM_PATH.c_str(), true);
 
161
 
 
162
  bool lock_called = false;
 
163
 
 
164
  lightdm_->GetObjects().front()->SetMethodsCallsHandler([&] (std::string const& method, GVariant*) -> GVariant* {
 
165
    if (method == "Lock")
 
166
      lock_called = true;
 
167
 
 
168
    return nullptr;
 
169
  });
 
170
 
 
171
  lockscreen_settings.lockscreen_type = Type::LIGHTDM;
 
172
  session_manager->lock_requested.emit();
 
173
 
 
174
  ASSERT_EQ(1, controller.shields_.size());
 
175
  EXPECT_FALSE(controller.shields_.at(0)->primary());
 
176
  Utils::WaitUntilMSec(lock_called);
 
177
}
 
178
 
 
179
TEST_F(TestLockScreenController, LockScreenTypeLightdmOnMultiMonitor)
 
180
{
 
181
  g_setenv("XDG_SESSION_PATH", LIGHTDM_PATH.c_str(), true);
 
182
 
 
183
  bool lock_called = false;
 
184
 
 
185
  lightdm_->GetObjects().front()->SetMethodsCallsHandler([&] (std::string const& method, GVariant*) -> GVariant* {
 
186
    if (method == "Lock")
 
187
      lock_called = true;
 
188
 
 
189
    return nullptr;
 
190
  });
 
191
 
 
192
  lockscreen_settings.lockscreen_type = Type::LIGHTDM;
 
193
  uscreen.SetupFakeMultiMonitor(/*primary*/ 0, /*emit_change*/ true);
 
194
  session_manager->lock_requested.emit();
 
195
 
 
196
  ASSERT_EQ(monitors::MAX, controller.shields_.size());
 
197
 
 
198
  for (unsigned int i=0; i < monitors::MAX; ++i)
 
199
    EXPECT_FALSE(controller.shields_.at(i)->primary());
 
200
 
 
201
  Utils::WaitUntilMSec(lock_called);
 
202
}
 
203
 
 
204
TEST_F(TestLockScreenController, UnlockScreenTypeLightdmOnSingleMonitor)
 
205
{
 
206
  g_setenv("XDG_SESSION_PATH", LIGHTDM_PATH.c_str(), true);
 
207
 
 
208
  bool lock_called = false;
 
209
 
 
210
  lightdm_->GetObjects().front()->SetMethodsCallsHandler([&] (std::string const& method, GVariant*) -> GVariant* {
 
211
    if (method == "Lock")
 
212
      lock_called = true;
 
213
 
 
214
    return nullptr;
 
215
  });
 
216
 
 
217
  lockscreen_settings.lockscreen_type = Type::LIGHTDM;
 
218
  session_manager->lock_requested.emit();
 
219
 
 
220
  ASSERT_EQ(1, controller.shields_.size());
 
221
  Utils::WaitUntilMSec(lock_called);
 
222
 
 
223
  session_manager->unlock_requested.emit();
 
224
  tick_source.tick(ANIMATION_DURATION);
 
225
 
 
226
  ASSERT_EQ(0, controller.shields_.size());
 
227
}
 
228
 
 
229
TEST_F(TestLockScreenController, UnlockScreenTypeLightdmOnMultiMonitor)
 
230
{
 
231
  g_setenv("XDG_SESSION_PATH", LIGHTDM_PATH.c_str(), true);
 
232
 
 
233
  bool lock_called = false;
 
234
 
 
235
  lightdm_->GetObjects().front()->SetMethodsCallsHandler([&] (std::string const& method, GVariant*) -> GVariant* {
 
236
    if (method == "Lock")
 
237
      lock_called = true;
 
238
 
 
239
    return nullptr;
 
240
  });
 
241
 
 
242
  lockscreen_settings.lockscreen_type = Type::LIGHTDM;
 
243
  uscreen.SetupFakeMultiMonitor(/*primary*/ 0, /*emit_change*/ true);
 
244
  session_manager->lock_requested.emit();
 
245
 
 
246
  ASSERT_EQ(monitors::MAX, controller.shields_.size());
 
247
  Utils::WaitUntilMSec(lock_called);
 
248
 
 
249
  session_manager->unlock_requested.emit();
 
250
  tick_source.tick(ANIMATION_DURATION);
 
251
 
 
252
  ASSERT_EQ(0, controller.shields_.size());
 
253
}
 
254
 
 
255
TEST_F(TestLockScreenController, LockScreenOnSingleMonitor)
 
256
{
 
257
  session_manager->lock_requested.emit();
 
258
 
 
259
  ASSERT_EQ(1, controller.shields_.size());
 
260
  EXPECT_EQ(uscreen.GetMonitors().at(0), controller.shields_.at(0)->GetGeometry());
 
261
}
 
262
 
 
263
TEST_F(TestLockScreenController, LockScreenOnMultiMonitor)
 
264
{
 
265
  uscreen.SetupFakeMultiMonitor();
 
266
 
 
267
  session_manager->lock_requested.emit();
 
268
  ASSERT_EQ(monitors::MAX, controller.shields_.size());
 
269
 
 
270
  for (unsigned int i=0; i < monitors::MAX; ++i)
 
271
    EXPECT_EQ(uscreen.GetMonitors().at(i), controller.shields_.at(i)->GetAbsoluteGeometry());
 
272
}
 
273
 
 
274
TEST_F(TestLockScreenController, SwitchToMultiMonitor)
 
275
{
 
276
  session_manager->lock_requested.emit();
 
277
  tick_source.tick(ANIMATION_DURATION);
 
278
 
 
279
  ASSERT_EQ(1, controller.shields_.size());
 
280
  EXPECT_EQ(uscreen.GetMonitors().at(0), controller.shields_.at(0)->GetGeometry());
 
281
 
 
282
  uscreen.SetupFakeMultiMonitor(/* primary */ 0, /* emit_change */ true);
 
283
 
 
284
  ASSERT_EQ(monitors::MAX, controller.shields_.size());
 
285
 
 
286
  for (unsigned int i=0; i < monitors::MAX; ++i)
 
287
  {
 
288
    ASSERT_EQ(uscreen.GetMonitors().at(i), controller.shields_.at(i)->GetAbsoluteGeometry());
 
289
    ASSERT_TRUE(controller.shields_.at(i)->IsVisible());
 
290
  }
 
291
}
 
292
 
 
293
TEST_F(TestLockScreenController, SwitchToSingleMonitor)
 
294
{
 
295
  uscreen.SetupFakeMultiMonitor(/* primary */ 0, /* emit_change */ true);
 
296
  session_manager->lock_requested.emit();
 
297
 
 
298
  ASSERT_EQ(monitors::MAX, controller.shields_.size());
 
299
 
 
300
  for (unsigned int i=0; i < monitors::MAX; ++i)
 
301
    ASSERT_EQ(uscreen.GetMonitors().at(i), controller.shields_.at(i)->GetAbsoluteGeometry());
 
302
 
 
303
  uscreen.Reset(/* emit_change */ true);
 
304
 
 
305
  ASSERT_EQ(1, controller.shields_.size());
 
306
  EXPECT_EQ(uscreen.GetMonitors().at(0), controller.shields_.at(0)->GetGeometry());
 
307
}
 
308
 
 
309
TEST_F(TestLockScreenController, UnlockScreenOnSingleMonitor)
 
310
{
 
311
  session_manager->lock_requested.emit();
 
312
 
 
313
  ASSERT_EQ(1, controller.shields_.size());
 
314
 
 
315
  session_manager->unlock_requested.emit();
 
316
  tick_source.tick(ANIMATION_DURATION);
 
317
 
 
318
  EXPECT_TRUE(controller.shields_.empty());
 
319
}
 
320
 
 
321
TEST_F(TestLockScreenController, UnlockScreenOnMultiMonitor)
 
322
{
 
323
  uscreen.SetupFakeMultiMonitor(/* primary */ 0, /* emit_change */ true);
 
324
  session_manager->lock_requested.emit();
 
325
 
 
326
  ASSERT_EQ(monitors::MAX, controller.shields_.size());
 
327
 
 
328
  session_manager->unlock_requested.emit();
 
329
  tick_source.tick(ANIMATION_DURATION);
 
330
 
 
331
  EXPECT_TRUE(controller.shields_.empty());
 
332
}
 
333
 
 
334
} // lockscreen
 
335
} // unity