cros: Remaining interfaces for DBUS biometrics client.

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"
@@ skipping 12 matching lines @@
 
 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;
+}
+
 // 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
@@ skipping 47 matching lines @@
     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)))
+    EXPECT_CALL(*bus_.get(), GetObjectProxy(biod::kBiodServiceName, _))
         .WillRepeatedly(Return(proxy_.get()));
 
     // Save |client_|'s signal callback.
     EXPECT_CALL(*proxy_.get(), ConnectToSignal(kInterface, _, _, _))
         .WillRepeatedly(Invoke(this, &BiodClientTest::ConnectToSignal));
 
     client_.reset(BiodClient::Create(REAL_DBUS_CLIENT_IMPLEMENTATION));
     client_->Init(bus_.get());
 
     // Execute callbacks posted by Init().
@@ skipping 151 matching lines @@
   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
-  // enrollments call should return this array of object paths.
+  // 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));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kFakeObjectPaths, returned_object_paths);
 
   // Verify that by sending a empty reponse the response is an empty array of
@@ skipping 66 matching lines @@
   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.num_failures_received());
 }
+
+TEST_F(BiodClientTest, TestGetRecordLabel) {
+  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));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(kFakeLabel, returned_label);
+
+  // Verify that by sending a empty reponse the response is an empty string.
+  // Also, logs will get printed.
+  returned_label = kInvalidString;
+  AddMethodExpectation(dbus::kDBusPropertiesGet, nullptr);
+  client_->RequestRecordLabel(kFakeRecordPath,
+                              base::Bind(&CopyString, &returned_label));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ("", returned_label);
+}
 }  // namespace chromeos