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

#include <memory>
#include <optional>

#include "ash/constants/ash_features.h"
#include "base/feature_list.h"
#include "base/functional/bind.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/task_environment.h"
#include "base/values.h"
#include "chromeos/ash/components/dbus/dbus_thread_manager.h"
#include "chromeos/ash/components/dbus/shill/fake_shill_device_client.h"
#include "chromeos/ash/components/dbus/shill/shill_clients.h"
#include "chromeos/ash/components/dbus/shill/shill_manager_client.h"
#include "chromeos/ash/components/network/cellular_metrics_logger.h"
#include "chromeos/ash/components/network/network_device_handler_impl.h"
#include "chromeos/ash/components/network/network_handler.h"
#include "chromeos/ash/components/network/network_handler_callbacks.h"
#include "chromeos/ash/components/network/network_handler_test_helper.h"
#include "chromeos/ash/components/network/network_state_handler.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/cros_system_api/dbus/service_constants.h"
#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"

namespace ash {

namespace {

const char kDefaultCellularDevicePath[] = "stub_cellular_device";
const char kUnknownCellularDevicePath[] = "unknown_cellular_device";
const char kDefaultWifiDevicePath[] = "stub_wifi_device";
const char kResultFailure[] = "failure";
const char kResultSuccess[] = "success";
const char kDefaultPin[] = "1111";

}  // namespace

class NetworkDeviceHandlerTest : public testing::Test {
 public:
  NetworkDeviceHandlerTest()
      : task_environment_(
            base::test::SingleThreadTaskEnvironment::MainThreadType::UI) {}

  NetworkDeviceHandlerTest(const NetworkDeviceHandlerTest&) = delete;
  NetworkDeviceHandlerTest& operator=(const NetworkDeviceHandlerTest&) = delete;

  ~NetworkDeviceHandlerTest() override = default;

  void SetUp() override {
    shill_clients::InitializeFakes();
    fake_device_client_ = ShillDeviceClient::Get();
    fake_device_client_->GetTestInterface()->ClearDevices();

    network_handler_test_helper_ = std::make_unique<NetworkHandlerTestHelper>();

    network_state_handler_ = NetworkStateHandler::InitializeForTest();
    NetworkDeviceHandlerImpl* device_handler = new NetworkDeviceHandlerImpl;
    device_handler->Init(network_state_handler_.get());
    network_device_handler_.reset(device_handler);

    // Add devices after handlers have been initialized.
    ShillDeviceClient::TestInterface* device_test =
        fake_device_client_->GetTestInterface();
    device_test->AddDevice(kDefaultCellularDevicePath, shill::kTypeCellular,
                           "cellular1");
    device_test->AddDevice(kDefaultWifiDevicePath, shill::kTypeWifi, "wifi1");

    base::Value::List test_ip_configs;
    test_ip_configs.Append("ip_config1");
    device_test->SetDeviceProperty(kDefaultWifiDevicePath,
                                   shill::kIPConfigsProperty,
                                   base::Value(std::move(test_ip_configs)),
                                   /*notify_changed=*/true);

    base::RunLoop().RunUntilIdle();
  }

  void TearDown() override {
    network_state_handler_->Shutdown();
    network_handler_test_helper_.reset();
    network_device_handler_.reset();
    network_state_handler_.reset();
    shill_clients::Shutdown();
  }

  base::OnceClosure GetSuccessCallback() {
    return base::BindOnce(&NetworkDeviceHandlerTest::SuccessCallback,
                          base::Unretained(this));
  }

  network_handler::ErrorCallback GetErrorCallback() {
    return base::BindOnce(&NetworkDeviceHandlerTest::ErrorCallback,
                          base::Unretained(this));
  }

  void ErrorCallback(const std::string& error_name) {
    VLOG(1) << "ErrorCallback: " << error_name;
    result_ = error_name;
  }

  void SuccessCallback() { result_ = kResultSuccess; }

  void GetPropertiesCallback(const std::string& device_path,
                             std::optional<base::Value::Dict> properties) {
    if (!properties) {
      result_ = kResultFailure;
      return;
    }
    result_ = kResultSuccess;
    properties_ = std::move(properties.value());
  }

  void StringSuccessCallback(const std::string& result) {
    VLOG(1) << "StringSuccessCallback: " << result;
    result_ = result;
  }

  void GetDeviceProperties(const std::string& device_path,
                           const std::string& expected_result) {
    network_device_handler_->GetDeviceProperties(
        device_path,
        base::BindOnce(&NetworkDeviceHandlerTest::GetPropertiesCallback,
                       base::Unretained(this)));
    base::RunLoop().RunUntilIdle();
    ASSERT_EQ(expected_result, result_);
  }

  void ExpectDeviceProperty(const std::string& device_path,
                            const std::string& property_name,
                            const std::string& expected_value) {
    GetDeviceProperties(device_path, kResultSuccess);
    std::string* value = properties_.FindString(property_name);
    ASSERT_NE(value, nullptr);
    ASSERT_EQ(*value, expected_value);
  }

 protected:
  base::test::SingleThreadTaskEnvironment task_environment_;
  std::string result_;
  raw_ptr<ShillDeviceClient, DanglingUntriaged> fake_device_client_ = nullptr;
  std::unique_ptr<NetworkDeviceHandler> network_device_handler_;
  std::unique_ptr<NetworkStateHandler> network_state_handler_;
  std::unique_ptr<NetworkHandlerTestHelper> network_handler_test_helper_;
  base::Value::Dict properties_;
};

TEST_F(NetworkDeviceHandlerTest, GetDeviceProperties) {
  GetDeviceProperties(kDefaultWifiDevicePath, kResultSuccess);
  std::string* type = properties_.FindString(shill::kTypeProperty);
  ASSERT_TRUE(type);
  EXPECT_EQ(shill::kTypeWifi, *type);
}

TEST_F(NetworkDeviceHandlerTest, SetDeviceProperty) {
  // Set the shill::kScanIntervalProperty to true. The call
  // should succeed and the value should be set.
  network_device_handler_->SetDeviceProperty(
      kDefaultCellularDevicePath, shill::kScanIntervalProperty, base::Value(1),
      GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(kResultSuccess, result_);

  // GetDeviceProperties should return the value set by SetDeviceProperty.
  GetDeviceProperties(kDefaultCellularDevicePath, kResultSuccess);

  std::optional<int> interval =
      properties_.FindInt(shill::kScanIntervalProperty);
  EXPECT_TRUE(interval.has_value());
  EXPECT_EQ(1, interval.value());

  // Repeat the same with value false.
  network_device_handler_->SetDeviceProperty(
      kDefaultCellularDevicePath, shill::kScanIntervalProperty, base::Value(2),
      GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(kResultSuccess, result_);

  GetDeviceProperties(kDefaultCellularDevicePath, kResultSuccess);

  interval = properties_.FindInt(shill::kScanIntervalProperty);
  EXPECT_TRUE(interval.has_value());
  EXPECT_EQ(2, interval.value());

  // Set property on an invalid path.
  network_device_handler_->SetDeviceProperty(
      kUnknownCellularDevicePath, shill::kScanIntervalProperty, base::Value(1),
      GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(NetworkDeviceHandler::kErrorDeviceMissing, result_);

  // Setting a owner-protected device property through SetDeviceProperty must
  // fail.
  network_device_handler_->SetDeviceProperty(
      kDefaultCellularDevicePath, shill::kCellularPolicyAllowRoamingProperty,
      base::Value(true), GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_NE(kResultSuccess, result_);
}

TEST_F(NetworkDeviceHandlerTest, CellularAllowRoaming) {
  ShillDeviceClient::TestInterface* device_test =
      fake_device_client_->GetTestInterface();
  device_test->SetDeviceProperty(kDefaultCellularDevicePath,
                                 shill::kCellularPolicyAllowRoamingProperty,
                                 base::Value(false), /*notify_changed=*/true);

  network_device_handler_->SetCellularPolicyAllowRoaming(true);
  base::RunLoop().RunUntilIdle();

  GetDeviceProperties(kDefaultCellularDevicePath, kResultSuccess);

  std::optional<bool> policy_allow_roaming =
      properties_.FindBool(shill::kCellularPolicyAllowRoamingProperty);
  EXPECT_TRUE(policy_allow_roaming.has_value());
  EXPECT_TRUE(policy_allow_roaming.value());

  network_device_handler_->SetCellularPolicyAllowRoaming(false);
  base::RunLoop().RunUntilIdle();

  GetDeviceProperties(kDefaultCellularDevicePath, kResultSuccess);

  policy_allow_roaming =
      properties_.FindBool(shill::kCellularPolicyAllowRoamingProperty);
  EXPECT_TRUE(policy_allow_roaming.has_value());
  EXPECT_FALSE(policy_allow_roaming.value());
}

TEST_F(NetworkDeviceHandlerTest,
       ResetUsbEthernetMacAddressSourceForSecondaryUsbDevices) {
  ShillDeviceClient::TestInterface* device_test =
      fake_device_client_->GetTestInterface();

  constexpr char kSource[] = "some_source1";

  constexpr char kUsbEthernetDevicePath1[] = "usb_ethernet_device1";
  device_test->AddDevice(kUsbEthernetDevicePath1, shill::kTypeEthernet, "eth1");
  device_test->SetDeviceProperty(
      kUsbEthernetDevicePath1, shill::kDeviceBusTypeProperty,
      base::Value(shill::kDeviceBusTypeUsb), /*notify_changed=*/true);
  device_test->SetDeviceProperty(kUsbEthernetDevicePath1,
                                 shill::kLinkUpProperty, base::Value(true),
                                 /*notify_changed=*/true);
  device_test->SetDeviceProperty(kUsbEthernetDevicePath1,
                                 shill::kUsbEthernetMacAddressSourceProperty,
                                 base::Value("source_to_override1"),
                                 /*notify_changed=*/true);
  constexpr char kUsbEthernetDevicePath2[] = "usb_ethernet_device2";
  device_test->AddDevice(kUsbEthernetDevicePath2, shill::kTypeEthernet, "eth2");
  device_test->SetDeviceProperty(
      kUsbEthernetDevicePath2, shill::kDeviceBusTypeProperty,
      base::Value(shill::kDeviceBusTypeUsb), /*notify_changed=*/true);
  device_test->SetDeviceProperty(kUsbEthernetDevicePath2,
                                 shill::kLinkUpProperty, base::Value(true),
                                 /*notify_changed=*/true);
  device_test->SetDeviceProperty(kUsbEthernetDevicePath2,
                                 shill::kUsbEthernetMacAddressSourceProperty,
                                 base::Value(kSource),
                                 /*notify_changed=*/true);
  constexpr char kUsbEthernetDevicePath3[] = "usb_ethernet_device3";
  device_test->AddDevice(kUsbEthernetDevicePath3, shill::kTypeEthernet, "eth3");
  device_test->SetDeviceProperty(
      kUsbEthernetDevicePath3, shill::kDeviceBusTypeProperty,
      base::Value(shill::kDeviceBusTypeUsb), /*notify_changed=*/true);
  device_test->SetDeviceProperty(kUsbEthernetDevicePath3,
                                 shill::kLinkUpProperty, base::Value(true),
                                 /*notify_changed=*/true);
  device_test->SetDeviceProperty(kUsbEthernetDevicePath3,
                                 shill::kUsbEthernetMacAddressSourceProperty,
                                 base::Value("source_to_override2"),
                                 /*notify_changed=*/true);

  network_device_handler_->SetUsbEthernetMacAddressSource(kSource);
  base::RunLoop().RunUntilIdle();

  // Expect to reset source property for eth1 and eth3 since eth2 already has
  // needed source value.
  ASSERT_NO_FATAL_FAILURE(ExpectDeviceProperty(
      kUsbEthernetDevicePath1, shill::kUsbEthernetMacAddressSourceProperty,
      "usb_adapter_mac"));
  ASSERT_NO_FATAL_FAILURE(ExpectDeviceProperty(
      kUsbEthernetDevicePath2, shill::kUsbEthernetMacAddressSourceProperty,
      kSource));
  ASSERT_NO_FATAL_FAILURE(ExpectDeviceProperty(
      kUsbEthernetDevicePath3, shill::kUsbEthernetMacAddressSourceProperty,
      "usb_adapter_mac"));
}

TEST_F(NetworkDeviceHandlerTest, UsbEthernetMacAddressSourceNotSupported) {
  ShillDeviceClient::TestInterface* device_test =
      fake_device_client_->GetTestInterface();

  constexpr char kSourceToOverride[] = "source_to_override";
  constexpr char kUsbEthernetDevicePath[] = "usb_ethernet_device1";
  device_test->AddDevice(kUsbEthernetDevicePath, shill::kTypeEthernet, "eth1");
  device_test->SetDeviceProperty(
      kUsbEthernetDevicePath, shill::kDeviceBusTypeProperty,
      base::Value(shill::kDeviceBusTypeUsb), /*notify_changed=*/true);
  device_test->SetDeviceProperty(kUsbEthernetDevicePath, shill::kLinkUpProperty,
                                 base::Value(true),
                                 /*notify_changed=*/true);
  device_test->SetDeviceProperty(kUsbEthernetDevicePath,
                                 shill::kUsbEthernetMacAddressSourceProperty,
                                 base::Value(kSourceToOverride),
                                 /*notify_changed=*/true);
  device_test->SetUsbEthernetMacAddressSourceError(
      kUsbEthernetDevicePath, shill::kErrorResultNotSupported);

  network_device_handler_->SetUsbEthernetMacAddressSource("some_source1");
  base::RunLoop().RunUntilIdle();

  // Expect to do not change MAC address source property, because eth1 does not
  // support |some_source1|.
  ASSERT_NO_FATAL_FAILURE(ExpectDeviceProperty(
      kUsbEthernetDevicePath, shill::kUsbEthernetMacAddressSourceProperty,
      kSourceToOverride));

  constexpr char kSource2[] = "some_source2";
  device_test->SetUsbEthernetMacAddressSourceError(kUsbEthernetDevicePath, "");
  network_device_handler_->SetUsbEthernetMacAddressSource(kSource2);
  base::RunLoop().RunUntilIdle();

  // Expect to change MAC address source property, because eth1 supports
  // |some_source2|.
  ASSERT_NO_FATAL_FAILURE(ExpectDeviceProperty(
      kUsbEthernetDevicePath, shill::kUsbEthernetMacAddressSourceProperty,
      kSource2));
}

TEST_F(NetworkDeviceHandlerTest, UsbEthernetMacAddressSource) {
  ShillDeviceClient::TestInterface* device_test =
      fake_device_client_->GetTestInterface();

  constexpr char kUsbEthernetDevicePath1[] = "ubs_ethernet_device1";
  device_test->AddDevice(kUsbEthernetDevicePath1, shill::kTypeEthernet, "eth1");
  device_test->SetDeviceProperty(
      kUsbEthernetDevicePath1, shill::kDeviceBusTypeProperty,
      base::Value(shill::kDeviceBusTypeUsb), /*notify_changed=*/true);

  constexpr char kUsbEthernetDevicePath2[] = "usb_ethernet_device2";
  device_test->AddDevice(kUsbEthernetDevicePath2, shill::kTypeEthernet, "eth2");
  device_test->SetDeviceProperty(
      kUsbEthernetDevicePath2, shill::kDeviceBusTypeProperty,
      base::Value(shill::kDeviceBusTypeUsb), /*notify_changed=*/true);
  device_test->SetDeviceProperty(kUsbEthernetDevicePath2,
                                 shill::kAddressProperty,
                                 base::Value("abcdef123456"),
                                 /*notify_changed=*/true);
  device_test->SetDeviceProperty(kUsbEthernetDevicePath2,
                                 shill::kLinkUpProperty, base::Value(true),
                                 /*notify_changed=*/true);
  device_test->SetUsbEthernetMacAddressSourceError(
      kUsbEthernetDevicePath2, shill::kErrorResultNotSupported);

  constexpr char kUsbEthernetDevicePath3[] = "usb_ethernet_device3";
  device_test->AddDevice(kUsbEthernetDevicePath3, shill::kTypeEthernet, "eth3");
  device_test->SetDeviceProperty(
      kUsbEthernetDevicePath3, shill::kDeviceBusTypeProperty,
      base::Value(shill::kDeviceBusTypeUsb), /*notify_changed=*/true);
  device_test->SetDeviceProperty(kUsbEthernetDevicePath3,
                                 shill::kAddressProperty,
                                 base::Value("123456abcdef"),
                                 /*notify_changed=*/true);
  device_test->SetDeviceProperty(kUsbEthernetDevicePath3,
                                 shill::kLinkUpProperty, base::Value(true),
                                 /*notify_changed=*/true);

  constexpr char kPciEthernetDevicePath[] = "pci_ethernet_device";
  device_test->AddDevice(kPciEthernetDevicePath, shill::kTypeEthernet, "eth4");
  device_test->SetDeviceProperty(
      kPciEthernetDevicePath, shill::kDeviceBusTypeProperty,
      base::Value(shill::kDeviceBusTypePci), /*notify_changed=*/true);

  // Expect property change on eth3, because:
  //   1) eth2 device is connected to the internet, but does not support MAC
  //      address change;
  //   2) eth3 device is connected to the internet and supports MAC address
  //      change.
  constexpr char kSource1[] = "some_source1";
  network_device_handler_->SetUsbEthernetMacAddressSource(kSource1);
  base::RunLoop().RunUntilIdle();

  ASSERT_NO_FATAL_FAILURE(ExpectDeviceProperty(
      kUsbEthernetDevicePath3, shill::kUsbEthernetMacAddressSourceProperty,
      kSource1));

  // Expect property change on eth3, because device is connected to the
  // internet.
  const char* kSource2 = shill::kUsbEthernetMacAddressSourceBuiltinAdapterMac;
  network_device_handler_->SetUsbEthernetMacAddressSource(kSource2);
  base::RunLoop().RunUntilIdle();

  ASSERT_NO_FATAL_FAILURE(ExpectDeviceProperty(
      kUsbEthernetDevicePath3, shill::kUsbEthernetMacAddressSourceProperty,
      kSource2));

  // Expect property change back to "usb_adapter_mac" on eth3, because device
  // is not connected to the internet.
  device_test->SetDeviceProperty(kUsbEthernetDevicePath3,
                                 shill::kLinkUpProperty, base::Value(false),
                                 /*notify_changed=*/true);
  base::RunLoop().RunUntilIdle();

  ASSERT_NO_FATAL_FAILURE(ExpectDeviceProperty(
      kUsbEthernetDevicePath3, shill::kUsbEthernetMacAddressSourceProperty,
      "usb_adapter_mac"));

  // Expect property change back to "usb_adapter_mac" on eth1, because both
  // builtin PCI eth4 and eth1 have the same MAC address and connected to the
  // internet.
  device_test->SetDeviceProperty(kUsbEthernetDevicePath1,
                                 shill::kLinkUpProperty, base::Value(true),
                                 /*notify_changed=*/true);
  device_test->SetDeviceProperty(kPciEthernetDevicePath, shill::kLinkUpProperty,
                                 base::Value(true),
                                 /*notify_changed=*/true);
  base::RunLoop().RunUntilIdle();

  ASSERT_NO_FATAL_FAILURE(ExpectDeviceProperty(
      kUsbEthernetDevicePath1, shill::kUsbEthernetMacAddressSourceProperty,
      "usb_adapter_mac"));

  // Expect property change on eth1, because device is connected to the
  // internet and builtin PCI eth4 and eth1 have different MAC addresses.
  constexpr char kSource3[] = "some_source3";
  network_device_handler_->SetUsbEthernetMacAddressSource(kSource3);
  base::RunLoop().RunUntilIdle();

  ASSERT_NO_FATAL_FAILURE(ExpectDeviceProperty(
      kUsbEthernetDevicePath1, shill::kUsbEthernetMacAddressSourceProperty,
      kSource3));
}

TEST_F(NetworkDeviceHandlerTest, RequirePin) {
  base::HistogramTester histogram_tester;

  // Test that the success callback gets called.
  network_device_handler_->RequirePin(kDefaultCellularDevicePath, true,
                                      kDefaultPin, GetSuccessCallback(),
                                      GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(kResultSuccess, result_);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kSimPinRequireLockSuccessHistogram, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kSimPinRequireLockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 1);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kRequirePinSuccessSimPinLockPolicyHistogram, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRequirePinSuccessSimPinLockPolicyHistogram, true,
      1);

  // Test that the shill error propagates to the error callback.
  network_device_handler_->RequirePin(kUnknownCellularDevicePath, true,
                                      kDefaultPin, GetSuccessCallback(),
                                      GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(NetworkDeviceHandler::kErrorDeviceMissing, result_);

  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kSimPinRequireLockSuccessHistogram, 2);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kSimPinRequireLockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 1);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kRequirePinSuccessSimPinLockPolicyHistogram, 2);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRequirePinSuccessSimPinLockPolicyHistogram, true,
      2);
}

TEST_F(NetworkDeviceHandlerTest, EnterPinOnManagedDevice) {
  base::HistogramTester histogram_tester;

  NetworkHandler::Get()->SetIsEnterpriseManaged(true);
  network_device_handler_->SetAllowCellularSimLock(
      /*allow_cellular_sim_lock=*/true);

  // Test that the success metrics get emitted for managed devices.
  network_device_handler_->EnterPin(kDefaultCellularDevicePath, kDefaultPin,
                                    GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kManagedSimPinUnlockSuccessHistogram, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kManagedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kUnrestrictedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRestrictedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 0);

  // Test that the shill error propagates to the error callback.
  network_device_handler_->EnterPin(kUnknownCellularDevicePath, kDefaultPin,
                                    GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(NetworkDeviceHandler::kErrorDeviceMissing, result_);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kManagedSimPinUnlockSuccessHistogram, 2);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kManagedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kUnrestrictedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRestrictedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 0);

  network_device_handler_->SetAllowCellularSimLock(
      /*allow_cellular_sim_lock=*/false);

  network_device_handler_->EnterPin(kDefaultCellularDevicePath, kDefaultPin,
                                    GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRestrictedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 1);

  network_device_handler_->EnterPin(kUnknownCellularDevicePath, kDefaultPin,
                                    GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRestrictedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 1);
}

TEST_F(NetworkDeviceHandlerTest, EnterPinOnUnmanagedDevice) {
  base::HistogramTester histogram_tester;

  NetworkHandler::Get()->SetIsEnterpriseManaged(false);

  // Test that the success callback gets called.
  network_device_handler_->EnterPin(kDefaultCellularDevicePath, kDefaultPin,
                                    GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(kResultSuccess, result_);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kUnmanagedSimPinUnlockSuccessHistogram, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kUnmanagedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kUnrestrictedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 0);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRestrictedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 0);

  // Test that the shill error propagates to the error callback.
  network_device_handler_->EnterPin(kUnknownCellularDevicePath, kDefaultPin,
                                    GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(NetworkDeviceHandler::kErrorDeviceMissing, result_);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kUnmanagedSimPinUnlockSuccessHistogram, 2);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kUnmanagedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kUnrestrictedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 0);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRestrictedSimPinUnlockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 0);
}

TEST_F(NetworkDeviceHandlerTest, UnblockPinOnManagedDevice) {
  base::HistogramTester histogram_tester;

  const char kPuk[] = "12345678";
  const char kPin[] = "1234";

  NetworkHandler::Get()->SetIsEnterpriseManaged(true);
  network_device_handler_->SetAllowCellularSimLock(
      /*allow_cellular_sim_lock=*/true);

  // Test that the success metrics get emitted for managed devices.
  network_device_handler_->UnblockPin(kDefaultCellularDevicePath, kPin, kPuk,
                                      GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kManagedSimPinUnblockSuccessHistogram, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kManagedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kUnrestrictedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRestrictedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 0);

  // Test that the error metrics get emitted for managed devices.
  network_device_handler_->UnblockPin(kUnknownCellularDevicePath, kPin, kPuk,
                                      GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kManagedSimPinUnblockSuccessHistogram, 2);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kManagedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kUnrestrictedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRestrictedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 0);

  network_device_handler_->SetAllowCellularSimLock(
      /*allow_cellular_sim_lock=*/false);
  network_device_handler_->UnblockPin(kDefaultCellularDevicePath, kPin, kPuk,
                                      GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRestrictedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 1);

  network_device_handler_->UnblockPin(kUnknownCellularDevicePath, kPin, kPuk,
                                      GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRestrictedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 1);
}

TEST_F(NetworkDeviceHandlerTest, UnblockPinOnUnmanagedDevice) {
  base::HistogramTester histogram_tester;

  const char kPuk[] = "12345678";
  const char kPin[] = "1234";

  NetworkHandler::Get()->SetIsEnterpriseManaged(false);

  // Test that the success callback gets called.
  network_device_handler_->UnblockPin(kDefaultCellularDevicePath, kPin, kPuk,
                                      GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(kResultSuccess, result_);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kUnmanagedSimPinUnblockSuccessHistogram, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kUnmanagedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kUnrestrictedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 0);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRestrictedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 0);

  // Test that the shill error propagates to the error callback.
  network_device_handler_->UnblockPin(kUnknownCellularDevicePath, kPin, kPuk,
                                      GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(NetworkDeviceHandler::kErrorDeviceMissing, result_);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kUnmanagedSimPinUnblockSuccessHistogram, 2);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kUnmanagedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kUnrestrictedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 0);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRestrictedSimPinUnblockSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorDeviceMissing, 0);

  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kSimPinRemoveLockSuccessHistogram, 0);

  // Test that if SIM PIN locking is prohibited, PUK unblocking a SIM will
  // also disable the SIM PIN lock setting.
  network_device_handler_->SetAllowCellularSimLock(
      /*allow_cellular_sim_lock=*/false);
  network_device_handler_->UnblockPin(kDefaultCellularDevicePath, kPin, kPuk,
                                      GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kSimPinRemoveLockSuccessHistogram, 1);
}

TEST_F(NetworkDeviceHandlerTest, ChangePin) {
  base::HistogramTester histogram_tester;
  const char kNewPin[] = "1234";
  const char kIncorrectPin[] = "9999";

  fake_device_client_->GetTestInterface()->SetSimLocked(
      kDefaultCellularDevicePath, true);

  // Test that the success callback gets called.
  network_device_handler_->ChangePin(
      kDefaultCellularDevicePath, FakeShillDeviceClient::kDefaultSimPin,
      kNewPin, GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(kResultSuccess, result_);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kSimPinChangeSuccessHistogram, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kSimPinChangeSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kSuccess, 1);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kChangePinSuccessSimPinLockPolicyHistogram, 1);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kChangePinSuccessSimPinLockPolicyHistogram, true,
      1);

  // Test that the shill error propagates to the error callback.
  network_device_handler_->ChangePin(kDefaultCellularDevicePath, kIncorrectPin,
                                     kNewPin, GetSuccessCallback(),
                                     GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(NetworkDeviceHandler::kErrorIncorrectPin, result_);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kSimPinChangeSuccessHistogram, 2);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kSimPinChangeSuccessHistogram,
      CellularMetricsLogger::SimPinOperationResult::kErrorIncorrectPin, 1);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kChangePinSuccessSimPinLockPolicyHistogram, 2);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kChangePinSuccessSimPinLockPolicyHistogram, true,
      2);
}

TEST_F(NetworkDeviceHandlerTest, RequirePinBlockedByPolicy) {
  base::HistogramTester histogram_tester;

  network_device_handler_->SetAllowCellularSimLock(
      /*allow_cellular_sim_lock=*/false);

  // Test that the error callback gets called when attempting to require a PIN
  // lock.
  network_device_handler_->RequirePin(kDefaultCellularDevicePath, true,
                                      kDefaultPin, GetSuccessCallback(),
                                      GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(NetworkDeviceHandler::kErrorBlockedByPolicy, result_);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kSimPinRequireLockSuccessHistogram, 0);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kRequirePinSuccessSimPinLockPolicyHistogram, 0);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kRequirePinSuccessSimPinLockPolicyHistogram, true,
      0);

  // Test that the success callback gets called when removing a PIN lock.
  network_device_handler_->RequirePin(kDefaultCellularDevicePath, false,
                                      kDefaultPin, GetSuccessCallback(),
                                      GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(kResultSuccess, result_);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kSimPinRemoveLockSuccessHistogram, 1);
}

TEST_F(NetworkDeviceHandlerTest, ChangePinBlockedByPolicy) {
  base::HistogramTester histogram_tester;
  const char kNewPin[] = "1234";

  fake_device_client_->GetTestInterface()->SetSimLocked(
      kDefaultCellularDevicePath, true);

  network_device_handler_->SetAllowCellularSimLock(
      /*allow_cellular_sim_lock=*/false);

  // Test that the error callback gets called.
  network_device_handler_->ChangePin(
      kDefaultCellularDevicePath, FakeShillDeviceClient::kDefaultSimPin,
      kNewPin, GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(NetworkDeviceHandler::kErrorBlockedByPolicy, result_);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kSimPinChangeSuccessHistogram, 0);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kChangePinSuccessSimPinLockPolicyHistogram, 0);
  histogram_tester.ExpectBucketCount(
      CellularMetricsLogger::kChangePinSuccessSimPinLockPolicyHistogram, true,
      0);
}

TEST_F(NetworkDeviceHandlerTest, EnterPinWhenSimPinLockPolicyRestricted) {
  base::HistogramTester histogram_tester;

  fake_device_client_->GetTestInterface()->SetSimLocked(
      kDefaultCellularDevicePath, true);

  // Test that removing the PIN Lock requirement does not occur when the policy
  // is not applied.
  network_device_handler_->EnterPin(kDefaultCellularDevicePath, kDefaultPin,
                                    GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();

  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kSimPinRemoveLockSuccessHistogram, 0);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kUnmanagedSimPinUnlockSuccessHistogram, 1);

  network_device_handler_->SetAllowCellularSimLock(
      /*allow_cellular_sim_lock=*/false);

  // Test that removing the PIN Lock requirement does occur when the policy is
  // applied.
  network_device_handler_->EnterPin(kDefaultCellularDevicePath, kDefaultPin,
                                    GetSuccessCallback(), GetErrorCallback());
  base::RunLoop().RunUntilIdle();

  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kSimPinRemoveLockSuccessHistogram, 1);
  histogram_tester.ExpectTotalCount(
      CellularMetricsLogger::kUnmanagedSimPinUnlockSuccessHistogram, 2);
}
}  // namespace ash