cros: Added a fake fingerprint storage class.

chromeos/dbus/biod/biod_client_unittest.cc

 // Copyright 2017 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/biod_client.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
+#include "chromeos/dbus/biod/test_utils.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;
 
 // Value used to intialize dbus::ObjectPath objects in tests to make it easier
 // to determine when empty values have been assigned.
 const char kInvalidTestPath[] = "/invalid/test/path";
 
 // Value used to intialize string objects in tests to make it easier to
 // determine when empty values have been assigned.
 const char kInvalidString[] = "invalidString";
 
-void CopyObjectPath(dbus::ObjectPath* dest_path,
-                    const dbus::ObjectPath& src_path) {
-  CHECK(dest_path);
-  *dest_path = src_path;
-}
-
-void CopyObjectPathArray(
-    std::vector<dbus::ObjectPath>* dest_object_paths,
-    const std::vector<dbus::ObjectPath>& src_object_paths) {
-  CHECK(dest_object_paths);
-  *dest_object_paths = src_object_paths;
-}
-
-void CopyString(std::string* dest_str, const std::string& src_str) {
-  CHECK(dest_str);
-  *dest_str = src_str;
-}
-
-void CopyDBusMethodCallStatus(DBusMethodCallStatus* dest_status,
-                              DBusMethodCallStatus src_status) {
-  CHECK(dest_status);
-  *dest_status = src_status;
-}
-
-void CopyBiometricType(biod::BiometricType* dest_type,
-                       biod::BiometricType src_type) {
-  CHECK(dest_type);
-  *dest_type = src_type;
-}
-
 // Matcher that verifies that a dbus::Message has member |name|.
 MATCHER_P(HasMember, name, "") {
   if (arg->GetMember() != name) {
     *result_listener << "has member " << arg->GetMember();
     return false;
   }
   return true;
 }
 
 // Runs |callback| with |response|. Needed due to ResponseCallback expecting a
 // bare pointer rather than an std::unique_ptr.
 void RunResponseCallback(dbus::ObjectProxy::ResponseCallback callback,
                          std::unique_ptr<dbus::Response> response) {
   callback.Run(response.get());
 }
 
-// Implementation of BiodClient::Observer.
-class TestBiodObserver : public BiodClient::Observer {
- public:
-  TestBiodObserver() {}
-  ~TestBiodObserver() override {}
-
-  int num_enroll_scans_received() const { return num_enroll_scans_received_; }
-  int num_auth_scans_received() const { return num_auth_scans_received_; }
-  int num_failures_received() const { return num_failures_received_; }
-
-  // BiodClient::Observer:
-  void BiodServiceRestarted() override {}
-
-  void BiodEnrollScanDoneReceived(biod::ScanResult scan_result,
-                                  bool enroll_sesion_complete) override {
-    num_enroll_scans_received_++;
-  }
-
-  void BiodAuthScanDoneReceived(biod::ScanResult scan_result,
-                                const AuthScanMatches& matches) override {
-    num_auth_scans_received_++;
-  }
-
-  void BiodSessionFailedReceived() override { num_failures_received_++; }
-
- private:
-  int num_enroll_scans_received_ = 0;
-  int num_auth_scans_received_ = 0;
-  int num_failures_received_ = 0;
-
-  DISALLOW_COPY_AND_ASSIGN(TestBiodObserver);
-};
-
 }  // namespace
 
 class BiodClientTest : public testing::Test {
  public:
   BiodClientTest() {}
   ~BiodClientTest() override {}
 
   void SetUp() override {
     dbus::Bus::Options options;
     options.bus_type = dbus::Bus::SYSTEM;
@@ skipping 131 matching lines @@
 
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(response.get());
   writer.AppendObjectPath(kFakeObjectPath);
 
   // Create a fake response with a fake object path. The start enroll
   // call should return this object path.
   AddMethodExpectation(biod::kBiometricsManagerStartEnrollSessionMethod,
                        std::move(response));
   dbus::ObjectPath returned_path(kInvalidTestPath);
-  client_->StartEnrollSession(kFakeId, kFakeLabel,
-                              base::Bind(&CopyObjectPath, &returned_path));
+  client_->StartEnrollSession(
+      kFakeId, kFakeLabel,
+      base::Bind(&test_utils::CopyObjectPath, &returned_path));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kFakeObjectPath, returned_path);
 
   // Verify that by sending a empty reponse or a improperly formatted one, the
   // response is an empty object path.
   AddMethodExpectation(biod::kBiometricsManagerStartEnrollSessionMethod,
                        nullptr);
   returned_path = dbus::ObjectPath(kInvalidTestPath);
-  client_->StartEnrollSession(kFakeId, kFakeLabel,
-                              base::Bind(&CopyObjectPath, &returned_path));
+  client_->StartEnrollSession(
+      kFakeId, kFakeLabel,
+      base::Bind(&test_utils::CopyObjectPath, &returned_path));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(dbus::ObjectPath(), returned_path);
 
   std::unique_ptr<dbus::Response> bad_response(dbus::Response::CreateEmpty());
   dbus::MessageWriter bad_writer(bad_response.get());
   bad_writer.AppendString("");
   AddMethodExpectation(biod::kBiometricsManagerStartEnrollSessionMethod,
                        std::move(bad_response));
   returned_path = dbus::ObjectPath(kInvalidTestPath);
-  client_->StartEnrollSession(kFakeId, kFakeLabel,
-                              base::Bind(&CopyObjectPath, &returned_path));
+  client_->StartEnrollSession(
+      kFakeId, kFakeLabel,
+      base::Bind(&test_utils::CopyObjectPath, &returned_path));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(dbus::ObjectPath(), returned_path);
 }
 
 TEST_F(BiodClientTest, TestGetRecordsForUser) {
   const std::string kFakeId("fakeId");
   const dbus::ObjectPath kFakeObjectPath(std::string("/fake/object/path"));
   const dbus::ObjectPath kFakeObjectPath2(std::string("/fake/object/path2"));
   const std::vector<dbus::ObjectPath> kFakeObjectPaths = {kFakeObjectPath,
                                                           kFakeObjectPath2};
 
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(response.get());
   writer.AppendArrayOfObjectPaths(kFakeObjectPaths);
 
   // Create a fake response with an array of fake object paths. The get
   // records for user call should return this array of object paths.
   AddMethodExpectation(biod::kBiometricsManagerGetRecordsForUserMethod,
                        std::move(response));
   std::vector<dbus::ObjectPath> returned_object_paths = {
       dbus::ObjectPath(kInvalidTestPath)};
   client_->GetRecordsForUser(
-      kFakeId, base::Bind(&CopyObjectPathArray, &returned_object_paths));
+      kFakeId,
+      base::Bind(&test_utils::CopyObjectPathArray, &returned_object_paths));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kFakeObjectPaths, returned_object_paths);
 
   // Verify that by sending a empty reponse the response is an empty array of
   // object paths.
   AddMethodExpectation(biod::kBiometricsManagerGetRecordsForUserMethod,
                        nullptr);
   returned_object_paths = {dbus::ObjectPath(kInvalidTestPath)};
   client_->GetRecordsForUser(
-      kFakeId, base::Bind(&CopyObjectPathArray, &returned_object_paths));
+      kFakeId,
+      base::Bind(&test_utils::CopyObjectPathArray, &returned_object_paths));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(std::vector<dbus::ObjectPath>(), returned_object_paths);
 }
 
 TEST_F(BiodClientTest, TestDestroyAllRecords) {
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(response.get());
 
   // Create an empty response to simulate success.
   AddMethodExpectation(biod::kBiometricsManagerDestroyAllRecordsMethod,
                        std::move(response));
   DBusMethodCallStatus returned_status = static_cast<DBusMethodCallStatus>(-1);
   client_->DestroyAllRecords(
-      base::Bind(&CopyDBusMethodCallStatus, &returned_status));
+      base::Bind(&test_utils::CopyDBusMethodCallStatus, &returned_status));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(DBUS_METHOD_CALL_SUCCESS, returned_status);
 
   // Return a null response to simulate failure.
   AddMethodExpectation(biod::kBiometricsManagerDestroyAllRecordsMethod,
                        nullptr);
   returned_status = static_cast<DBusMethodCallStatus>(-1);
   client_->DestroyAllRecords(
-      base::Bind(&CopyDBusMethodCallStatus, &returned_status));
+      base::Bind(&test_utils::CopyDBusMethodCallStatus, &returned_status));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(DBUS_METHOD_CALL_FAILURE, returned_status);
 }
 
 TEST_F(BiodClientTest, TestStartAuthentication) {
   const dbus::ObjectPath kFakeObjectPath(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(kFakeObjectPath);
 
   AddMethodExpectation(biod::kBiometricsManagerStartAuthSessionMethod,
                        std::move(response));
   dbus::ObjectPath returned_path(kInvalidTestPath);
-  client_->StartAuthSession(base::Bind(&CopyObjectPath, &returned_path));
+  client_->StartAuthSession(
+      base::Bind(&test_utils::CopyObjectPath, &returned_path));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kFakeObjectPath, returned_path);
 
   // Verify that by sending a empty reponse or a improperly formatted one, the
   // response is an empty object path.
   AddMethodExpectation(biod::kBiometricsManagerStartAuthSessionMethod, nullptr);
   returned_path = dbus::ObjectPath(kInvalidTestPath);
-  client_->StartAuthSession(base::Bind(&CopyObjectPath, &returned_path));
+  client_->StartAuthSession(
+      base::Bind(&test_utils::CopyObjectPath, &returned_path));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(dbus::ObjectPath(), returned_path);
 
   std::unique_ptr<dbus::Response> bad_response(dbus::Response::CreateEmpty());
   dbus::MessageWriter bad_writer(bad_response.get());
   bad_writer.AppendString("");
   AddMethodExpectation(biod::kBiometricsManagerStartAuthSessionMethod,
                        std::move(bad_response));
   returned_path = dbus::ObjectPath(kInvalidTestPath);
-  client_->StartAuthSession(base::Bind(&CopyObjectPath, &returned_path));
+  client_->StartAuthSession(
+      base::Bind(&test_utils::CopyObjectPath, &returned_path));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(dbus::ObjectPath(), returned_path);
 }
 
 TEST_F(BiodClientTest, TestRequestBiometricType) {
   const biod::BiometricType kFakeBiometricType =
       biod::BIOMETRIC_TYPE_FINGERPRINT;
 
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(response.get());
   writer.AppendVariantOfUint32(static_cast<uint32_t>(kFakeBiometricType));
 
   // Create a fake response with biometric type. The get label call should
   // return this exact biometric type.
   biod::BiometricType returned_biometric_type = biod::BIOMETRIC_TYPE_MAX;
   AddMethodExpectation(dbus::kDBusPropertiesGet, std::move(response));
   client_->RequestType(
-      base::Bind(&CopyBiometricType, &returned_biometric_type));
+      base::Bind(&test_utils::CopyBiometricType, &returned_biometric_type));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kFakeBiometricType, returned_biometric_type);
 
   // Verify that by sending a null reponse, the result is an unknown biometric
   // type.
   returned_biometric_type = biod::BIOMETRIC_TYPE_MAX;
   AddMethodExpectation(dbus::kDBusPropertiesGet, nullptr);
   client_->RequestType(
-      base::Bind(&CopyBiometricType, &returned_biometric_type));
+      base::Bind(&test_utils::CopyBiometricType, &returned_biometric_type));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(biod::BiometricType::BIOMETRIC_TYPE_UNKNOWN,
             returned_biometric_type);
 }
 
 TEST_F(BiodClientTest, TestRequestRecordLabel) {
   const std::string kFakeLabel("fakeLabel");
   const dbus::ObjectPath kFakeRecordPath(std::string("/fake/record/path"));
 
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(response.get());
   writer.AppendString(kFakeLabel);
 
   // Create a fake response with string. The get label call should return this
   // exact string.
   std::string returned_label = kInvalidString;
   AddMethodExpectation(dbus::kDBusPropertiesGet, std::move(response));
-  client_->RequestRecordLabel(kFakeRecordPath,
-                              base::Bind(&CopyString, &returned_label));
+  client_->RequestRecordLabel(
+      kFakeRecordPath, base::Bind(&test_utils::CopyString, &returned_label));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kFakeLabel, returned_label);
 
   // Verify that by sending a null reponse, the result is an empty string.
   returned_label = kInvalidString;
   AddMethodExpectation(dbus::kDBusPropertiesGet, nullptr);
-  client_->RequestRecordLabel(kFakeRecordPath,
-                              base::Bind(&CopyString, &returned_label));
+  client_->RequestRecordLabel(
+      kFakeRecordPath, base::Bind(&test_utils::CopyString, &returned_label));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ("", returned_label);
 }
 
 // Verify when signals are mocked, an observer will catch the signals as
 // expected.
 TEST_F(BiodClientTest, TestNotifyObservers) {
-  TestBiodObserver observer;
+  test_utils::TestBiodObserver observer;
   client_->AddObserver(&observer);
   EXPECT_TRUE(client_->HasObserver(&observer));
 
   const biod::ScanResult scan_signal = biod::ScanResult::SCAN_RESULT_SUCCESS;
   const bool enroll_session_complete = false;
   const AuthScanMatches test_attempt;
-  EXPECT_EQ(0, observer.num_enroll_scans_received());
-  EXPECT_EQ(0, observer.num_auth_scans_received());
+  EXPECT_EQ(0, observer.NumEnrollScansReceived());
+  EXPECT_EQ(0, observer.NumAuthScansReceived());
   EXPECT_EQ(0, observer.num_failures_received());
 
   EmitEnrollScanDoneSignal(scan_signal, enroll_session_complete);
-  EXPECT_EQ(1, observer.num_enroll_scans_received());
+  EXPECT_EQ(1, observer.NumEnrollScansReceived());
 
   EmitAuthScanDoneSignal(scan_signal, test_attempt);
-  EXPECT_EQ(1, observer.num_auth_scans_received());
+  EXPECT_EQ(1, observer.NumAuthScansReceived());
 
   EmitScanFailedSignal();
   EXPECT_EQ(1, observer.num_failures_received());
 
   client_->RemoveObserver(&observer);
 
   EmitEnrollScanDoneSignal(scan_signal, enroll_session_complete);
   EmitAuthScanDoneSignal(scan_signal, test_attempt);
-  EXPECT_EQ(1, observer.num_enroll_scans_received());
-  EXPECT_EQ(1, observer.num_auth_scans_received());
+  EXPECT_EQ(1, observer.NumEnrollScansReceived());
+  EXPECT_EQ(1, observer.NumAuthScansReceived());
   EXPECT_EQ(1, observer.num_failures_received());
 }
 }  // namespace chromeos