// 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 "chrome/browser/ash/policy/networking/euicc_status_uploader.h"

#include <algorithm>

#include "ash/constants/ash_features.h"
#include "ash/constants/ash_pref_names.h"
#include "base/json/json_string_value_serializer.h"
#include "base/strings/stringprintf.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/values_test_util.h"
#include "chrome/test/base/testing_browser_process.h"
#include "chromeos/ash/components/dbus/shill/shill_manager_client.h"
#include "chromeos/ash/components/network/managed_cellular_pref_handler.h"
#include "chromeos/ash/components/network/managed_network_configuration_handler.h"
#include "chromeos/ash/components/network/network_handler_test_helper.h"
#include "chromeos/ash/components/network/network_ui_data.h"
#include "chromeos/ash/components/network/policy_util.h"
#include "chromeos/components/onc/onc_utils.h"
#include "components/policy/core/common/cloud/mock_cloud_policy_client.h"
#include "components/prefs/testing_pref_service.h"
#include "content/public/test/browser_task_environment.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"

namespace policy {

namespace {

class FakeCloudPolicyClient : public testing::NiceMock<MockCloudPolicyClient> {
 public:
  using UploadEuiccInfoCallbackHandler =
      base::RepeatingCallback<void(base::OnceCallback<void(bool)>)>;

  void SetHandler(UploadEuiccInfoCallbackHandler handler) {
    handler_ = handler;
  }
  void SetStatus(bool status) { status_ = status; }

  enterprise_management::UploadEuiccInfoRequest* GetLastRequest() {
    if (requests_.empty())
      return nullptr;
    return requests_.back().get();
  }

  int num_requests() const { return requests_.size(); }

 private:
  void UploadEuiccInfo(
      std::unique_ptr<enterprise_management::UploadEuiccInfoRequest> request,
      base::OnceCallback<void(bool)> callback) override {
    requests_.push_back(std::move(request));
    if (handler_) {
      handler_.Run(std::move(callback));
      return;
    }
    std::move(callback).Run(status_);
  }

  std::vector<std::unique_ptr<enterprise_management::UploadEuiccInfoRequest>>
      requests_;
  bool status_ = false;
  // This member is used to control how the callback is executed when
  // UploadEuiccInfo() is called.
  UploadEuiccInfoCallbackHandler handler_;
};

bool RequestsAreEqual(
    const enterprise_management::UploadEuiccInfoRequest& lhs,
    const enterprise_management::UploadEuiccInfoRequest& rhs) {
  const auto proj = [](const auto& profile) {
    return std::tie(profile.iccid(), profile.smdp_address());
  };
  return lhs.euicc_count() == rhs.euicc_count() &&
         std::ranges::equal(lhs.esim_profiles(), rhs.esim_profiles(),
                            std::equal_to<>(), proj, proj) &&
         lhs.clear_profile_list() == rhs.clear_profile_list();
}

const char kDmToken[] = "token";
const char kFakeObjectPath[] = "object-path";
const char kFakeEid[] = "12";
const char kEuiccStatusUploadResultHistogram[] =
    "Network.Cellular.ESim.Policy.EuiccStatusUploadResult";

const char kEuiccStatus_Empty[] =
    R"({
        "esim_profiles": [],
        "euicc_count": 0
       })";
const char kEuiccStatus_OneProfileWithMissingName[] =
    R"({
        "esim_profiles": [
          {
            "iccid": "iccid-1",
            "smdp_activation_code": "smdp-1"
          }
        ],
        "euicc_count": 1
       })";
const char kEuiccStatus_OneProfileWithEmptyActivationCode[] =
    R"({
        "esim_profiles": [],
        "euicc_count": 1
       })";
const char kEuiccStatus_OneProfile[] =
    R"({
        "esim_profiles": [
          {
            "iccid": "iccid-1",
            "network_name": "name-1",
            "smdp_activation_code": "smdp-1"
          }
        ],
        "euicc_count": 1
       })";
const char kEuiccStatus_TwoProfiles[] =
    R"({
        "esim_profiles": [
          {
            "iccid": "iccid-1",
            "network_name": "name-1",
            "smdp_activation_code": "smdp-1"
          },
          {
            "iccid": "iccid-2",
            "network_name": "name-2",
            "smdp_activation_code": "smdp-2"
          }
        ],
        "euicc_count": 2
       })";
const char kEuiccStatus_FourProfiles[] =
    R"({
        "esim_profiles": [
          {
            "iccid": "iccid-1",
            "network_name": "name-1",
            "smdp_activation_code": "smdp-1"
          },
          {
            "iccid": "iccid-2",
            "network_name": "name-2",
            "smdp_activation_code": "smdp-2"
          },
          {
            "iccid": "iccid-3",
            "network_name": "name-3",
            "smds_activation_code": "smds-3"
          },
          {
            "iccid": "iccid-4",
            "network_name": "name-4",
            "smds_activation_code": "smds-4"
          }
        ],
        "euicc_count": 3
       })";
const char kEuiccStatus_AfterReset[] =
    R"({
        "esim_profiles": [],
        "euicc_count": 4
      })";

const char kCellularServicePath0[] = "/service/cellular0";
const char kCellularServicePath1[] = "/service/cellular1";
const char kCellularServicePath2[] = "/service/cellular2";
const char kCellularServicePath3[] = "/service/cellular3";
const char kCellularProfilePath0[] = "/org/chromium/Hermes/Profile/0";
const char kCellularProfilePath1[] = "/org/chromium/Hermes/Profile/1";
const char kCellularProfilePath2[] = "/org/chromium/Hermes/Profile/2";
const char kCellularProfilePath3[] = "/org/chromium/Hermes/Profile/3";

struct FakeESimProfile {
  std::string profile_path;
  std::string service_path;
  std::string guid;
  std::string iccid;
  ash::policy_util::SmdxActivationCode::Type activation_code_type;
  std::string activation_code_value;
  std::string network_name;
  hermes::profile::State state;
  bool managed = true;
};
struct EuiccTestData {
  int euicc_count = 0;
  std::vector<FakeESimProfile> profiles;
};

const EuiccTestData kEuiccTestData_OneProfile = {
    1,
    {
        {kCellularProfilePath0, kCellularServicePath0, "guid-1", "iccid-1",
         ash::policy_util::SmdxActivationCode::Type::SMDP, "smdp-1", "name-1",
         hermes::profile::State::kActive, true},
    },
};
const EuiccTestData kEuiccTestData_OneProfileWithMissingName = {
    1,
    {
        {kCellularProfilePath0, kCellularServicePath0, "guid-1", "iccid-1",
         ash::policy_util::SmdxActivationCode::Type::SMDP, "smdp-1", "",
         hermes::profile::State::kActive, true},
    },
};
const EuiccTestData kEuiccTestData_OneProfileWithEmptyActivationCode = {
    1,
    {
        {kCellularProfilePath0, kCellularServicePath0, "guid-1", "iccid-1",
         ash::policy_util::SmdxActivationCode::Type::SMDP, "", "name-1",
         hermes::profile::State::kActive, true},
    },
};
const EuiccTestData kEuiccTestData_TwoProfiles = {
    2,
    {
        {kCellularProfilePath0, kCellularServicePath0, "guid-1", "iccid-1",
         ash::policy_util::SmdxActivationCode::Type::SMDP, "smdp-1", "name-1",
         hermes::profile::State::kActive, true},
        {kCellularProfilePath1, kCellularServicePath1, "guid-2", "iccid-2",
         ash::policy_util::SmdxActivationCode::Type::SMDP, "smdp-2", "name-2",
         hermes::profile::State::kInactive, true},
    },
};
const EuiccTestData kEuiccTestData_FourProfiles = {
    3,
    {
        {kCellularProfilePath0, kCellularServicePath0, "guid-1", "iccid-1",
         ash::policy_util::SmdxActivationCode::Type::SMDP, "smdp-1", "name-1",
         hermes::profile::State::kActive, true},
        {kCellularProfilePath1, kCellularServicePath1, "guid-2", "iccid-2",
         ash::policy_util::SmdxActivationCode::Type::SMDP, "smdp-2", "name-2",
         hermes::profile::State::kInactive, true},
        {kCellularProfilePath2, kCellularServicePath2, "guid-3", "iccid-3",
         ash::policy_util::SmdxActivationCode::Type::SMDS, "smds-3", "name-3",
         hermes::profile::State::kActive, true},
        {kCellularProfilePath3, kCellularServicePath3, "guid-4", "iccid-4",
         ash::policy_util::SmdxActivationCode::Type::SMDS, "smds-4", "name-4",
         hermes::profile::State::kInactive, true},
    },
};
const EuiccTestData kEuiccTestData_AfterReset = {4, {}};

std::string GetEid(int euicc_id) {
  return base::StringPrintf("%s%d", kFakeObjectPath, euicc_id);
}

std::string GetEuiccPath(int euicc_id) {
  return base::StringPrintf("%s%d", kFakeEid, euicc_id);
}

}  // namespace

class EuiccStatusUploaderTest : public testing::Test {
 public:

  void SetUp() override {
    helper_ = std::make_unique<ash::NetworkHandlerTestHelper>();

    EuiccStatusUploader::RegisterLocalStatePrefs(local_state_.registry());
    helper_->RegisterPrefs(nullptr, local_state_.registry());
    helper_->InitializePrefs(nullptr, &local_state_);
    SetPolicyClientIsRegistered(/*is_registered=*/true);
  }

  std::unique_ptr<EuiccStatusUploader> CreateStatusUploader(
      bool is_policy_fetched = true) {
    auto status_uploader = base::WrapUnique(new EuiccStatusUploader(
        &cloud_policy_client_, &local_state_,
        base::BindRepeating(&EuiccStatusUploaderTest::is_device_active,
                            base::Unretained(this))));
    if (is_policy_fetched) {
      SetPolicyFetched(status_uploader.get());
    }
    return status_uploader;
  }

  void SetPolicyClientIsRegistered(bool is_registered) {
    cloud_policy_client_.dm_token_ = is_registered ? kDmToken : std::string();
  }

  void SetPolicyFetched(EuiccStatusUploader* status_uploader) {
    status_uploader->OnPolicyFetched(&cloud_policy_client_);
  }

  void SetServerSuccessStatus(bool success) {
    cloud_policy_client_.SetStatus(success);
  }

  void SetPolicyClientHandler(
      FakeCloudPolicyClient::UploadEuiccInfoCallbackHandler handler) {
    cloud_policy_client_.SetHandler(std::move(handler));
  }

  const base::Value& GetStoredPref() {
    return local_state_.GetValue(
        EuiccStatusUploader::kLastUploadedEuiccStatusPref);
  }

  std::string GetStoredPrefString() {
    const base::Value& last_uploaded_pref = GetStoredPref();
    std::string result;
    JSONStringValueSerializer sz(&result);
    sz.Serialize(last_uploaded_pref);
    return result;
  }

  void UpdateUploader(EuiccStatusUploader* status_uploader) {
    (static_cast<ash::NetworkPolicyObserver*>(status_uploader))
        ->PoliciesApplied(/*userhash=*/std::string());
    status_uploader->FireRetryTimerIfExistsForTesting();
  }

  void SetupEuicc(int euicc_id = 0) {
    ash::HermesManagerClient::Get()->GetTestInterface()->AddEuicc(
        dbus::ObjectPath(GetEuiccPath(euicc_id)), GetEid(euicc_id),
        /*is_active=*/true, euicc_id);
  }

  void SetUpDeviceProfiles(const EuiccTestData& data) {

    // Create |data.euicc_count| fake EUICCs.
    ash::HermesManagerClient::Get()->GetTestInterface()->ClearEuiccs();
    for (int euicc_id = 0; euicc_id < data.euicc_count; euicc_id++) {
      SetupEuicc(euicc_id);
    }

    for (const auto& test_profile : data.profiles) {
      ash::HermesEuiccClient::Get()->GetTestInterface()->AddCarrierProfile(
          dbus::ObjectPath(test_profile.profile_path),
          dbus::ObjectPath(GetEuiccPath(/*euicc_id=*/0)), test_profile.iccid,
          test_profile.guid, "nickname", "service_provider",
          test_profile.activation_code_value, test_profile.service_path,
          test_profile.state, hermes::profile::ProfileClass::kOperational,
          ash::HermesEuiccClient::TestInterface::AddCarrierProfileBehavior::
              kAddProfileWithService);

      if (test_profile.managed) {
        // We set the prefs directly so that we can force situations that
        // otherwise would not be acceptable by the API of
        // ManagedCellularPrefHandler, e.g. an empty name or activation code
        // value, that we want to protect against uploading.
        base::Value::Dict esim_metadata;
        esim_metadata.Set(::onc::network_config::kName,
                          test_profile.network_name);
        esim_metadata.Set(
            test_profile.activation_code_type ==
                    ash::policy_util::SmdxActivationCode::Type::SMDP
                ? ::onc::cellular::kSMDPAddress
                : ::onc::cellular::kSMDSAddress,
            test_profile.activation_code_value);

        base::Value::Dict existing_prefs =
            local_state_.GetDict(ash::prefs::kManagedCellularESimMetadata)
                .Clone();
        existing_prefs.Set(test_profile.iccid, std::move(esim_metadata));
        local_state_.Set(ash::prefs::kManagedCellularESimMetadata,
                         base::Value(std::move(existing_prefs)));
      }
    }

    // Wait for Shill device and service change notifications to propagate.
    base::RunLoop().RunUntilIdle();
  }

  void ValidateUploadedStatus(const std::string& expected_status_str,
                              bool clear_profile_list) {
    base::Value expected_status = base::test::ParseJson(expected_status_str);
    EXPECT_EQ(expected_status, GetStoredPref());
    EXPECT_TRUE(cloud_policy_client_.GetLastRequest());
    EXPECT_TRUE(
        RequestsAreEqual(*EuiccStatusUploader::ConstructRequestFromStatus(
                             expected_status.GetDict(), clear_profile_list),
                         *cloud_policy_client_.GetLastRequest()));
  }

  void SetLastUploadedValue(const std::string& last_value) {
    local_state_.Set(EuiccStatusUploader::kLastUploadedEuiccStatusPref,
                     base::test::ParseJson(last_value));
  }

  void TriggerManagedCellularPrefChanged(EuiccStatusUploader* status_uploader) {
    static_cast<ash::ManagedCellularPrefHandler::Observer*>(status_uploader)
        ->OnManagedCellularPrefChanged();
  }

  void ExecuteResetCommand(EuiccStatusUploader* status_uploader) {
    SetUpDeviceProfiles(kEuiccTestData_AfterReset);

    // TODO(crbug.com/40205133): Make FakeHermesEuiccClient trigger OnEuiccReset
    // directly.
    static_cast<ash::HermesEuiccClient::Observer*>(status_uploader)
        ->OnEuiccReset(dbus::ObjectPath());
  }

  int GetRequestCount() { return cloud_policy_client_.num_requests(); }

  enterprise_management::UploadEuiccInfoRequest* GetLastRequest() {
    return cloud_policy_client_.GetLastRequest();
  }

  void CheckHistogram(int total_count, int success_count, int failed_count) {
    histogram_tester_.ExpectTotalCount(kEuiccStatusUploadResultHistogram,
                                       total_count);
    histogram_tester_.ExpectBucketCount(kEuiccStatusUploadResultHistogram, true,
                                        /*expected_count=*/success_count);
    histogram_tester_.ExpectBucketCount(kEuiccStatusUploadResultHistogram,
                                        false,
                                        /*expected_count=*/failed_count);
  }

  void SetIsDeviceActive(bool value) { is_device_active_ = value; }

 private:
  bool is_device_active() { return is_device_active_; }

  bool is_device_active_ = true;
  content::BrowserTaskEnvironment task_environment_;
  FakeCloudPolicyClient cloud_policy_client_;
  TestingPrefServiceSimple local_state_;
  std::unique_ptr<ash::NetworkHandlerTestHelper> helper_;
  base::HistogramTester histogram_tester_;
};

TEST_F(EuiccStatusUploaderTest, EmptySetup) {
  auto status_uploader = CreateStatusUploader();
  EXPECT_EQ(GetRequestCount(), 0);
  // No value is uploaded yet.
  EXPECT_EQ("{}", GetStoredPrefString());

  // Make server accept requests.
  SetServerSuccessStatus(true);
  UpdateUploader(status_uploader.get());
  // Verify that no status is uploaded if there is no EUICC.
  EXPECT_EQ(GetRequestCount(), 0);
  CheckHistogram(/*total_count=*/0, /*success_count=*/0, /*failed_count=*/0);
}

TEST_F(EuiccStatusUploaderTest, InactiveDevice) {
  SetIsDeviceActive(false);
  auto status_uploader = CreateStatusUploader();
  EXPECT_EQ(GetRequestCount(), 0);
  // No value is uploaded yet.
  EXPECT_EQ("{}", GetStoredPrefString());

  // Make server accept requests.
  SetServerSuccessStatus(true);
  UpdateUploader(status_uploader.get());
  // Verify that no status is uploaded if the device is inactive.
  EXPECT_EQ(GetRequestCount(), 0);
  CheckHistogram(/*total_count=*/0, /*success_count=*/0, /*failed_count=*/0);
}

TEST_F(EuiccStatusUploaderTest, ClientNotRegistered) {
  SetupEuicc();
  base::RunLoop().RunUntilIdle();
  SetPolicyClientIsRegistered(/*is_registered=*/false);

  auto status_uploader = CreateStatusUploader();
  EXPECT_EQ(GetRequestCount(), 0);
  // No value is uploaded yet.
  EXPECT_EQ("{}", GetStoredPrefString());

  UpdateUploader(status_uploader.get());
  // Verify that no requests are made if client is not registered.
  EXPECT_EQ(GetRequestCount(), 0);
  EXPECT_EQ("{}", GetStoredPrefString());
  CheckHistogram(/*total_count=*/0, /*success_count=*/0, /*failed_count=*/0);
}

TEST_F(EuiccStatusUploaderTest, ServerError) {
  SetupEuicc();
  base::RunLoop().RunUntilIdle();
  auto status_uploader = CreateStatusUploader();
  UpdateUploader(status_uploader.get());
  EXPECT_EQ(GetRequestCount(), 2);
  // Nothing is stored when requests fail.
  EXPECT_EQ("{}", GetStoredPrefString());
  CheckHistogram(/*total_count=*/2, /*success_count=*/0, /*failed_count=*/2);
}

TEST_F(EuiccStatusUploaderTest, WaitForPolicyFetch) {
  SetUpDeviceProfiles(kEuiccTestData_OneProfile);

  auto status_uploader = CreateStatusUploader(/*is_policy_fetched=*/false);
  EXPECT_EQ(GetRequestCount(), 0);
  // No value is uploaded yet.
  EXPECT_EQ("{}", GetStoredPrefString());

  // Verify that no requests are made when policy has not been fetched.
  SetServerSuccessStatus(true);
  UpdateUploader(status_uploader.get());
  EXPECT_EQ(GetRequestCount(), 0);

  // Verify that status is uploaded correctly when policy is fetched.
  SetPolicyFetched(status_uploader.get());
  ValidateUploadedStatus(kEuiccStatus_OneProfile,
                         /*clear_profile_list=*/false);
  CheckHistogram(/*total_count=*/1, /*success_count=*/1, /*failed_count=*/0);
}

TEST_F(EuiccStatusUploaderTest, Basic) {
  SetUpDeviceProfiles(kEuiccTestData_OneProfile);

  auto status_uploader = CreateStatusUploader();
  // Initial upload request.
  EXPECT_EQ(GetRequestCount(), 1);
  // No value is uploaded yet.
  EXPECT_EQ("{}", GetStoredPrefString());
  CheckHistogram(/*total_count=*/1, /*success_count=*/0, /*failed_count=*/1);

  // Make server accept requests.
  SetServerSuccessStatus(true);
  UpdateUploader(status_uploader.get());
  EXPECT_EQ(GetRequestCount(), 2);
  // Verify that last uploaded configuration is stored.
  ValidateUploadedStatus(kEuiccStatus_OneProfile,
                         /*clear_profile_list=*/false);
  CheckHistogram(/*total_count=*/2, /*success_count=*/1, /*failed_count=*/1);
}

TEST_F(EuiccStatusUploaderTest, BasicWithMissingName) {
  SetUpDeviceProfiles(kEuiccTestData_OneProfileWithMissingName);

  auto status_uploader = CreateStatusUploader();
  // Initial upload request.
  EXPECT_EQ(GetRequestCount(), 1);
  // No value is uploaded yet.
  EXPECT_EQ("{}", GetStoredPrefString());
  CheckHistogram(/*total_count=*/1, /*success_count=*/0, /*failed_count=*/1);

  // Make server accept requests.
  SetServerSuccessStatus(true);
  UpdateUploader(status_uploader.get());
  EXPECT_EQ(GetRequestCount(), 2);
  // Verify that last uploaded configuration is stored.
  ValidateUploadedStatus(kEuiccStatus_OneProfileWithMissingName,
                         /*clear_profile_list=*/false);
  CheckHistogram(/*total_count=*/2, /*success_count=*/1, /*failed_count=*/1);
}

TEST_F(EuiccStatusUploaderTest, BasicWithEmptyActivationCode) {
  SetUpDeviceProfiles(kEuiccTestData_OneProfileWithEmptyActivationCode);

  auto status_uploader = CreateStatusUploader();
  // Initial upload request.
  EXPECT_EQ(GetRequestCount(), 1);
  // No value is uploaded yet.
  EXPECT_EQ("{}", GetStoredPrefString());
  CheckHistogram(/*total_count=*/1, /*success_count=*/0, /*failed_count=*/1);

  // Make server accept requests.
  SetServerSuccessStatus(true);
  UpdateUploader(status_uploader.get());
  EXPECT_EQ(GetRequestCount(), 2);
  // Verify that last uploaded configuration is stored.
  ValidateUploadedStatus(kEuiccStatus_OneProfileWithEmptyActivationCode,
                         /*clear_profile_list=*/false);
  CheckHistogram(/*total_count=*/2, /*success_count=*/1, /*failed_count=*/1);
}

TEST_F(EuiccStatusUploaderTest, TwoProfiles) {
  SetUpDeviceProfiles(kEuiccTestData_TwoProfiles);

  auto status_uploader = CreateStatusUploader();
  // Initial upload request.
  EXPECT_EQ(GetRequestCount(), 1);
  // No value is uploaded yet.
  EXPECT_EQ("{}", GetStoredPrefString());
  CheckHistogram(/*total_count=*/1, /*success_count=*/0, /*failed_count=*/1);

  // Make server accept requests.
  SetServerSuccessStatus(true);
  UpdateUploader(status_uploader.get());
  EXPECT_EQ(GetRequestCount(), 2);

  // Verify that last uploaded configuration is stored.
  ValidateUploadedStatus(kEuiccStatus_TwoProfiles,
                         /*clear_profile_list=*/false);
  CheckHistogram(/*total_count=*/2, /*success_count=*/1, /*failed_count=*/1);
}

TEST_F(EuiccStatusUploaderTest, FourProfilesWithSmds) {
  SetUpDeviceProfiles(kEuiccTestData_FourProfiles);

  auto status_uploader = CreateStatusUploader();
  // Initial upload request.
  EXPECT_EQ(GetRequestCount(), 1);
  // No value is uploaded yet.
  EXPECT_EQ("{}", GetStoredPrefString());
  CheckHistogram(/*total_count=*/1, /*success_count=*/0, /*failed_count=*/1);

  // Make server accept requests.
  SetServerSuccessStatus(true);
  UpdateUploader(status_uploader.get());
  EXPECT_EQ(GetRequestCount(), 2);

  // Verify that last uploaded configuration is stored.
  ValidateUploadedStatus(kEuiccStatus_FourProfiles,
                         /*clear_profile_list=*/false);
  CheckHistogram(/*total_count=*/2, /*success_count=*/1, /*failed_count=*/1);
}

TEST_F(EuiccStatusUploaderTest, SameValueAsBefore) {
  // Make server accept requests.
  SetServerSuccessStatus(true);
  // Mark the current state as already uploaded.
  SetUpDeviceProfiles(kEuiccTestData_OneProfile);
  SetLastUploadedValue(kEuiccStatus_OneProfile);

  auto status_uploader = CreateStatusUploader();
  // No value is uploaded since it has been previously sent.
  EXPECT_EQ(GetRequestCount(), 0);
  CheckHistogram(/*total_count=*/0, /*success_count=*/0, /*failed_count=*/0);
}

TEST_F(EuiccStatusUploaderTest, NewValue) {
  // Make server accept requests.
  SetServerSuccessStatus(true);
  // Set up a value different from one that was previously uploaded.
  SetUpDeviceProfiles(kEuiccTestData_OneProfile);
  SetLastUploadedValue(kEuiccStatus_Empty);

  auto status_uploader = CreateStatusUploader();
  // Verify that last uploaded configuration is stored.
  ValidateUploadedStatus(kEuiccStatus_OneProfile,
                         /*clear_profile_list=*/false);
  CheckHistogram(/*total_count=*/1, /*success_count=*/1, /*failed_count=*/0);
}

TEST_F(EuiccStatusUploaderTest, ResetRequest) {
  // Make server accept requests.
  SetServerSuccessStatus(true);
  // Set up a value different from one that was previously uploaded.
  SetUpDeviceProfiles(kEuiccTestData_OneProfile);
  SetLastUploadedValue(kEuiccStatus_Empty);

  auto status_uploader = CreateStatusUploader();
  // Verify that last uploaded configuration is stored.
  ValidateUploadedStatus(kEuiccStatus_OneProfile,
                         /*clear_profile_list=*/false);

  // Reset remote command was received and executed.
  ExecuteResetCommand(status_uploader.get());
  // Request has been sent.
  EXPECT_EQ(GetRequestCount(), 3);

  ValidateUploadedStatus(kEuiccStatus_AfterReset,
                         /*clear_profile_list=*/true);

  // Send the reset command again.
  ExecuteResetCommand(status_uploader.get());
  // Request will be force-sent again because we've received a reset command..
  EXPECT_EQ(GetRequestCount(), 4);

  ValidateUploadedStatus(kEuiccStatus_AfterReset,
                         /*clear_profile_list=*/true);
}

TEST_F(EuiccStatusUploaderTest, ClearProfileListRaceCondition) {
  SetUpDeviceProfiles(kEuiccTestData_OneProfile);

  // Create the status uploader but do not trigger an upload via the policies
  // being fetched.
  auto status_uploader = CreateStatusUploader(/*is_policy_fetched=*/false);
  EXPECT_EQ(GetRequestCount(), 0);

  // Capture the callback that the status uploader provides to the cloud policy
  // client to allow us to block the completion of the first upload.
  base::OnceCallback<void(bool)> callback;
  SetPolicyClientHandler(base::BindRepeating(
      [](base::OnceCallback<void(bool)>* callback_out,
         base::OnceCallback<void(bool)> callback_in) {
        *callback_out = std::move(callback_in);
      },
      &callback));

  // Trigger the first upload.
  SetPolicyFetched(status_uploader.get());

  EXPECT_FALSE(GetLastRequest()->clear_profile_list());
  EXPECT_EQ(GetRequestCount(), 1);

  // Simulate a race condition where an upload is in progress and an EUICC reset
  // causes the "clear profile list" pref to be set to |true|. This pref should
  // not be cleared when the first upload finishes. This won't affect the value
  // of |callback| since an ongoing upload is blocking.
  ExecuteResetCommand(status_uploader.get());

  // Complete the first status upload. When this completes the status uploader
  // class will check if it should perform another upload; this class will
  // identify that the EUICC was reset and will trigger a second upload.
  ASSERT_TRUE(callback);
  std::move(callback).Run(true);

  EXPECT_TRUE(GetLastRequest()->clear_profile_list());
  EXPECT_EQ(GetRequestCount(), 2);
}

TEST_F(EuiccStatusUploaderTest, UnexpectedNetworkHandlerShutdown) {
  SetUpDeviceProfiles(kEuiccTestData_OneProfile);
  // NetworkHandler has not been initialized.
  auto status_uploader = CreateStatusUploader();

  // Initial Request
  EXPECT_EQ(GetRequestCount(), 1);

  // Requests made normally.
  UpdateUploader(status_uploader.get());
  EXPECT_EQ(GetRequestCount(), 2);

  // NetworkHandler::Shutdown() has already been called before
  // EuiccStatusUploader is deleted
  ash::NetworkHandler::Shutdown();

  // No requests made as NetworkHandler is not available.
  UpdateUploader(status_uploader.get());
  EXPECT_EQ(GetRequestCount(), 2);

  // Need to reinitialize before exiting test.
  ash::NetworkHandler::Initialize();
}

}  // namespace policy