chrome/enterprise_companion/proxy_config_service_unittest.cc

// Copyright 2024 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/enterprise_companion/proxy_config_service.h"

#include <memory>
#include <optional>
#include <string>
#include <utility>

#include "base/files/file_path.h"
#include "base/memory/scoped_refptr.h"
#include "base/test/bind.h"
#include "base/test/task_environment.h"
#include "chrome/enterprise_companion/device_management_storage/dm_storage.h"
#include "chrome/updater/protos/omaha_settings.pb.h"
#include "device_management_backend.pb.h"
#include "net/base/proxy_server.h"
#include "net/base/proxy_string_util.h"
#include "net/proxy_resolution/proxy_config.h"
#include "net/proxy_resolution/proxy_config_service.h"
#include "net/proxy_resolution/proxy_config_with_annotation.h"
#include "net/proxy_resolution/proxy_list.h"
#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace enterprise_companion {

// A stub DMStorage for providing cloud policy data to the ProxyConfigService.
class FakeDMStorage : public device_management_storage::DMStorage {
 public:
  FakeDMStorage() = default;

  void SetProxyPolicies(
      std::optional<std::string> proxy_mode,
      std::optional<std::string> pac_url,
      std::optional<std::string> proxy_server,
      std::optional<bool> cloud_policy_overrides_platform_policy =
          std::nullopt) {
    wireless_android_enterprise_devicemanagement::OmahaSettingsClientProto
        omaha_settings;
    if (proxy_mode) {
      omaha_settings.set_proxy_mode(*proxy_mode);
    }
    if (pac_url) {
      omaha_settings.set_proxy_pac_url(*pac_url);
    }
    if (proxy_server) {
      omaha_settings.set_proxy_server(*proxy_server);
    }
    if (cloud_policy_overrides_platform_policy) {
      omaha_settings.set_cloud_policy_overrides_platform_policy(
          *cloud_policy_overrides_platform_policy);
    }
    policy_data_ = enterprise_management::PolicyData();
    policy_data_->set_policy_value(omaha_settings.SerializeAsString());
  }

  void WriteInvalidPolicyData() {
    policy_data_ = enterprise_management::PolicyData();
    policy_data_->set_policy_value("this is not a real serialized proto.");
  }

  std::optional<enterprise_management::PolicyData> ReadPolicyData(
      const std::string& policy_type) override {
    return policy_data_;
  }

  std::string GetDeviceID() const override { return std::string(); }
  bool IsEnrollmentMandatory() const override { return false; }
  bool StoreEnrollmentToken(const std::string& enrollment_token) override {
    return false;
  }
  bool DeleteEnrollmentToken() override { return false; }
  std::string GetEnrollmentToken() const override { return std::string(); }
  bool StoreDmToken(const std::string& dm_token) override { return false; }
  std::string GetDmToken() const override { return std::string(); }
  bool InvalidateDMToken() override { return false; }
  bool DeleteDMToken() override { return false; }
  bool IsValidDMToken() const override { return false; }
  bool IsDeviceDeregistered() const override { return false; }
  bool CanPersistPolicies() const override { return false; }
  bool PersistPolicies(
      const device_management_storage::DMPolicyMap& policy_map) const override {
    return false;
  }
  bool RemoveAllPolicies() const override { return false; }
  std::unique_ptr<device_management_storage::CachedPolicyInfo>
  GetCachedPolicyInfo() const override {
    return nullptr;
  }
  base::FilePath policy_cache_folder() const override {
    return base::FilePath();
  }

 private:
  ~FakeDMStorage() override = default;

  std::optional<enterprise_management::PolicyData> policy_data_;
};

class MockProxyConfigService final : public net::ProxyConfigService {
 public:
  void AddObserver(Observer*) override {}
  void RemoveObserver(Observer*) override {}

  MOCK_METHOD(ConfigAvailability,
              GetLatestProxyConfig,
              (net::ProxyConfigWithAnnotation*),
              (override));
};

class ProxyConfigServiceTest : public ::testing::Test {
 protected:
  base::test::TaskEnvironment environment_;
  scoped_refptr<FakeDMStorage> fake_dm_storage_ =
      base::MakeRefCounted<FakeDMStorage>();
  std::unique_ptr<MockProxyConfigService> mock_fallback_ =
      std::make_unique<MockProxyConfigService>();
  std::optional<ProxyConfigAndOverridePrecedence> system_policy_config_;

  std::unique_ptr<net::ProxyConfigService> CreateService() {
    return CreatePolicyProxyConfigService(
        scoped_refptr<device_management_storage::DMStorage>(fake_dm_storage_),
        base::BindLambdaForTesting([&] { return system_policy_config_; }),
        std::move(mock_fallback_));
  }
};

TEST_F(ProxyConfigServiceTest, ConfigFromCloudPolicy_Direct) {
  fake_dm_storage_->SetProxyPolicies("direct",
                                     /*pac_url=*/std::nullopt,
                                     /*proxy_server=*/std::nullopt);
  EXPECT_CALL(*mock_fallback_, GetLatestProxyConfig).Times(0);
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  EXPECT_TRUE(config.value().Equals(net::ProxyConfig::CreateDirect()));
}

TEST_F(ProxyConfigServiceTest, ConfigFromCloudPolicy_AutoDetect) {
  fake_dm_storage_->SetProxyPolicies("auto_detect",
                                     /*pac_url=*/std::nullopt,
                                     /*proxy_server=*/std::nullopt);
  EXPECT_CALL(*mock_fallback_, GetLatestProxyConfig).Times(0);
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  EXPECT_TRUE(config.value().Equals(net::ProxyConfig::CreateAutoDetect()));
}

TEST_F(ProxyConfigServiceTest, ConfigFromCloudPolicy_PAC) {
  fake_dm_storage_->SetProxyPolicies(
      "pac_script",
      /*pac_url=*/"http://not-a.real-domain:8082/proxy.pac",
      /*proxy_server=*/std::nullopt);
  EXPECT_CALL(*mock_fallback_, GetLatestProxyConfig).Times(0);
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  EXPECT_TRUE(config.value().Equals(net::ProxyConfig::CreateFromCustomPacURL(
      GURL("http://not-a.real-domain:8082/proxy.pac"))));
}

TEST_F(ProxyConfigServiceTest, ConfigFromCloudPolicy_FixedServers) {
  fake_dm_storage_->SetProxyPolicies(
      "fixed_servers",
      /*pac_url=*/std::nullopt,
      /*proxy_server=*/"http://not-a.real-domain:7918");
  EXPECT_CALL(*mock_fallback_, GetLatestProxyConfig).Times(0);
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  net::ProxyList proxy_list;
  proxy_list.SetSingleProxyServer(net::ProxyUriToProxyServer(
      "http://not-a.real-domain:7918", net::ProxyServer::SCHEME_HTTP));
  EXPECT_TRUE(
      config.value().Equals(net::ProxyConfig::CreateForTesting(proxy_list)));
}

TEST_F(ProxyConfigServiceTest, ConfigFromCloudPolicy_System) {
  fake_dm_storage_->SetProxyPolicies("system",
                                     /*pac_url=*/std::nullopt,
                                     /*proxy_server=*/std::nullopt);
  // The "system" mode should delegate to the fallback service.
  EXPECT_CALL(*mock_fallback_, GetLatestProxyConfig)
      .WillOnce([](net::ProxyConfigWithAnnotation* config) {
        *config = net::ProxyConfigWithAnnotation(
            net::ProxyConfig::CreateAutoDetect(), TRAFFIC_ANNOTATION_FOR_TESTS);
        return net::ProxyConfigService::ConfigAvailability::CONFIG_VALID;
      });
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  EXPECT_TRUE(config.value().auto_detect());
}

TEST_F(ProxyConfigServiceTest, NoPolicies_Fallback) {
  EXPECT_CALL(*mock_fallback_, GetLatestProxyConfig)
      .WillOnce([](net::ProxyConfigWithAnnotation* config) {
        *config = net::ProxyConfigWithAnnotation(
            net::ProxyConfig::CreateAutoDetect(), TRAFFIC_ANNOTATION_FOR_TESTS);
        return net::ProxyConfigService::ConfigAvailability::CONFIG_VALID;
      });
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  EXPECT_TRUE(config.value().auto_detect());
}

TEST_F(ProxyConfigServiceTest, EmptyPolicies_Fallback) {
  fake_dm_storage_->SetProxyPolicies(/*proxy_mode=*/std::nullopt,
                                     /*pac_url=*/std::nullopt,
                                     /*proxy_server=*/std::nullopt);
  EXPECT_CALL(*mock_fallback_, GetLatestProxyConfig)
      .WillOnce([](net::ProxyConfigWithAnnotation* config) {
        *config = net::ProxyConfigWithAnnotation(
            net::ProxyConfig::CreateAutoDetect(), TRAFFIC_ANNOTATION_FOR_TESTS);
        return net::ProxyConfigService::ConfigAvailability::CONFIG_VALID;
      });
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  EXPECT_TRUE(config.value().auto_detect());
}

TEST_F(ProxyConfigServiceTest, UnknownProxyMode_Fallback) {
  fake_dm_storage_->SetProxyPolicies(/*proxy_mode=*/"not_a_real_proxy_mode",
                                     /*pac_url=*/std::nullopt,
                                     /*proxy_server=*/std::nullopt);
  EXPECT_CALL(*mock_fallback_, GetLatestProxyConfig)
      .WillOnce([](net::ProxyConfigWithAnnotation* config) {
        *config = net::ProxyConfigWithAnnotation(
            net::ProxyConfig::CreateAutoDetect(), TRAFFIC_ANNOTATION_FOR_TESTS);
        return net::ProxyConfigService::ConfigAvailability::CONFIG_VALID;
      });
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  EXPECT_TRUE(config.value().auto_detect());
}

TEST_F(ProxyConfigServiceTest, UnparsableOmahaSettings_Fallback) {
  fake_dm_storage_->WriteInvalidPolicyData();
  EXPECT_CALL(*mock_fallback_, GetLatestProxyConfig)
      .WillOnce([](net::ProxyConfigWithAnnotation* config) {
        *config = net::ProxyConfigWithAnnotation(
            net::ProxyConfig::CreateAutoDetect(), TRAFFIC_ANNOTATION_FOR_TESTS);
        return net::ProxyConfigService::ConfigAvailability::CONFIG_VALID;
      });
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  EXPECT_TRUE(config.value().auto_detect());
}

TEST_F(ProxyConfigServiceTest, ConfigFromLocalPolicy) {
  system_policy_config_ = ProxyConfigAndOverridePrecedence();
  system_policy_config_->config = net::ProxyConfig::CreateDirect();
  EXPECT_CALL(*mock_fallback_, GetLatestProxyConfig).Times(0);
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  EXPECT_TRUE(config.value().Equals(net::ProxyConfig::CreateDirect()));
}

TEST_F(ProxyConfigServiceTest, LocalPolicyOverridesByDefault) {
  fake_dm_storage_->SetProxyPolicies("direct",
                                     /*pac_url=*/std::nullopt,
                                     /*proxy_server=*/std::nullopt);
  system_policy_config_ = ProxyConfigAndOverridePrecedence();
  system_policy_config_->config = net::ProxyConfig::CreateAutoDetect();
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  EXPECT_TRUE(config.value().Equals(net::ProxyConfig::CreateAutoDetect()));
}

TEST_F(ProxyConfigServiceTest, CloudPolicyOverridesPlatformPolicy_ByLocal) {
  fake_dm_storage_->SetProxyPolicies("direct",
                                     /*pac_url=*/std::nullopt,
                                     /*proxy_server=*/std::nullopt);
  system_policy_config_ = ProxyConfigAndOverridePrecedence();
  system_policy_config_->config = net::ProxyConfig::CreateAutoDetect();
  system_policy_config_->cloud_policy_overrides_platform_policy = true;
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  EXPECT_TRUE(config.value().Equals(net::ProxyConfig::CreateDirect()));
}

TEST_F(ProxyConfigServiceTest, CloudPolicyOverridesPlatformPolicy_ByCloud) {
  fake_dm_storage_->SetProxyPolicies(
      "direct",
      /*pac_url=*/std::nullopt,
      /*proxy_server=*/std::nullopt,
      /*cloud_policy_overrides_platform_policy=*/true);
  system_policy_config_ = ProxyConfigAndOverridePrecedence();
  system_policy_config_->config = net::ProxyConfig::CreateAutoDetect();
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  EXPECT_TRUE(config.value().Equals(net::ProxyConfig::CreateDirect()));
}

// If the "CloudPolicyOverridesPlatformPolicy" from cloud policy disagrees with
// that from local policy, the cloud policy should be honored.
TEST_F(ProxyConfigServiceTest,
       CloudPolicyOverridesPlatformPolicy_CloudAndLocalConflict) {
  fake_dm_storage_->SetProxyPolicies(
      "direct",
      /*pac_url=*/std::nullopt,
      /*proxy_server=*/std::nullopt,
      /*cloud_policy_overrides_platform_policy=*/true);
  system_policy_config_ = ProxyConfigAndOverridePrecedence();
  system_policy_config_->config = net::ProxyConfig::CreateAutoDetect();
  system_policy_config_->cloud_policy_overrides_platform_policy = false;
  std::unique_ptr<net::ProxyConfigService> proxy_config_service =
      CreateService();

  net::ProxyConfigWithAnnotation config;
  ASSERT_EQ(proxy_config_service->GetLatestProxyConfig(&config),
            net::ProxyConfigService::ConfigAvailability::CONFIG_VALID);

  EXPECT_TRUE(config.value().Equals(net::ProxyConfig::CreateDirect()));
}

}  // namespace enterprise_companion