CrOS: Add success/failure indicators for biod methods with no callback.

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 34 matching lines @@
     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) {
+  *dest_status = src_status;
+}
+
+void CopyBiometricType(biod::BiometricType* dest_type,
+                       biod::BiometricType src_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
@@ skipping 63 matching lines @@
 
     client_.reset(BiodClient::Create(REAL_DBUS_CLIENT_IMPLEMENTATION));
     client_->Init(bus_.get());
 
     // Execute callbacks posted by Init().
     base::RunLoop().RunUntilIdle();
   }
 
  protected:
   // Add an expectation for method with |method_name| to be called. When the
-  // method is called the response shoudl match |response|.
+  // method is called the response should match |response|.
   void AddMethodExpectation(const std::string& method_name,
                             std::unique_ptr<dbus::Response> response) {
     ASSERT_FALSE(pending_method_calls_.count(method_name));
     pending_method_calls_[method_name] = std::move(response);
     EXPECT_CALL(*proxy_.get(), CallMethod(HasMember(method_name), _, _))
         .WillOnce(Invoke(this, &BiodClientTest::OnCallMethod));
   }
 
+  void AddMethodWithErrorCallbackExpectation(

[Daniel Erat, 2017/04/08 00:12:34]

per earlier comment, you probably don't need this

[sammiequon, 2017/04/08 01:03:30]

Done.

+      const std::string& method_name,
+      std::unique_ptr<dbus::Response> response) {
+    ASSERT_FALSE(pending_method_calls_.count(method_name));
+    pending_method_calls_[method_name] = std::move(response);
+    EXPECT_CALL(*proxy_.get(),
+                CallMethodWithErrorCallback(HasMember(method_name), _, _, _))
+        .WillOnce(Invoke(this, &BiodClientTest::OnCallMethodWithErrorCallback));
+  }
+
   // 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);
   }
 
@@ skipping 70 matching lines @@
     auto it = pending_method_calls_.find(method_call->GetMember());
     ASSERT_TRUE(it != pending_method_calls_.end());
     auto pending_response = std::move(it->second);
     pending_method_calls_.erase(it);
 
     message_loop_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&RunResponseCallback, callback,
                               base::Passed(&pending_response)));
   }
 
+  void OnCallMethodWithErrorCallback(

[Daniel Erat, 2017/04/08 00:12:34]

or this

[sammiequon, 2017/04/08 01:03:30]

Done.

+      dbus::MethodCall* method_call,
+      int timeout_ms,
+      const dbus::ObjectProxy::ResponseCallback& callback,
+      const dbus::ObjectProxy::ErrorCallback& error_callback) {
+    auto it = pending_method_calls_.find(method_call->GetMember());
+    ASSERT_TRUE(it != pending_method_calls_.end());
+    auto pending_response = std::move(it->second);
+    pending_method_calls_.erase(it);
+
+    message_loop_.task_runner()->PostTask(
+        FROM_HERE, base::Bind(&RunResponseCallback, callback,
+                              base::Passed(&pending_response)));
+  }
+
   DISALLOW_COPY_AND_ASSIGN(BiodClientTest);
 };
 
 TEST_F(BiodClientTest, TestStartEnrollSession) {
   const std::string kFakeId("fakeId");
   const std::string kFakeLabel("fakeLabel");
   const dbus::ObjectPath kFakeObjectPath(std::string("/fake/object/path"));
   const dbus::ObjectPath kFakeObjectPath2(std::string("/fake/object/path2"));
 
   std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
@@ skipping 58 matching lines @@
   // object paths. Also, logs will get printed.
   AddMethodExpectation(biod::kBiometricsManagerGetRecordsForUserMethod,
                        nullptr);
   returned_object_paths = {dbus::ObjectPath(kInvalidTestPath)};
   client_->GetRecordsForUser(
       kFakeId, base::Bind(&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 a fake response with nothing. The destroy all records call should
+  // return success.
+  AddMethodWithErrorCallbackExpectation(
+      biod::kBiometricsManagerDestroyAllRecordsMethod, std::move(response));
+  DBusMethodCallStatus returned_status = static_cast<DBusMethodCallStatus>(-1);
+  client_->DestroyAllRecords(
+      base::Bind(&CopyDBusMethodCallStatus, &returned_status));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(DBUS_METHOD_CALL_SUCCESS, returned_status);
+
+  // Create a fake response with nothing. The destroy all records call should
+  // return failure.
+  AddMethodWithErrorCallbackExpectation(
+      biod::kBiometricsManagerDestroyAllRecordsMethod, nullptr);
+  returned_status = static_cast<DBusMethodCallStatus>(-1);
+  client_->DestroyAllRecords(
+      base::Bind(&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,
@@ skipping 15 matching lines @@
   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));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(dbus::ObjectPath(), returned_path);
 }
 
+TEST_F(BiodClientTest, TestRequestBiometricType) {
+  const biod::BiometricType kFakeBiometricType =
+      biod::BiometricType::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::BiometricType::BIOMETRIC_TYPE_MAX;
+  AddMethodExpectation(dbus::kDBusPropertiesGet, std::move(response));
+  client_->RequestType(
+      base::Bind(&CopyBiometricType, &returned_biometric_type));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(kFakeBiometricType, returned_biometric_type);
+
+  // Verify that by sending a empty reponse the response is an unknown biometric
+  // type. Also, logs will get printed.

[Daniel Erat, 2017/04/08 00:12:35]

what's the reason for mentioning that messages will be logged? you're not
verifying that in the test, right?

[sammiequon, 2017/04/08 01:03:30]

No, I thought it would be a good heads ups for filling up the console. Done.

[Daniel Erat, 2017/04/08 01:06:03]

i think that switching to CallMethod (and letting the dbus code log the error
instead of logging it yourself) may also avoid the log spam when running tests.
:-)

[sammiequon, 2017/04/08 01:31:47]

I see. I think think spam was the wrong word, it was like 3 lines.

+  returned_biometric_type = biod::BiometricType::BIOMETRIC_TYPE_MAX;
+  AddMethodExpectation(dbus::kDBusPropertiesGet, nullptr);
+  client_->RequestType(
+      base::Bind(&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));
+  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);
+}
+
 // Verify when signals are mocked, an observer will catch the signals as
 // expected.
 TEST_F(BiodClientTest, TestNotifyObservers) {
   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;
@@ skipping 11 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