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

#include "chromeos/ash/components/dbus/userdataauth/userdataauth_client.h"

#include <string>
#include <utility>

#include "base/memory/raw_ptr.h"
#include "base/test/task_environment.h"
#include "chromeos/ash/components/dbus/cryptohome/UserDataAuth.pb.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"
#include "third_party/cros_system_api/dbus/cryptohome/dbus-constants.h"

using ::testing::_;
using ::testing::Invoke;
using ::testing::Return;
using ::testing::SaveArg;

namespace ash {

namespace {

// 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) {
  std::move(callback).Run(response.get());
}

bool ProtobufEquals(const google::protobuf::MessageLite& a,
                    const google::protobuf::MessageLite& b) {
  std::string a_serialized, b_serialized;
  a.SerializeToString(&a_serialized);
  b.SerializeToString(&b_serialized);
  return a_serialized == b_serialized;
}

// Returns a PrepareAuthFactorProgress proto representing a success fingerprint
// enroll scan with the desired |percent_complete|.
::user_data_auth::PrepareAuthFactorProgress PrepareFpAuthFactorForAdd(
    int percent_complete) {
  ::user_data_auth::PrepareAuthFactorProgress progress;
  progress.set_purpose(::user_data_auth::PURPOSE_ADD_AUTH_FACTOR);
  auto* add_progress = progress.mutable_add_progress();
  add_progress->set_auth_factor_type(
      ::user_data_auth::AUTH_FACTOR_TYPE_FINGERPRINT);
  auto* enroll_progress = add_progress->mutable_biometrics_progress();
  enroll_progress->mutable_scan_result()->set_fingerprint_result(
      ::user_data_auth::FINGERPRINT_SCAN_RESULT_SUCCESS);
  enroll_progress->set_done(percent_complete == 100);
  enroll_progress->mutable_fingerprint_progress()->set_percent_complete(
      percent_complete);
  return progress;
}

// Returns a PrepareAuthFactorProgress proto representing a fingerprint auth
// scan.
::user_data_auth::PrepareAuthFactorProgress PrepareFpAuthFactorForAuth(
    ::user_data_auth::FingerprintScanResult result) {
  ::user_data_auth::PrepareAuthFactorProgress progress;
  progress.set_purpose(::user_data_auth::PURPOSE_AUTHENTICATE_AUTH_FACTOR);
  auto* auth_progress = progress.mutable_auth_progress();
  auth_progress->set_auth_factor_type(
      ::user_data_auth::AUTH_FACTOR_TYPE_FINGERPRINT);
  auto* result_progress = auth_progress->mutable_biometrics_progress();
  result_progress->mutable_scan_result()->set_fingerprint_result(result);
  return progress;
}

// Create a callback that would copy the input argument passed to it into |out|.
// This is used mostly to create a callback that would catch the reply from
// dbus.
template <typename T>
base::OnceCallback<void(T)> CreateCopyCallback(T* out) {
  return base::BindOnce([](T* out, T result) { *out = result; }, out);
}

class TestObserver : public UserDataAuthClient::Observer {
 public:
  // UserDataAuthClient::Observer overrides
  void LowDiskSpace(const ::user_data_auth::LowDiskSpace& status) override {
    last_low_disk_space_.CopyFrom(status);
    low_disk_space_count_++;
  }

  void DircryptoMigrationProgress(
      const ::user_data_auth::DircryptoMigrationProgress& progress) override {
    last_dircrypto_progress_.CopyFrom(progress);
    dircrypto_progress_count_++;
  }

  const ::user_data_auth::LowDiskSpace& last_low_disk_space() const {
    return last_low_disk_space_;
  }

  int low_disk_space_count() const { return low_disk_space_count_; }

  const ::user_data_auth::DircryptoMigrationProgress& last_dircrypto_progress()
      const {
    return last_dircrypto_progress_;
  }

  int dircrypto_progress_count() const { return dircrypto_progress_count_; }

 private:
  // The protobuf that came with the signal when the last low disk space event
  // came.
  ::user_data_auth::LowDiskSpace last_low_disk_space_;

  // The number of times the LowDiskSpace signal is triggered.
  int low_disk_space_count_ = 0;

  // The protobuf that came with the signal when the last dircrypto migration
  // progress event came.
  ::user_data_auth::DircryptoMigrationProgress last_dircrypto_progress_;

  // The number of times the DircryptoMigrationProgress signal is triggered.
  int dircrypto_progress_count_ = 0;
};

// The test observer that only observe fingerprint related progress messages.
class TestFingerprintObserver
    : public UserDataAuthClient::PrepareAuthFactorProgressObserver {
 public:
  void OnFingerprintAuthScan(
      const ::user_data_auth::AuthScanDone& result) override {
    last_auth_scan_done_.CopyFrom(result);
    auth_scan_done_count_++;
  }
  void OnFingerprintEnrollProgress(
      const ::user_data_auth::AuthEnrollmentProgress& progress) override {
    last_enroll_progress_.CopyFrom(progress);
    enroll_progress_count_++;
  }

  int auth_scan_done_count() const { return auth_scan_done_count_; }
  int enroll_progress_count() const { return enroll_progress_count_; }
  const ::user_data_auth::AuthScanDone& last_auth_scan_done() const {
    return last_auth_scan_done_;
  }
  const ::user_data_auth::AuthEnrollmentProgress& last_enroll_progress() const {
    return last_enroll_progress_;
  }

 private:
  int auth_scan_done_count_ = 0;
  int enroll_progress_count_ = 0;
  ::user_data_auth::AuthScanDone last_auth_scan_done_;
  ::user_data_auth::AuthEnrollmentProgress last_enroll_progress_;
};

// The test observer that only observe AuthFactorStatusUpdate messages.
class TestAuthFactorStatusUpdateObserver
    : public UserDataAuthClient::AuthFactorStatusUpdateObserver {
 public:
  void OnAuthFactorStatusUpdate(
      const ::user_data_auth::AuthFactorStatusUpdate& update) override {
    last_broadcast_id_ = update.broadcast_id();
    last_auth_factor_with_status_ = update.auth_factor_with_status();
  }
  const std::string& last_broadcast_id() const { return last_broadcast_id_; }
  const ::user_data_auth::AuthFactorWithStatus& last_auth_factor_with_status()
      const {
    return last_auth_factor_with_status_;
  }

 private:
  std::string last_broadcast_id_;
  ::user_data_auth::AuthFactorWithStatus last_auth_factor_with_status_;
};

}  // namespace

class UserDataAuthClientTest : public testing::Test {
 public:
  UserDataAuthClientTest() = default;
  ~UserDataAuthClientTest() override = default;

  void SetUp() override {
    dbus::Bus::Options options;
    options.bus_type = dbus::Bus::SYSTEM;
    bus_ = new dbus::MockBus(options);

    dbus::ObjectPath userdataauth_object_path =
        dbus::ObjectPath(::user_data_auth::kUserDataAuthServicePath);
    proxy_ = new dbus::MockObjectProxy(
        bus_.get(), ::user_data_auth::kUserDataAuthServiceName,
        userdataauth_object_path);

    // Makes sure `GetObjectProxy()` is caled with the correct service name and
    // path.
    EXPECT_CALL(*bus_.get(),
                GetObjectProxy(::user_data_auth::kUserDataAuthServiceName,
                               userdataauth_object_path))
        .WillRepeatedly(Return(proxy_.get()));

    EXPECT_CALL(*proxy_.get(), DoCallMethod(_, _, _))
        .WillRepeatedly(Invoke(this, &UserDataAuthClientTest::OnCallMethod));

    EXPECT_CALL(
        *proxy_,
        DoConnectToSignal(::user_data_auth::kUserDataAuthInterface,
                          ::user_data_auth::kDircryptoMigrationProgress, _, _))
        .WillOnce(SaveArg<2>(&dircrypto_progress_callback_));
    EXPECT_CALL(*proxy_,
                DoConnectToSignal(::user_data_auth::kUserDataAuthInterface,
                                  ::user_data_auth::kLowDiskSpace, _, _))
        .WillOnce(SaveArg<2>(&low_disk_space_callback_));

    EXPECT_CALL(*proxy_,
                DoConnectToSignal(
                    ::user_data_auth::kUserDataAuthInterface,
                    ::user_data_auth::kAuthEnrollmentProgressSignal, _, _))
        .WillOnce(SaveArg<2>(&auth_enrollment_callback_));
    EXPECT_CALL(*proxy_,
                DoConnectToSignal(
                    ::user_data_auth::kUserDataAuthInterface,
                    ::user_data_auth::kPrepareAuthFactorProgressSignal, _, _))
        .WillOnce(SaveArg<2>(&prepare_auth_factor_progress_callback_));

    EXPECT_CALL(*proxy_, DoConnectToSignal(
                             ::user_data_auth::kUserDataAuthInterface,
                             ::user_data_auth::kAuthFactorStatusUpdate, _, _))
        .WillOnce(SaveArg<2>(&auth_factor_status_update_callback_));

    UserDataAuthClient::Initialize(bus_.get());

    // Execute callbacks posted by `client_->Init()`.
    base::RunLoop().RunUntilIdle();

    client_ = UserDataAuthClient::Get();
  }

  void TearDown() override { UserDataAuthClient::Shutdown(); }

 protected:
  void EmitLowDiskSpaceSignal(const ::user_data_auth::LowDiskSpace& status) {
    dbus::Signal signal(::user_data_auth::kUserDataAuthInterface,
                        ::user_data_auth::kLowDiskSpace);
    dbus::MessageWriter writer(&signal);
    writer.AppendProtoAsArrayOfBytes(status);
    // Emit the signal.
    ASSERT_FALSE(low_disk_space_callback_.is_null());
    low_disk_space_callback_.Run(&signal);
  }

  void EmitDircryptoMigrationProgressSignal(
      const ::user_data_auth::DircryptoMigrationProgress& status) {
    dbus::Signal signal(::user_data_auth::kUserDataAuthInterface,
                        ::user_data_auth::kDircryptoMigrationProgress);
    dbus::MessageWriter writer(&signal);
    writer.AppendProtoAsArrayOfBytes(status);
    // Emit the signal.
    ASSERT_FALSE(dircrypto_progress_callback_.is_null());
    dircrypto_progress_callback_.Run(&signal);
  }

  void EmitPrepareAuthFactorProgressSignal(
      const ::user_data_auth::PrepareAuthFactorProgress& progress) {
    dbus::Signal signal(::user_data_auth::kUserDataAuthInterface,
                        ::user_data_auth::kPrepareAuthFactorProgressSignal);
    dbus::MessageWriter writer(&signal);
    writer.AppendProtoAsArrayOfBytes(progress);
    // Emit the signal.
    ASSERT_FALSE(prepare_auth_factor_progress_callback_.is_null());
    prepare_auth_factor_progress_callback_.Run(&signal);
  }

  void EmitAuthFactorStatusUpdateSignal(
      const ::user_data_auth::AuthFactorStatusUpdate& update) {
    dbus::Signal signal(::user_data_auth::kUserDataAuthInterface,
                        ::user_data_auth::kAuthFactorStatusUpdate);
    dbus::MessageWriter writer(&signal);
    writer.AppendProtoAsArrayOfBytes(update);
    // Emit the signal.
    ASSERT_FALSE(auth_factor_status_update_callback_.is_null());
    auth_factor_status_update_callback_.Run(&signal);
  }

  base::test::SingleThreadTaskEnvironment task_environment_;

  // Mock bus and proxy for simulating calls.
  scoped_refptr<dbus::MockBus> bus_;
  scoped_refptr<dbus::MockObjectProxy> proxy_;

  // Convenience pointer to the global instance.
  raw_ptr<UserDataAuthClient, DanglingUntriaged> client_;

  // The expected replies to the respective D-Bus calls.
  ::user_data_auth::IsMountedReply expected_is_mounted_reply_;
  ::user_data_auth::UnmountReply expected_unmount_reply_;
  ::user_data_auth::RemoveReply expected_remove_reply_;
  ::user_data_auth::StartMigrateToDircryptoReply
      expected_start_migrate_to_dircrypto_reply_;
  ::user_data_auth::NeedsDircryptoMigrationReply
      expected_needs_dircrypto_migration_reply_;
  ::user_data_auth::GetSupportedKeyPoliciesReply
      expected_get_supported_key_policies_reply_;
  ::user_data_auth::GetAccountDiskUsageReply
      expected_get_account_disk_usage_reply_;
  ::user_data_auth::StartAuthSessionReply expected_start_auth_session_reply_;

  // When it is set `true`, an invalid array of bytes that cannot be parsed will
  // be the response.
  bool shall_message_parsing_fail_ = false;

 private:
  // Handles calls to |proxy_|'s `CallMethod()`.
  void OnCallMethod(dbus::MethodCall* method_call,
                    int timeout_ms,
                    dbus::ObjectProxy::ResponseCallback* callback) {
    std::unique_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
    dbus::MessageWriter writer(response.get());
    if (shall_message_parsing_fail_) {
      // 0x02 => Field 0, Type String
      // (0xFF)*6 => Varint, the size of the string, it is not terminated and is
      // a very large value so the parsing will fail.
      constexpr uint8_t invalid_protobuf[] = {0x02, 0xFF, 0xFF, 0xFF,
                                              0xFF, 0xFF, 0xFF};
      writer.AppendArrayOfBytes(invalid_protobuf);
    } else if (method_call->GetMember() == ::user_data_auth::kIsMounted) {
      writer.AppendProtoAsArrayOfBytes(expected_is_mounted_reply_);
    } else if (method_call->GetMember() == ::user_data_auth::kIsMounted) {
      writer.AppendProtoAsArrayOfBytes(expected_is_mounted_reply_);
    } else if (method_call->GetMember() == ::user_data_auth::kUnmount) {
      writer.AppendProtoAsArrayOfBytes(expected_unmount_reply_);
    } else if (method_call->GetMember() == ::user_data_auth::kRemove) {
      writer.AppendProtoAsArrayOfBytes(expected_remove_reply_);
    } else if (method_call->GetMember() ==
               ::user_data_auth::kStartMigrateToDircrypto) {
      writer.AppendProtoAsArrayOfBytes(
          expected_start_migrate_to_dircrypto_reply_);
    } else if (method_call->GetMember() ==
               ::user_data_auth::kNeedsDircryptoMigration) {
      writer.AppendProtoAsArrayOfBytes(
          expected_needs_dircrypto_migration_reply_);
    } else if (method_call->GetMember() ==
               ::user_data_auth::kGetSupportedKeyPolicies) {
      writer.AppendProtoAsArrayOfBytes(
          expected_get_supported_key_policies_reply_);
    } else if (method_call->GetMember() ==
               ::user_data_auth::kGetAccountDiskUsage) {
      writer.AppendProtoAsArrayOfBytes(expected_get_account_disk_usage_reply_);
    } else if (method_call->GetMember() ==
               ::user_data_auth::kStartAuthSession) {
      writer.AppendProtoAsArrayOfBytes(expected_start_auth_session_reply_);
    } else {
      ASSERT_FALSE(true) << "Unrecognized member: " << method_call->GetMember();
    }
    task_environment_.GetMainThreadTaskRunner()->PostTask(
        FROM_HERE, base::BindOnce(RunResponseCallback, std::move(*callback),
                                  std::move(response)));
  }

  // Callback that delivers the Low Disk Space signal to the client when called.
  dbus::ObjectProxy::SignalCallback low_disk_space_callback_;

  // Callback that delivers the dircrypto Migration Progress signal to the
  // client when called.
  dbus::ObjectProxy::SignalCallback dircrypto_progress_callback_;

  // Callback that delivers the cryptohome AuthEnrollmentProgress signal to the
  // client when called.
  dbus::ObjectProxy::SignalCallback auth_enrollment_callback_;

  // Callback that delivers the cryptohome AuthEnrollmentProgress signal to the
  // client when called.
  dbus::ObjectProxy::SignalCallback prepare_auth_factor_progress_callback_;

  // Callback that delivers the cryptohome AuthFactorStatusUpdate signal to the
  // client when called.
  dbus::ObjectProxy::SignalCallback auth_factor_status_update_callback_;
};

TEST_F(UserDataAuthClientTest, IsMounted) {
  expected_is_mounted_reply_.set_is_mounted(true);
  expected_is_mounted_reply_.set_is_ephemeral_mount(false);
  std::optional<::user_data_auth::IsMountedReply> result_reply = std::nullopt;
  auto callback = base::BindOnce(
      [](std::optional<::user_data_auth::IsMountedReply>* result_reply,
         std::optional<::user_data_auth::IsMountedReply> reply) {
        *result_reply = reply;
      },
      &result_reply);

  client_->IsMounted(::user_data_auth::IsMountedRequest(), std::move(callback));
  base::RunLoop().RunUntilIdle();
  ASSERT_NE(result_reply, std::nullopt);
  EXPECT_TRUE(result_reply.value().is_mounted());
  EXPECT_FALSE(result_reply.value().is_ephemeral_mount());
}

TEST_F(UserDataAuthClientTest, IsMountedInvalidProtobuf) {
  shall_message_parsing_fail_ = true;
  std::optional<::user_data_auth::IsMountedReply> result_reply =
      ::user_data_auth::IsMountedReply();
  auto callback = base::BindOnce(
      [](std::optional<::user_data_auth::IsMountedReply>* result_reply,
         std::optional<::user_data_auth::IsMountedReply> reply) {
        *result_reply = reply;
      },
      &result_reply);

  client_->IsMounted(::user_data_auth::IsMountedRequest(), std::move(callback));
  base::RunLoop().RunUntilIdle();
  ASSERT_EQ(result_reply, std::nullopt);
}

TEST_F(UserDataAuthClientTest, Unmount) {
  expected_unmount_reply_.set_error(
      user_data_auth::CryptohomeErrorCode::CRYPTOHOME_ERROR_TPM_DEFEND_LOCK);
  std::optional<::user_data_auth::UnmountReply> result_reply;

  client_->Unmount(::user_data_auth::UnmountRequest(),
                   CreateCopyCallback(&result_reply));
  base::RunLoop().RunUntilIdle();
  ASSERT_NE(result_reply, std::nullopt);
  EXPECT_TRUE(ProtobufEquals(result_reply.value(), expected_unmount_reply_));
}

TEST_F(UserDataAuthClientTest, Remove) {
  expected_remove_reply_.set_error(
      user_data_auth::CryptohomeErrorCode::CRYPTOHOME_ERROR_TPM_DEFEND_LOCK);
  std::optional<::user_data_auth::RemoveReply> result_reply;

  client_->Remove(::user_data_auth::RemoveRequest(),
                  CreateCopyCallback(&result_reply));
  base::RunLoop().RunUntilIdle();
  ASSERT_NE(result_reply, std::nullopt);
  EXPECT_TRUE(ProtobufEquals(result_reply.value(), expected_remove_reply_));
}

TEST_F(UserDataAuthClientTest, StartMigrateToDircrypto) {
  expected_start_migrate_to_dircrypto_reply_.set_error(
      user_data_auth::CryptohomeErrorCode::CRYPTOHOME_ERROR_TPM_DEFEND_LOCK);
  std::optional<::user_data_auth::StartMigrateToDircryptoReply> result_reply;

  client_->StartMigrateToDircrypto(
      ::user_data_auth::StartMigrateToDircryptoRequest(),
      CreateCopyCallback(&result_reply));
  base::RunLoop().RunUntilIdle();
  ASSERT_NE(result_reply, std::nullopt);
  EXPECT_TRUE(ProtobufEquals(result_reply.value(),
                             expected_start_migrate_to_dircrypto_reply_));
}

TEST_F(UserDataAuthClientTest, NeedsDircryptoMigration) {
  expected_needs_dircrypto_migration_reply_.set_error(
      user_data_auth::CryptohomeErrorCode::CRYPTOHOME_ERROR_TPM_DEFEND_LOCK);
  std::optional<::user_data_auth::NeedsDircryptoMigrationReply> result_reply;

  client_->NeedsDircryptoMigration(
      ::user_data_auth::NeedsDircryptoMigrationRequest(),
      CreateCopyCallback(&result_reply));
  base::RunLoop().RunUntilIdle();
  ASSERT_NE(result_reply, std::nullopt);
  EXPECT_TRUE(ProtobufEquals(result_reply.value(),
                             expected_needs_dircrypto_migration_reply_));
}

TEST_F(UserDataAuthClientTest, GetSupportedKeyPolicies) {
  expected_get_supported_key_policies_reply_
      .set_low_entropy_credentials_supported(true);
  std::optional<::user_data_auth::GetSupportedKeyPoliciesReply> result_reply;

  client_->GetSupportedKeyPolicies(
      ::user_data_auth::GetSupportedKeyPoliciesRequest(),
      CreateCopyCallback(&result_reply));
  base::RunLoop().RunUntilIdle();
  ASSERT_NE(result_reply, std::nullopt);
  EXPECT_TRUE(ProtobufEquals(result_reply.value(),
                             expected_get_supported_key_policies_reply_));
}

TEST_F(UserDataAuthClientTest, GetAccountDiskUsage) {
  expected_get_account_disk_usage_reply_.set_error(
      user_data_auth::CryptohomeErrorCode::CRYPTOHOME_ERROR_TPM_DEFEND_LOCK);
  std::optional<::user_data_auth::GetAccountDiskUsageReply> result_reply;

  client_->GetAccountDiskUsage(::user_data_auth::GetAccountDiskUsageRequest(),
                               CreateCopyCallback(&result_reply));
  base::RunLoop().RunUntilIdle();
  ASSERT_NE(result_reply, std::nullopt);
  EXPECT_TRUE(ProtobufEquals(result_reply.value(),
                             expected_get_account_disk_usage_reply_));
}

TEST_F(UserDataAuthClientTest, StartAuthSession) {
  expected_start_auth_session_reply_.set_error(
      user_data_auth::CryptohomeErrorCode::CRYPTOHOME_ERROR_TPM_DEFEND_LOCK);
  std::optional<::user_data_auth::StartAuthSessionReply> result_reply;

  client_->StartAuthSession(::user_data_auth::StartAuthSessionRequest(),
                            CreateCopyCallback(&result_reply));
  base::RunLoop().RunUntilIdle();
  ASSERT_NE(result_reply, std::nullopt);
  EXPECT_TRUE(
      ProtobufEquals(result_reply.value(), expected_start_auth_session_reply_));
}

TEST_F(UserDataAuthClientTest, LowDiskSpaceSignal) {
  constexpr uint64_t kFreeSpace1 = 0x1234567890123ULL;
  constexpr uint64_t kFreeSpace2 = 0xFFFF9876ULL;

  TestObserver observer;
  client_->AddObserver(&observer);

  ::user_data_auth::LowDiskSpace status;
  status.set_disk_free_bytes(kFreeSpace1);

  // Basic validity check, emit a signal and check.
  EmitLowDiskSpaceSignal(status);
  EXPECT_EQ(observer.low_disk_space_count(), 1);
  EXPECT_EQ(observer.last_low_disk_space().disk_free_bytes(), kFreeSpace1);

  // Try again to see nothing is stuck.
  status.set_disk_free_bytes(kFreeSpace2);
  EmitLowDiskSpaceSignal(status);
  EXPECT_EQ(observer.low_disk_space_count(), 2);
  EXPECT_EQ(observer.last_low_disk_space().disk_free_bytes(), kFreeSpace2);

  // Remove the observer to check that it no longer gets triggered.
  client_->RemoveObserver(&observer);
  EmitLowDiskSpaceSignal(status);
  EXPECT_EQ(observer.low_disk_space_count(), 2);
}

TEST_F(UserDataAuthClientTest, DircryptoMigrationProgressSignal) {
  // Prepare the test constants.
  constexpr uint64_t kTotalBytes = 0x1234567890123ULL;
  ::user_data_auth::DircryptoMigrationProgress progress1, progress2;
  progress1.set_status(::user_data_auth::DircryptoMigrationStatus::
                           DIRCRYPTO_MIGRATION_IN_PROGRESS);
  progress1.set_current_bytes(12345);
  progress1.set_total_bytes(kTotalBytes);
  progress2.set_status(
      ::user_data_auth::DircryptoMigrationStatus::DIRCRYPTO_MIGRATION_SUCCESS);
  progress2.set_current_bytes(kTotalBytes);
  progress2.set_total_bytes(kTotalBytes);

  TestObserver observer;
  client_->AddObserver(&observer);

  // Basic validity check, emit a signal and check.
  EmitDircryptoMigrationProgressSignal(progress1);
  EXPECT_EQ(observer.dircrypto_progress_count(), 1);
  EXPECT_TRUE(ProtobufEquals(observer.last_dircrypto_progress(), progress1));

  // Try again to see nothing is stuck.
  EmitDircryptoMigrationProgressSignal(progress2);
  EXPECT_EQ(observer.dircrypto_progress_count(), 2);
  EXPECT_TRUE(ProtobufEquals(observer.last_dircrypto_progress(), progress2));

  // Remove the observer to check that it no longer gets triggered.
  client_->RemoveObserver(&observer);
  EmitDircryptoMigrationProgressSignal(progress1);
  EXPECT_EQ(observer.dircrypto_progress_count(), 2);
}

TEST_F(UserDataAuthClientTest, PrepareAuthFactorForAddProgressSignal) {
  TestFingerprintObserver observer;
  client_->AddPrepareAuthFactorProgressObserver(&observer);

  ::user_data_auth::PrepareAuthFactorProgress progress1 =
      PrepareFpAuthFactorForAdd(50);
  ::user_data_auth::PrepareAuthFactorProgress progress2 =
      PrepareFpAuthFactorForAdd(100);

  // Basic validity check, emit a signal and check.
  EmitPrepareAuthFactorProgressSignal(progress1);
  EXPECT_EQ(observer.enroll_progress_count(), 1);
  EXPECT_EQ(
      observer.last_enroll_progress().fingerprint_progress().percent_complete(),
      50);
  EXPECT_EQ(observer.last_enroll_progress().done(), false);

  // Try again to see nothing is stuck.
  EmitPrepareAuthFactorProgressSignal(progress2);
  EXPECT_EQ(observer.enroll_progress_count(), 2);
  EXPECT_EQ(
      observer.last_enroll_progress().fingerprint_progress().percent_complete(),
      100);
  EXPECT_EQ(observer.last_enroll_progress().done(), true);

  // Remove the observer to check that it no longer gets triggered.
  client_->RemovePrepareAuthFactorProgressObserver(&observer);
  EmitPrepareAuthFactorProgressSignal(progress2);
  EXPECT_EQ(observer.enroll_progress_count(), 2);
}

TEST_F(UserDataAuthClientTest, PrepareAuthFactorForAuthenticateProgressSignal) {
  TestFingerprintObserver observer;
  client_->AddPrepareAuthFactorProgressObserver(&observer);

  ::user_data_auth::PrepareAuthFactorProgress progress1 =
      PrepareFpAuthFactorForAuth(
          ::user_data_auth::FINGERPRINT_SCAN_RESULT_SUCCESS);
  ::user_data_auth::PrepareAuthFactorProgress progress2 =
      PrepareFpAuthFactorForAuth(
          ::user_data_auth::FINGERPRINT_SCAN_RESULT_LOCKOUT);

  // Basic validity check, emit a signal and check.
  EmitPrepareAuthFactorProgressSignal(progress1);
  EXPECT_EQ(observer.auth_scan_done_count(), 1);
  EXPECT_EQ(observer.last_auth_scan_done().scan_result().fingerprint_result(),
            ::user_data_auth::FINGERPRINT_SCAN_RESULT_SUCCESS);

  // Try again to see nothing is stuck.
  EmitPrepareAuthFactorProgressSignal(progress2);
  EXPECT_EQ(observer.auth_scan_done_count(), 2);
  EXPECT_EQ(observer.last_auth_scan_done().scan_result().fingerprint_result(),
            ::user_data_auth::FINGERPRINT_SCAN_RESULT_LOCKOUT);

  // Remove the observer to check that it no longer gets triggered.
  client_->RemovePrepareAuthFactorProgressObserver(&observer);
  EmitPrepareAuthFactorProgressSignal(progress2);
  EXPECT_EQ(observer.auth_scan_done_count(), 2);
}

TEST_F(UserDataAuthClientTest, AuthFactorStatusUpdateSignal) {
  TestAuthFactorStatusUpdateObserver observer;
  client_->AddAuthFactorStatusUpdateObserver(&observer);

  ::user_data_auth::AuthFactorStatusUpdate update1;
  update1.set_broadcast_id("id1");
  update1.mutable_auth_factor_with_status()->mutable_auth_factor()->set_type(
      ::user_data_auth::AUTH_FACTOR_TYPE_PASSWORD);
  update1.mutable_auth_factor_with_status()->mutable_auth_factor()->set_label(
      "password");

  // Basic validity check, emit a signal and check.
  EmitAuthFactorStatusUpdateSignal(update1);
  EXPECT_EQ(observer.last_broadcast_id(), "id1");
  EXPECT_EQ(observer.last_auth_factor_with_status().auth_factor().label(),
            "password");
  EXPECT_EQ(observer.last_auth_factor_with_status().auth_factor().type(),
            ::user_data_auth::AUTH_FACTOR_TYPE_PASSWORD);

  // Try again to see nothing is stuck.
  ::user_data_auth::AuthFactorStatusUpdate update2;
  update2.set_broadcast_id("id2");
  update2.mutable_auth_factor_with_status()->mutable_auth_factor()->set_type(
      ::user_data_auth::AUTH_FACTOR_TYPE_PIN);
  update2.mutable_auth_factor_with_status()->mutable_auth_factor()->set_label(
      "pin");
  EmitAuthFactorStatusUpdateSignal(update2);
  EXPECT_EQ(observer.last_broadcast_id(), "id2");
  EXPECT_EQ(observer.last_auth_factor_with_status().auth_factor().label(),
            "pin");
  EXPECT_EQ(observer.last_auth_factor_with_status().auth_factor().type(),
            ::user_data_auth::AUTH_FACTOR_TYPE_PIN);

  // Remove the observer to check that it no longer gets triggered.
  client_->RemoveAuthFactorStatusUpdateObserver(&observer);
  EmitAuthFactorStatusUpdateSignal(update1);
  EXPECT_EQ(observer.last_broadcast_id(), "id2");
}

}  // namespace ash