OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "chromeos/dbus/biod_biometrics_manager_client.h" | |
6 | |
7 #include <map> | |
8 #include <string> | |
9 | |
10 #include "base/bind.h" | |
11 #include "base/run_loop.h" | |
12 #include "dbus/mock_bus.h" | |
13 #include "dbus/mock_object_proxy.h" | |
14 #include "dbus/object_path.h" | |
15 #include "testing/gmock/include/gmock/gmock.h" | |
16 #include "testing/gtest/include/gtest/gtest.h" | |
17 | |
18 using ::testing::_; | |
19 using ::testing::Invoke; | |
20 using ::testing::Return; | |
21 | |
22 namespace chromeos { | |
23 | |
24 namespace { | |
25 | |
26 // Shorthand for a commonly-used constant. | |
27 const char* kInterface = biod::kBiometricsManagerInterface; | |
28 | |
29 void CheckObjectPathCallback(const dbus::ObjectPath& expected_object_path, | |
30 const dbus::ObjectPath& object_path) { | |
31 EXPECT_EQ(expected_object_path, object_path); | |
32 } | |
33 | |
34 void CheckObjectPathArrayCallback( | |
35 const std::vector<dbus::ObjectPath>& expected_object_paths, | |
36 const std::vector<dbus::ObjectPath>& object_paths) { | |
37 EXPECT_EQ(expected_object_paths.size(), object_paths.size()); | |
38 for (size_t i = 0; i < expected_object_paths.size(); ++i) | |
39 EXPECT_EQ(expected_object_paths[i], object_paths[i]); | |
40 } | |
41 | |
42 // Implementation of BiodBiometricsManagerClient::Observer. | |
43 class TestBiometricsObserver : public BiodBiometricsManagerClient::Observer { | |
44 public: | |
45 TestBiometricsObserver() {} | |
46 ~TestBiometricsObserver() override {} | |
47 | |
48 int num_scan_received() const { return num_scan_received_; } | |
49 int num_attempt_received() const { return num_attempt_received_; } | |
50 int num_failure_received() const { return num_failure_received_; } | |
51 | |
52 // BiodBiometricsManagerClient::Observer: | |
53 void ClientRestarted() override {} | |
54 | |
55 void EnrollScanDoneReceived(uint32_t scan_result, bool is_complete) override { | |
56 num_scan_received_++; | |
57 } | |
58 | |
59 void AuthScanDoneReceived(uint32_t scan_result, | |
60 const AuthScanMatches& matches) override { | |
61 num_attempt_received_++; | |
62 } | |
63 | |
64 void ScanFailedReceived() override { num_failure_received_++; } | |
65 | |
66 private: | |
67 int num_scan_received_ = 0; | |
68 int num_attempt_received_ = 0; | |
69 int num_failure_received_ = 0; | |
70 | |
71 DISALLOW_COPY_AND_ASSIGN(TestBiometricsObserver); | |
72 }; | |
73 | |
74 } // namespace | |
75 | |
76 class BiodBiometricsManagerClientTest : public testing::Test { | |
77 public: | |
78 BiodBiometricsManagerClientTest() {} | |
79 ~BiodBiometricsManagerClientTest() override {} | |
80 | |
81 void SetUp() override { | |
82 dbus::Bus::Options options; | |
83 options.bus_type = dbus::Bus::SYSTEM; | |
84 bus_ = new dbus::MockBus(options); | |
85 | |
86 proxy_ = | |
87 new dbus::MockObjectProxy(bus_.get(), biod::kBiodServiceName, | |
88 dbus::ObjectPath(biod::kBiodServicePath)); | |
89 | |
90 // |client_|'s Init() method should request a proxy for communicating with | |
91 // biometrics api. | |
92 EXPECT_CALL(*bus_.get(), | |
93 GetObjectProxy(biod::kBiodServiceName, | |
94 dbus::ObjectPath(biod::kBiodServicePath))) | |
95 .WillRepeatedly(Return(proxy_.get())); | |
96 | |
97 // Save |client_|'s signal callback. | |
98 EXPECT_CALL(*proxy_.get(), ConnectToSignal(kInterface, _, _, _)) | |
99 .WillRepeatedly( | |
100 Invoke(this, &BiodBiometricsManagerClientTest::ConnectToSignal)); | |
101 | |
102 // |client_|'s Init() method should register methods. | |
103 EXPECT_CALL(*proxy_.get(), CallMethod(_, _, _)) | |
104 .WillRepeatedly( | |
105 Invoke(this, &BiodBiometricsManagerClientTest::OnCallMethod)); | |
106 | |
107 client_.reset( | |
108 BiodBiometricsManagerClient::Create(REAL_DBUS_CLIENT_IMPLEMENTATION)); | |
109 client_->Init(bus_.get()); | |
110 | |
111 // Execute callbacks posted by Init(). | |
112 base::RunLoop().RunUntilIdle(); | |
113 } | |
114 | |
115 protected: | |
116 // Set the values a method is expected to have when a dbus method is called. | |
117 void SetExpectedMethodArguments(const std::string& expected_interface, | |
118 const std::string& expected_name, | |
119 dbus::Response* response) { | |
120 expected_interface_ = expected_interface; | |
121 expected_name_ = expected_name; | |
122 expected_response_ = response; | |
123 } | |
124 | |
125 // Synchronously passes |signal| to |client_|'s handler, simulating the signal | |
126 // from biometrics. | |
127 void EmitSignal(dbus::Signal* signal) { | |
128 const std::string signal_name = signal->GetMember(); | |
129 const auto it = signal_callbacks_.find(signal_name); | |
130 ASSERT_TRUE(it != signal_callbacks_.end()) | |
131 << "Client didn't register for signal " << signal_name; | |
132 it->second.Run(signal); | |
133 } | |
134 | |
135 // Passes a enroll scan done signal to |client_|. | |
136 void EmitEnrollScanDoneSignal(uint32_t scan_result, bool is_complete) { | |
137 dbus::Signal signal(kInterface, | |
138 biod::kBiometricsManagerEnrollScanDoneSignal); | |
139 dbus::MessageWriter writer(&signal); | |
140 writer.AppendUint32(scan_result); | |
141 writer.AppendBool(is_complete); | |
142 EmitSignal(&signal); | |
143 } | |
144 | |
145 // Passes a auth scan done signal to |client_|. | |
146 void EmitAuthScanDoneSignal(uint32_t scan_result, | |
147 const AuthScanMatches& matches) { | |
148 dbus::Signal signal(kInterface, biod::kBiometricsManagerAuthScanDoneSignal); | |
149 dbus::MessageWriter writer(&signal); | |
150 writer.AppendUint32(scan_result); | |
151 | |
152 dbus::MessageWriter array_writer(NULL); | |
153 writer.OpenArray("{sx}", &array_writer); | |
154 for (auto& match : matches) { | |
155 dbus::MessageWriter entry_writer(NULL); | |
156 array_writer.OpenDictEntry(&entry_writer); | |
157 entry_writer.AppendString(match.first); | |
158 entry_writer.AppendArrayOfStrings(match.second); | |
159 array_writer.CloseContainer(&entry_writer); | |
160 } | |
161 writer.CloseContainer(&array_writer); | |
162 EmitSignal(&signal); | |
163 } | |
164 | |
165 // Passes a scan failed signal to |client_|. | |
166 void EmitScanFailedSignal() { | |
167 dbus::Signal signal(kInterface, biod::kBiometricsManagerScanFailedSignal); | |
168 EmitSignal(&signal); | |
169 } | |
170 | |
171 std::string expected_interface_; | |
172 std::string expected_name_; | |
173 dbus::Response* expected_response_; | |
174 | |
175 base::MessageLoop message_loop_; | |
176 | |
177 // Mock bus and proxy for simulating calls. | |
178 scoped_refptr<dbus::MockBus> bus_; | |
179 scoped_refptr<dbus::MockObjectProxy> proxy_; | |
180 | |
181 std::unique_ptr<BiodBiometricsManagerClient> client_; | |
182 | |
183 // Maps from powerd signal name to the corresponding callback provided by | |
184 // |client_|. | |
185 std::map<std::string, dbus::ObjectProxy::SignalCallback> signal_callbacks_; | |
186 | |
187 private: | |
188 // Handles calls to |proxy_|'s ConnectToSignal() method. | |
189 void ConnectToSignal( | |
190 const std::string& interface_name, | |
191 const std::string& signal_name, | |
192 dbus::ObjectProxy::SignalCallback signal_callback, | |
193 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) { | |
194 EXPECT_EQ(interface_name, kInterface); | |
195 signal_callbacks_[signal_name] = signal_callback; | |
196 | |
197 message_loop_.task_runner()->PostTask( | |
198 FROM_HERE, base::Bind(on_connected_callback, interface_name, | |
199 signal_name, true /* success */)); | |
200 } | |
201 | |
202 // Handles calls to |proxy_|'s CallMethod(). | |
203 void OnCallMethod(dbus::MethodCall* method_call, | |
204 int timeout_ms, | |
205 const dbus::ObjectProxy::ResponseCallback& callback) { | |
206 EXPECT_EQ(expected_interface_, method_call->GetInterface()); | |
207 EXPECT_EQ(expected_name_, method_call->GetMember()); | |
208 | |
209 message_loop_.task_runner()->PostTask( | |
210 FROM_HERE, base::Bind(callback, expected_response_)); | |
211 } | |
212 | |
213 DISALLOW_COPY_AND_ASSIGN(BiodBiometricsManagerClientTest); | |
214 }; | |
215 | |
216 TEST_F(BiodBiometricsManagerClientTest, TestStartEnrollSession) { | |
217 const std::string& fake_id("fakeId"); | |
218 const std::string& fake_label("fakeLabel"); | |
219 const dbus::ObjectPath& fake_object_path(std::string("/fake/object/path")); | |
220 | |
221 std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty()); | |
222 dbus::MessageWriter writer(response.get()); | |
223 writer.AppendObjectPath(fake_object_path); | |
224 | |
225 // Create a fake response with a fake object path. The start enroll | |
226 // call should return this object path. | |
227 SetExpectedMethodArguments(kInterface, | |
228 biod::kBiometricsManagerStartEnrollSessionMethod, | |
229 response.get()); | |
230 client_->StartEnrollSession( | |
231 fake_id, fake_label, | |
232 base::Bind(&CheckObjectPathCallback, fake_object_path)); | |
233 } | |
234 | |
235 TEST_F(BiodBiometricsManagerClientTest, TestGetRecordsForUser) { | |
236 const std::string& fake_id("fakeId"); | |
237 const dbus::ObjectPath& fake_object_path(std::string("/fake/object/path")); | |
238 const std::vector<dbus::ObjectPath>& fake_object_paths = {fake_object_path, | |
239 fake_object_path}; | |
rkc
2017/03/20 23:24:34
Nit: In lists, it's usually a good idea to have va
sammiequon
2017/03/21 00:13:36
Done.
| |
240 | |
241 std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty()); | |
242 dbus::MessageWriter writer(response.get()); | |
243 writer.AppendArrayOfObjectPaths(fake_object_paths); | |
244 | |
245 // Create a fake response with an array fake object paths. The get enrollments | |
246 // call should return this array of object paths. | |
247 SetExpectedMethodArguments(kInterface, | |
248 biod::kBiometricsManagerGetRecordsForUserMethod, | |
249 response.get()); | |
250 client_->GetRecordsForUser( | |
251 fake_id, base::Bind(&CheckObjectPathArrayCallback, fake_object_paths)); | |
252 } | |
253 | |
254 TEST_F(BiodBiometricsManagerClientTest, TestDestroyAllRecords) { | |
255 std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty()); | |
256 | |
257 SetExpectedMethodArguments(kInterface, | |
258 biod::kBiometricsManagerDestroyAllRecordsMethod, | |
259 response.get()); | |
260 client_->DestroyAllRecords(); | |
261 } | |
262 | |
263 TEST_F(BiodBiometricsManagerClientTest, TestStartAuthentication) { | |
264 const dbus::ObjectPath& fake_object_path(std::string("/fake/object/path")); | |
265 | |
266 // Create a fake response with a fake object path. The start authentication | |
267 // call should return this object path. | |
268 std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty()); | |
269 dbus::MessageWriter writer(response.get()); | |
270 writer.AppendObjectPath(fake_object_path); | |
271 | |
272 SetExpectedMethodArguments(kInterface, | |
273 biod::kBiometricsManagerStartAuthSessionMethod, | |
274 response.get()); | |
275 client_->StartAuthSession( | |
276 base::Bind(&CheckObjectPathCallback, fake_object_path)); | |
277 } | |
278 | |
279 // Verify when enroll scan done signals are mocked, observer(s) catch the | |
280 // signals as expected. | |
281 TEST_F(BiodBiometricsManagerClientTest, TestEnrollScanDoneObserver) { | |
282 TestBiometricsObserver observer1; | |
283 TestBiometricsObserver observer2; | |
284 client_->AddObserver(&observer1); | |
285 | |
286 const uint32_t scan_signal = 0; | |
287 const bool is_complete = false; | |
288 EmitEnrollScanDoneSignal(scan_signal, is_complete); | |
289 EXPECT_EQ(1, observer1.num_scan_received()); | |
290 EXPECT_EQ(0, observer2.num_scan_received()); | |
291 | |
292 client_->AddObserver(&observer2); | |
293 EmitEnrollScanDoneSignal(scan_signal, is_complete); | |
294 EXPECT_EQ(2, observer1.num_scan_received()); | |
295 EXPECT_EQ(1, observer2.num_scan_received()); | |
296 | |
297 client_->RemoveObserver(&observer1); | |
298 EmitEnrollScanDoneSignal(scan_signal, is_complete); | |
299 EXPECT_EQ(2, observer1.num_scan_received()); | |
300 EXPECT_EQ(2, observer2.num_scan_received()); | |
301 } | |
302 | |
303 // Verify when auth scan done signals are mocked, observer(s) catch the signals | |
304 // as expected. | |
305 TEST_F(BiodBiometricsManagerClientTest, TestAuthScanDoneObserver) { | |
306 TestBiometricsObserver observer1; | |
307 TestBiometricsObserver observer2; | |
308 client_->AddObserver(&observer1); | |
309 | |
310 const uint32_t scan_signal = 0; | |
311 const AuthScanMatches test_attempt; | |
312 EmitAuthScanDoneSignal(scan_signal, test_attempt); | |
313 EXPECT_EQ(1, observer1.num_attempt_received()); | |
314 EXPECT_EQ(0, observer2.num_attempt_received()); | |
315 | |
316 client_->AddObserver(&observer2); | |
317 EmitAuthScanDoneSignal(scan_signal, test_attempt); | |
318 EXPECT_EQ(2, observer1.num_attempt_received()); | |
319 EXPECT_EQ(1, observer2.num_attempt_received()); | |
320 | |
321 client_->RemoveObserver(&observer1); | |
322 EmitAuthScanDoneSignal(scan_signal, test_attempt); | |
323 EXPECT_EQ(2, observer1.num_attempt_received()); | |
324 EXPECT_EQ(2, observer2.num_attempt_received()); | |
325 } | |
326 } // namespace chromeos | |
OLD | NEW |