biod/biometrics_manager_record_wrapper_test.cc

// Copyright 2023 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/strings/stringprintf.h"
#include "biod/biometrics_manager_record.h"
#include "biod/biometrics_manager_record_wrapper.h"
#include "biod/biometrics_manager_wrapper.h"
#include "biod/mock_biod_metrics.h"
#include "biod/mock_biometrics_manager.h"
#include "biod/mock_biometrics_manager_record.h"
#include "biod/mock_cros_fp_biometrics_manager.h"
#include "biod/mock_cros_fp_device.h"
#include "biod/mock_cros_fp_record_manager.h"
#include "biod/mock_session_state_manager.h"
#include "dbus/mock_bus.h"
#include "dbus/mock_exported_object.h"
#include "dbus/mock_object_proxy.h"

#include <map>
#include <memory>
#include <string>
#include <utility>

#include <base/environment.h>
#include <brillo/dbus/mock_exported_object_manager.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <base/logging.h>
#include <base/memory/weak_ptr.h>

using testing::_;
using testing::IsEmpty;
using testing::Return;
using testing::SaveArg;
using testing::StrEq;

using dbus::ObjectPath;

namespace biod {
namespace {

using brillo::dbus_utils::DBusInterface;
using brillo::dbus_utils::ExportedObjectManager;
using dbus::ObjectPath;

class MockBiometricsManagerRecordWrapper
    : public BiometricsManagerRecordWrapper {
 public:
  MockBiometricsManagerRecordWrapper(
      BiometricsManagerWrapper* biometrics_manager,
      std::unique_ptr<BiometricsManagerRecordInterface> record,
      ExportedObjectManager* object_manager,
      const ObjectPath& object_path)
      : BiometricsManagerRecordWrapper(biometrics_manager,
                                       std::move(record),
                                       object_manager,
                                       object_path) {}
  ~MockBiometricsManagerRecordWrapper() = default;

  bool SetLabel(brillo::ErrorPtr* error, const std::string& new_label) {
    return BiometricsManagerRecordWrapper::SetLabel(error, new_label);
  }

  bool Remove(brillo::ErrorPtr* error) {
    return BiometricsManagerRecordWrapper::Remove(error);
  }

  std::string GetPropertyLabelValue() const { return property_label_.value(); }
};

class BiometricsManagerRecordWrapperTest : public ::testing::Test {
 public:
  BiometricsManagerRecordWrapperTest() {
    dbus::Bus::Options options;
    options.bus_type = dbus::Bus::SYSTEM;
    bus_ = new dbus::MockBus(options);
    ON_CALL(*bus_, GetExportedObject)
        .WillByDefault(Invoke(
            this, &BiometricsManagerRecordWrapperTest::GetExportedObject));

    proxy_ =
        new dbus::MockObjectProxy(bus_.get(), dbus::kDBusServiceName,
                                  dbus::ObjectPath(dbus::kDBusServicePath));

    ON_CALL(*bus_, GetObjectProxy(dbus::kDBusServiceName, _))
        .WillByDefault(Return(proxy_.get()));

    auto mock_biometrics_manager = std::make_unique<MockBiometricsManager>();
    bio_manager_ = mock_biometrics_manager.get();

    object_manager_ =
        std::make_unique<brillo::dbus_utils::MockExportedObjectManager>(
            bus_, dbus::ObjectPath(kBiodServicePath));
    session_manager_ = std::make_unique<MockSessionStateManager>();

    EXPECT_CALL(*session_manager_, AddObserver).Times(1);

    mock_bio_path_ = dbus::ObjectPath(
        base::StringPrintf("%s/%s", kBiodServicePath, "MockBiometricsManager"));

    auto sequencer =
        base::MakeRefCounted<brillo::dbus_utils::AsyncEventSequencer>();

    wrapper_.emplace(
        std::move(mock_biometrics_manager), object_manager_.get(),
        session_manager_.get(), mock_bio_path_,
        sequencer->GetHandler("Failed to register BiometricsManager", false));
  }

 protected:
  scoped_refptr<dbus::MockBus> bus_;
  scoped_refptr<dbus::MockObjectProxy> proxy_;
  MockBiometricsManager* bio_manager_;
  std::unique_ptr<brillo::dbus_utils::MockExportedObjectManager>
      object_manager_;
  dbus::ObjectPath mock_bio_path_;
  std::map<std::string, scoped_refptr<dbus::MockExportedObject>>
      exported_objects_;
  std::unique_ptr<MockSessionStateManager> session_manager_;
  std::optional<BiometricsManagerWrapper> wrapper_;

 private:
  std::map<std::string, dbus::ExportedObject::MethodCallCallback>
      method_callbacks_;

  dbus::ExportedObject* GetExportedObject(const dbus::ObjectPath& object_path);

  bool ExportMethodAndBlock(
      const std::string& interface_name,
      const std::string& method_name,
      const dbus::ExportedObject::MethodCallCallback& method_call_callback);
};

dbus::ExportedObject* BiometricsManagerRecordWrapperTest::GetExportedObject(
    const dbus::ObjectPath& object_path) {
  auto iter = exported_objects_.find(object_path.value());
  if (iter != exported_objects_.end()) {
    return iter->second.get();
  }

  scoped_refptr<dbus::MockExportedObject> exported_object =
      new dbus::MockExportedObject(bus_.get(), object_path);
  exported_objects_[object_path.value()] = exported_object;

  ON_CALL(*exported_object, ExportMethodAndBlock)
      .WillByDefault(Invoke(
          this, &BiometricsManagerRecordWrapperTest::ExportMethodAndBlock));

  return exported_object.get();
}

bool BiometricsManagerRecordWrapperTest::ExportMethodAndBlock(
    const std::string& interface_name,
    const std::string& method_name,
    const dbus::ExportedObject::MethodCallCallback& method_call_callback) {
  std::string full_name = interface_name + "." + method_name;
  method_callbacks_[full_name] = method_call_callback;

  return true;
}

TEST_F(BiometricsManagerRecordWrapperTest, TestSetLabelTrue) {
  auto mock_record = std::make_unique<MockBiometricsManagerRecord>();

  std::string records_root_path =
      mock_bio_path_.value() + std::string("/Record");

  const char kRecordId1[] = "00000000_0000_0000_0000_000000000001";
  std::string record_id = kRecordId1;
  ObjectPath record_path(records_root_path + kRecordId1);

  EXPECT_CALL(*mock_record, SetLabel(_)).WillOnce(Return(true));
  auto biometrics_manager_record_wrapper = MockBiometricsManagerRecordWrapper(
      &wrapper_.value(), std::move(mock_record), object_manager_.get(),
      record_path);

  const std::string label = "record_label";
  brillo::ErrorPtr error;

  EXPECT_TRUE(biometrics_manager_record_wrapper.SetLabel(&error, label));

  EXPECT_THAT(biometrics_manager_record_wrapper.GetPropertyLabelValue(),
              StrEq(label));
}

TEST_F(BiometricsManagerRecordWrapperTest, TestSetLabelFalse) {
  auto mock_record = std::make_unique<MockBiometricsManagerRecord>();

  std::string records_root_path =
      mock_bio_path_.value() + std::string("/Record");

  const char kRecordId1[] = "00000000_0000_0000_0000_000000000001";
  std::string record_id = kRecordId1;
  ObjectPath record_path(records_root_path + kRecordId1);

  EXPECT_CALL(*mock_record, SetLabel(_)).WillOnce(Return(false));
  auto biometrics_manager_record_wrapper = MockBiometricsManagerRecordWrapper(
      &wrapper_.value(), std::move(mock_record), object_manager_.get(),
      record_path);

  const std::string label = "record_label";
  brillo::ErrorPtr error;

  EXPECT_FALSE(biometrics_manager_record_wrapper.SetLabel(&error, label));
  EXPECT_THAT(error->GetMessage(), StrEq("Failed to set label"));

  EXPECT_THAT(biometrics_manager_record_wrapper.GetPropertyLabelValue(),
              IsEmpty());
}

TEST_F(BiometricsManagerRecordWrapperTest, TestRemoveTrue) {
  auto mock_record = std::make_unique<MockBiometricsManagerRecord>();

  std::string records_root_path =
      mock_bio_path_.value() + std::string("/Record");

  const char kRecordId1[] = "00000000_0000_0000_0000_000000000001";
  std::string record_id = kRecordId1;
  ObjectPath record_path(records_root_path + kRecordId1);

  EXPECT_CALL(*mock_record, Remove()).WillOnce(Return(true));
  auto biometrics_manager_record_wrapper = MockBiometricsManagerRecordWrapper(
      &wrapper_.value(), std::move(mock_record), object_manager_.get(),
      record_path);

  const std::string label = "record_label";
  brillo::ErrorPtr error;

  EXPECT_TRUE(biometrics_manager_record_wrapper.Remove(&error));
}

TEST_F(BiometricsManagerRecordWrapperTest, TestRemoveFalse) {
  auto mock_record = std::make_unique<MockBiometricsManagerRecord>();

  std::string records_root_path =
      mock_bio_path_.value() + std::string("/Record");

  const char kRecordId1[] = "00000000_0000_0000_0000_000000000001";
  std::string record_id = kRecordId1;
  ObjectPath record_path(records_root_path + kRecordId1);

  EXPECT_CALL(*mock_record, Remove()).WillOnce(Return(false));
  auto biometrics_manager_record_wrapper = MockBiometricsManagerRecordWrapper(
      &wrapper_.value(), std::move(mock_record), object_manager_.get(),
      record_path);

  const std::string label = "record_label";
  brillo::ErrorPtr error;

  EXPECT_FALSE(biometrics_manager_record_wrapper.Remove(&error));
  EXPECT_THAT(error->GetMessage(), StrEq("Failed to remove record"));
}

}  // namespace
}  // namespace biod