cros: DBUS client to interact with fingerprint DBUS API.

chromeos/dbus/biod_biometrics_manager_client_unittest.cc

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chromeos/dbus/biod_biometrics_manager_client.h"
+
+#include <map>
+#include <string>
+
+#include "base/bind.h"
+#include "base/run_loop.h"
+#include "dbus/mock_bus.h"
+#include "dbus/mock_object_proxy.h"
+#include "dbus/object_path.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::Return;
+
+namespace chromeos {
+
+namespace {
+
+// Shorthand for a commonly-used constant.
+const char* kInterface = biod::kBiometricsManagerInterface;
+
+void CheckObjectPathCallback(const dbus::ObjectPath& expected_object_path,
+                             const dbus::ObjectPath& object_path) {
+  EXPECT_EQ(expected_object_path, object_path);
+}
+
+void CheckObjectPathArrayCallback(
+    const std::vector<dbus::ObjectPath>& expected_object_paths,
+    const std::vector<dbus::ObjectPath>& object_paths) {
+  EXPECT_EQ(expected_object_paths.size(), object_paths.size());
+  for (size_t i = 0; i < expected_object_paths.size(); ++i)
+    EXPECT_EQ(expected_object_paths[i], object_paths[i]);
+}
+
+// Implementation of BiodBiometricsManagerClient::Observer.
+class TestBiometricsObserver : public BiodBiometricsManagerClient::Observer {
+ public:
+  TestBiometricsObserver() {}
+  ~TestBiometricsObserver() override {}
+
+  int num_scan_received() const { return num_scan_received_; }
+  int num_attempt_received() const { return num_attempt_received_; }
+  int num_failure_received() const { return num_failure_received_; }
+
+  // BiodBiometricsManagerClient::Observer:
+  void ClientRestarted() override {}
+
+  void EnrollScanDoneReceived(uint32_t scan_result, bool is_complete) override {
+    num_scan_received_++;
+  }
+
+  void AuthScanDoneReceived(uint32_t scan_result,
+                            const AuthScanMatches& matches) override {
+    num_attempt_received_++;
+  }
+
+  void ScanFailedReceived() override { num_failure_received_++; }
+
+ private:
+  int num_scan_received_ = 0;
+  int num_attempt_received_ = 0;
+  int num_failure_received_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(TestBiometricsObserver);
+};
+
+}  // namespace
+
+class BiodBiometricsManagerClientTest : public testing::Test {
+ public:
+  BiodBiometricsManagerClientTest() {}
+  ~BiodBiometricsManagerClientTest() override {}
+
+  void SetUp() override {
+    dbus::Bus::Options options;
+    options.bus_type = dbus::Bus::SYSTEM;
+    bus_ = new dbus::MockBus(options);
+
+    proxy_ =
+        new dbus::MockObjectProxy(bus_.get(), biod::kBiodServiceName,
+                                  dbus::ObjectPath(biod::kBiodServicePath));
+
+    // |client_|'s Init() method should request a proxy for communicating with
+    // biometrics api.
+    EXPECT_CALL(*bus_.get(),
+                GetObjectProxy(biod::kBiodServiceName,
+                               dbus::ObjectPath(biod::kBiodServicePath)))
+        .WillRepeatedly(Return(proxy_.get()));
+
+    // Save |client_|'s signal callback.
+    EXPECT_CALL(*proxy_.get(), ConnectToSignal(kInterface, _, _, _))
+        .WillRepeatedly(
+            Invoke(this, &BiodBiometricsManagerClientTest::ConnectToSignal));
+
+    // |client_|'s Init() method should register methods.
+    EXPECT_CALL(*proxy_.get(), CallMethod(_, _, _))
+        .WillRepeatedly(
+            Invoke(this, &BiodBiometricsManagerClientTest::OnCallMethod));
+
+    client_.reset(
+        BiodBiometricsManagerClient::Create(REAL_DBUS_CLIENT_IMPLEMENTATION));
+    client_->Init(bus_.get());
+
+    // Execute callbacks posted by Init().
+    base::RunLoop().RunUntilIdle();
+  }
+
+ protected:
+  // Set the values a method is expected to have when a dbus method is called.
+  void SetExpectedMethodArguments(const std::string& expected_interface,
+                                  const std::string& expected_name,
+                                  dbus::Response* response) {
+    expected_interface_ = expected_interface;
+    expected_name_ = expected_name;
+    expected_response_ = response;
+  }
+
+  // Synchronously passes |signal| to |client_|'s handler, simulating the signal
+  // from biometrics.
+  void EmitSignal(dbus::Signal* signal) {
+    const std::string signal_name = signal->GetMember();
+    const auto it = signal_callbacks_.find(signal_name);
+    ASSERT_TRUE(it != signal_callbacks_.end())
+        << "Client didn't register for signal " << signal_name;
+    it->second.Run(signal);
+  }
+
+  // Passes a enroll scan done signal to |client_|.
+  void EmitEnrollScanDoneSignal(uint32_t scan_result, bool is_complete) {
+    dbus::Signal signal(kInterface,
+                        biod::kBiometricsManagerEnrollScanDoneSignal);
+    dbus::MessageWriter writer(&signal);
+    writer.AppendUint32(scan_result);
+    writer.AppendBool(is_complete);
+    EmitSignal(&signal);
+  }
+
+  // Passes a auth scan done signal to |client_|.
+  void EmitAuthScanDoneSignal(uint32_t scan_result,
+                              const AuthScanMatches& matches) {
+    dbus::Signal signal(kInterface, biod::kBiometricsManagerAuthScanDoneSignal);
+    dbus::MessageWriter writer(&signal);
+    writer.AppendUint32(scan_result);
+
+    dbus::MessageWriter array_writer(NULL);
+    writer.OpenArray("{sx}", &array_writer);
+    for (auto& match : matches) {
+      dbus::MessageWriter entry_writer(NULL);
+      array_writer.OpenDictEntry(&entry_writer);
+      entry_writer.AppendString(match.first);
+      entry_writer.AppendArrayOfStrings(match.second);
+      array_writer.CloseContainer(&entry_writer);
+    }
+    writer.CloseContainer(&array_writer);
+    EmitSignal(&signal);
+  }
+
+  // Passes a scan failed signal to |client_|.
+  void EmitScanFailedSignal() {
+    dbus::Signal signal(kInterface, biod::kBiometricsManagerScanFailedSignal);
+    EmitSignal(&signal);
+  }
+
+  std::string expected_interface_;
+  std::string expected_name_;
+  dbus::Response* expected_response_;
+
+  base::MessageLoop message_loop_;
+
+  // Mock bus and proxy for simulating calls.
+  scoped_refptr<dbus::MockBus> bus_;
+  scoped_refptr<dbus::MockObjectProxy> proxy_;
+
+  std::unique_ptr<BiodBiometricsManagerClient> client_;
+
+  // Maps from powerd signal name to the corresponding callback provided by
+  // |client_|.
+  std::map<std::string, dbus::ObjectProxy::SignalCallback> signal_callbacks_;
+
+ private:
+  // Handles calls to |proxy_|'s ConnectToSignal() method.
+  void ConnectToSignal(
+      const std::string& interface_name,
+      const std::string& signal_name,
+      dbus::ObjectProxy::SignalCallback signal_callback,
+      dbus::ObjectProxy::OnConnectedCallback on_connected_callback) {
+    EXPECT_EQ(interface_name, kInterface);
+    signal_callbacks_[signal_name] = signal_callback;
+
+    message_loop_.task_runner()->PostTask(
+        FROM_HERE, base::Bind(on_connected_callback, interface_name,
+                              signal_name, true /* success */));
+  }
+
+  // Handles calls to |proxy_|'s CallMethod().
+  void OnCallMethod(dbus::MethodCall* method_call,
+                    int timeout_ms,
+                    const dbus::ObjectProxy::ResponseCallback& callback) {
+    EXPECT_EQ(expected_interface_, method_call->GetInterface());
+    EXPECT_EQ(expected_name_, method_call->GetMember());
+
+    message_loop_.task_runner()->PostTask(
+        FROM_HERE, base::Bind(callback, expected_response_));
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(BiodBiometricsManagerClientTest);
+};
+
+TEST_F(BiodBiometricsManagerClientTest, TestStartEnrollSession) {
+  const std::string& fake_id("fakeId");
+  const std::string& fake_label("fakeLabel");
+  const dbus::ObjectPath& fake_object_path(std::string("/fake/object/path"));
+
+  std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
+  dbus::MessageWriter writer(response.get());
+  writer.AppendObjectPath(fake_object_path);
+
+  // Create a fake response with a fake object path. The start enroll
+  // call should return this object path.
+  SetExpectedMethodArguments(kInterface,
+                             biod::kBiometricsManagerStartEnrollSessionMethod,
+                             response.get());
+  client_->StartEnrollSession(
+      fake_id, fake_label,
+      base::Bind(&CheckObjectPathCallback, fake_object_path));
+}
+
+TEST_F(BiodBiometricsManagerClientTest, TestGetRecordsForUser) {
+  const std::string& fake_id("fakeId");
+  const dbus::ObjectPath& fake_object_path(std::string("/fake/object/path"));
+  const std::vector<dbus::ObjectPath>& fake_object_paths = {fake_object_path,
+                                                            fake_object_path};

[rkc, 2017/03/20 23:24:34]

Nit: In lists, it's usually a good idea to have varied data so we can also
ensure testing of completeness of data and ordering.

[sammiequon, 2017/03/21 00:13:36]

Done.

+
+  std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
+  dbus::MessageWriter writer(response.get());
+  writer.AppendArrayOfObjectPaths(fake_object_paths);
+
+  // Create a fake response with an array fake object paths. The get enrollments
+  // call should return this array of object paths.
+  SetExpectedMethodArguments(kInterface,
+                             biod::kBiometricsManagerGetRecordsForUserMethod,
+                             response.get());
+  client_->GetRecordsForUser(
+      fake_id, base::Bind(&CheckObjectPathArrayCallback, fake_object_paths));
+}
+
+TEST_F(BiodBiometricsManagerClientTest, TestDestroyAllRecords) {
+  std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
+
+  SetExpectedMethodArguments(kInterface,
+                             biod::kBiometricsManagerDestroyAllRecordsMethod,
+                             response.get());
+  client_->DestroyAllRecords();
+}
+
+TEST_F(BiodBiometricsManagerClientTest, TestStartAuthentication) {
+  const dbus::ObjectPath& fake_object_path(std::string("/fake/object/path"));
+
+  // Create a fake response with a fake object path. The start authentication
+  // call should return this object path.
+  std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
+  dbus::MessageWriter writer(response.get());
+  writer.AppendObjectPath(fake_object_path);
+
+  SetExpectedMethodArguments(kInterface,
+                             biod::kBiometricsManagerStartAuthSessionMethod,
+                             response.get());
+  client_->StartAuthSession(
+      base::Bind(&CheckObjectPathCallback, fake_object_path));
+}
+
+// Verify when enroll scan done signals are mocked, observer(s) catch the
+// signals as expected.
+TEST_F(BiodBiometricsManagerClientTest, TestEnrollScanDoneObserver) {
+  TestBiometricsObserver observer1;
+  TestBiometricsObserver observer2;
+  client_->AddObserver(&observer1);
+
+  const uint32_t scan_signal = 0;
+  const bool is_complete = false;
+  EmitEnrollScanDoneSignal(scan_signal, is_complete);
+  EXPECT_EQ(1, observer1.num_scan_received());
+  EXPECT_EQ(0, observer2.num_scan_received());
+
+  client_->AddObserver(&observer2);
+  EmitEnrollScanDoneSignal(scan_signal, is_complete);
+  EXPECT_EQ(2, observer1.num_scan_received());
+  EXPECT_EQ(1, observer2.num_scan_received());
+
+  client_->RemoveObserver(&observer1);
+  EmitEnrollScanDoneSignal(scan_signal, is_complete);
+  EXPECT_EQ(2, observer1.num_scan_received());
+  EXPECT_EQ(2, observer2.num_scan_received());
+}
+
+// Verify when auth scan done signals are mocked, observer(s) catch the signals
+// as expected.
+TEST_F(BiodBiometricsManagerClientTest, TestAuthScanDoneObserver) {
+  TestBiometricsObserver observer1;
+  TestBiometricsObserver observer2;
+  client_->AddObserver(&observer1);
+
+  const uint32_t scan_signal = 0;
+  const AuthScanMatches test_attempt;
+  EmitAuthScanDoneSignal(scan_signal, test_attempt);
+  EXPECT_EQ(1, observer1.num_attempt_received());
+  EXPECT_EQ(0, observer2.num_attempt_received());
+
+  client_->AddObserver(&observer2);
+  EmitAuthScanDoneSignal(scan_signal, test_attempt);
+  EXPECT_EQ(2, observer1.num_attempt_received());
+  EXPECT_EQ(1, observer2.num_attempt_received());
+
+  client_->RemoveObserver(&observer1);
+  EmitAuthScanDoneSignal(scan_signal, test_attempt);
+  EXPECT_EQ(2, observer1.num_attempt_received());
+  EXPECT_EQ(2, observer2.num_attempt_received());
+}
+}  // namespace chromeos