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 dbus::ObjectPath& fake_object_path2(std::string("/fake/object/path2")); |
| 239 const std::vector<dbus::ObjectPath>& fake_object_paths = {fake_object_path, |
| 240 fake_object_path2}; |
| 241 |
| 242 std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty()); |
| 243 dbus::MessageWriter writer(response.get()); |
| 244 writer.AppendArrayOfObjectPaths(fake_object_paths); |
| 245 |
| 246 // Create a fake response with an array fake object paths. The get enrollments |
| 247 // call should return this array of object paths. |
| 248 SetExpectedMethodArguments(kInterface, |
| 249 biod::kBiometricsManagerGetRecordsForUserMethod, |
| 250 response.get()); |
| 251 client_->GetRecordsForUser( |
| 252 fake_id, base::Bind(&CheckObjectPathArrayCallback, fake_object_paths)); |
| 253 } |
| 254 |
| 255 TEST_F(BiodBiometricsManagerClientTest, TestDestroyAllRecords) { |
| 256 std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty()); |
| 257 |
| 258 SetExpectedMethodArguments(kInterface, |
| 259 biod::kBiometricsManagerDestroyAllRecordsMethod, |
| 260 response.get()); |
| 261 client_->DestroyAllRecords(); |
| 262 } |
| 263 |
| 264 TEST_F(BiodBiometricsManagerClientTest, TestStartAuthentication) { |
| 265 const dbus::ObjectPath& fake_object_path(std::string("/fake/object/path")); |
| 266 |
| 267 // Create a fake response with a fake object path. The start authentication |
| 268 // call should return this object path. |
| 269 std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty()); |
| 270 dbus::MessageWriter writer(response.get()); |
| 271 writer.AppendObjectPath(fake_object_path); |
| 272 |
| 273 SetExpectedMethodArguments(kInterface, |
| 274 biod::kBiometricsManagerStartAuthSessionMethod, |
| 275 response.get()); |
| 276 client_->StartAuthSession( |
| 277 base::Bind(&CheckObjectPathCallback, fake_object_path)); |
| 278 } |
| 279 |
| 280 // Verify when enroll scan done signals are mocked, observer(s) catch the |
| 281 // signals as expected. |
| 282 TEST_F(BiodBiometricsManagerClientTest, TestEnrollScanDoneObserver) { |
| 283 TestBiometricsObserver observer1; |
| 284 TestBiometricsObserver observer2; |
| 285 client_->AddObserver(&observer1); |
| 286 |
| 287 const uint32_t scan_signal = 0; |
| 288 const bool is_complete = false; |
| 289 EmitEnrollScanDoneSignal(scan_signal, is_complete); |
| 290 EXPECT_EQ(1, observer1.num_scan_received()); |
| 291 EXPECT_EQ(0, observer2.num_scan_received()); |
| 292 |
| 293 client_->AddObserver(&observer2); |
| 294 EmitEnrollScanDoneSignal(scan_signal, is_complete); |
| 295 EXPECT_EQ(2, observer1.num_scan_received()); |
| 296 EXPECT_EQ(1, observer2.num_scan_received()); |
| 297 |
| 298 client_->RemoveObserver(&observer1); |
| 299 EmitEnrollScanDoneSignal(scan_signal, is_complete); |
| 300 EXPECT_EQ(2, observer1.num_scan_received()); |
| 301 EXPECT_EQ(2, observer2.num_scan_received()); |
| 302 } |
| 303 |
| 304 // Verify when auth scan done signals are mocked, observer(s) catch the signals |
| 305 // as expected. |
| 306 TEST_F(BiodBiometricsManagerClientTest, TestAuthScanDoneObserver) { |
| 307 TestBiometricsObserver observer1; |
| 308 TestBiometricsObserver observer2; |
| 309 client_->AddObserver(&observer1); |
| 310 |
| 311 const uint32_t scan_signal = 0; |
| 312 const AuthScanMatches test_attempt; |
| 313 EmitAuthScanDoneSignal(scan_signal, test_attempt); |
| 314 EXPECT_EQ(1, observer1.num_attempt_received()); |
| 315 EXPECT_EQ(0, observer2.num_attempt_received()); |
| 316 |
| 317 client_->AddObserver(&observer2); |
| 318 EmitAuthScanDoneSignal(scan_signal, test_attempt); |
| 319 EXPECT_EQ(2, observer1.num_attempt_received()); |
| 320 EXPECT_EQ(1, observer2.num_attempt_received()); |
| 321 |
| 322 client_->RemoveObserver(&observer1); |
| 323 EmitAuthScanDoneSignal(scan_signal, test_attempt); |
| 324 EXPECT_EQ(2, observer1.num_attempt_received()); |
| 325 EXPECT_EQ(2, observer2.num_attempt_received()); |
| 326 } |
| 327 } // namespace chromeos |
OLD | NEW |