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

#include "net/dns/httpssvc_metrics.h"

#include <string>
#include <tuple>

#include "base/feature_list.h"
#include "base/strings/strcat.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "net/base/features.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace net {

// int: number of domains
// bool: extra leading comma
// bool: extra trailing comma
using DomainListQuirksTuple = std::tuple<int, bool, bool>;

// bool: DnsHttpssvc feature is enabled
// bool: DnsHttpssvcUseIntegrity feature param
// bool: DnsHttpssvcUseHttpssvc feature param
// bool: DnsHttpssvcControlDomainWildcard feature param
using HttpssvcFeatureTuple = std::tuple<bool, bool, bool, bool>;

// DomainListQuirksTuple: quirks for the experimental domain list.
// DomainListQuirksTuple: quirks for the control domain list.
// HttpssvcFeatureTuple: config for the whole DnsHttpssvc feature.
using ParsingTestParamTuple = std::
    tuple<DomainListQuirksTuple, DomainListQuirksTuple, HttpssvcFeatureTuple>;

// bool: whether we are querying for an experimental domain or a control domain
// HttpssvcFeatureTuple: config for the whole DnsHttpssvc feature.
using MetricsTestParamTuple = std::tuple<bool, HttpssvcFeatureTuple>;

// Create a comma-separated list of |domains| with the given |quirks|.
std::string FlattenDomainList(const std::vector<std::string>& domains,
                              DomainListQuirksTuple quirks) {
  int num_domains;
  bool leading_comma, trailing_comma;
  std::tie(num_domains, leading_comma, trailing_comma) = quirks;

  CHECK_EQ(static_cast<size_t>(num_domains), domains.size());
  std::string flattened = base::JoinString(domains, ",");
  if (leading_comma)
    flattened.insert(flattened.begin(), ',');
  if (trailing_comma)
    flattened.push_back(',');
  return flattened;
}

// Intermediate representation constructed from test parameters.
struct HttpssvcFeatureConfig {
  HttpssvcFeatureConfig() = default;

  explicit HttpssvcFeatureConfig(const HttpssvcFeatureTuple& feature_tuple,
                                 base::StringPiece experiment_domains,
                                 base::StringPiece control_domains)
      : experiment_domains(experiment_domains.as_string()),
        control_domains(control_domains.as_string()) {
    std::tie(enabled, use_integrity, use_httpssvc, control_domain_wildcard) =
        feature_tuple;
  }

  void Apply(base::test::ScopedFeatureList* scoped_feature_list) const {
    if (!enabled) {
      scoped_feature_list->InitAndDisableFeature(features::kDnsHttpssvc);
      return;
    }
    auto stringify = [](bool b) -> std::string { return b ? "true" : "false"; };
    scoped_feature_list->InitAndEnableFeatureWithParameters(
        features::kDnsHttpssvc,
        {
            {"DnsHttpssvcUseHttpssvc", stringify(use_httpssvc)},
            {"DnsHttpssvcUseIntegrity", stringify(use_integrity)},
            {"DnsHttpssvcEnableQueryOverInsecure", "false"},
            {"DnsHttpssvcExperimentDomains", experiment_domains},
            {"DnsHttpssvcControlDomains", control_domains},
            {"DnsHttpssvcControlDomainWildcard",
             stringify(control_domain_wildcard)},
        });
  }

  bool enabled = false;
  bool use_integrity = false;
  bool use_httpssvc = false;
  bool control_domain_wildcard = false;
  std::string experiment_domains;
  std::string control_domains;
};

std::vector<std::string> GenerateDomainList(base::StringPiece label, int n) {
  std::vector<std::string> domains;
  for (int i = 0; i < n; i++) {
    domains.push_back(base::StrCat(
        {"domain", base::NumberToString(i), ".", label, ".example"}));
  }
  return domains;
}

// Base for testing domain list parsing functions in
// net::features::dns_httpssvc_experiment.
class HttpssvcDomainParsingTest
    : public ::testing::TestWithParam<ParsingTestParamTuple> {
 public:
  void SetUp() override {
    DomainListQuirksTuple domain_quirks_experimental;
    DomainListQuirksTuple domain_quirks_control;
    HttpssvcFeatureTuple httpssvc_feature;
    std::tie(domain_quirks_experimental, domain_quirks_control,
             httpssvc_feature) = GetParam();

    expected_experiment_domains_ = GenerateDomainList(
        "experiment", std::get<0>(domain_quirks_experimental));
    expected_control_domains_ =
        GenerateDomainList("control", std::get<0>(domain_quirks_control));

    config_ = HttpssvcFeatureConfig(
        httpssvc_feature,
        FlattenDomainList(expected_experiment_domains_,
                          domain_quirks_experimental),
        FlattenDomainList(expected_control_domains_, domain_quirks_control));
    config_.Apply(&scoped_feature_list_);
  }

  const HttpssvcFeatureConfig& config() { return config_; }

 protected:
  // The expected results of parsing the comma-separated domain lists in
  // |experiment_domains| and |control_domains|, respectively.
  std::vector<std::string> expected_experiment_domains_;
  std::vector<std::string> expected_control_domains_;

 private:
  HttpssvcFeatureConfig config_;
  base::test::ScopedFeatureList scoped_feature_list_;
};

// This instantiation tests the domain list parser against various quirks,
// e.g. leading comma.
INSTANTIATE_TEST_SUITE_P(
    HttpssvcMetricsTestDomainParsing,
    HttpssvcDomainParsingTest,
    testing::Combine(
        // DomainListQuirksTuple for experimental domains. To fight back
        // combinatorial explosion of tests, this tuple is pared down more than
        // the one for control domains. This should not significantly hurt test
        // coverage because |IsExperimentDomain| and |IsControlDomain| rely on a
        // shared helper function.
        testing::Combine(testing::Values(0, 1),
                         testing::Values(false),
                         testing::Values(false)),
        // DomainListQuirksTuple for control domains.
        testing::Combine(testing::Range(0, 3),
                         testing::Bool(),
                         testing::Bool()),
        // HttpssvcFeatureTuple
        testing::Combine(
            testing::Bool() /* DnsHttpssvc feature enabled? */,
            testing::Bool() /* DnsHttpssvcUseIntegrity */,
            testing::Values(false) /* DnsHttpssvcUseHttpssvc */,
            testing::Values(false) /* DnsHttpssvcControlDomainWildcard */)));

// Base for testing the metrics collection code in |HttpssvcMetrics|.
class HttpssvcMetricsTest
    : public ::testing::TestWithParam<MetricsTestParamTuple> {
 public:
  void SetUp() override {
    HttpssvcFeatureTuple httpssvc_feature;
    std::tie(querying_experimental_, httpssvc_feature) = GetParam();
    config_ = HttpssvcFeatureConfig(httpssvc_feature, "", "");
    config_.Apply(&scoped_feature_list_);
  }

  std::string BuildMetricNamePrefix() const {
    return base::StrCat(
        {"Net.DNS.HTTPSSVC.RecordIntegrity.", doh_provider_, "."});
  }

  template <typename T>
  void ExpectSample(base::StringPiece name, base::Optional<T> sample) const {
    if (sample)
      histo().ExpectUniqueSample(name, *sample, 1);
    else
      histo().ExpectTotalCount(name, 0);
  }

  void ExpectSample(base::StringPiece name,
                    base::Optional<base::TimeDelta> sample) const {
    base::Optional<int64_t> sample_ms;
    if (sample)
      sample_ms = {sample->InMilliseconds()};
    ExpectSample<int64_t>(name, sample_ms);
  }

  void VerifyMetricsForExpectIntact(
      base::Optional<HttpssvcDnsRcode> rcode,
      base::Optional<bool> integrity,
      base::Optional<bool> record_with_error,
      base::Optional<base::TimeDelta> resolve_time_integrity,
      base::Optional<base::TimeDelta> resolve_time_non_integrity,
      base::Optional<int> resolve_time_ratio) const {
    const std::string kPrefix =
        base::StrCat({BuildMetricNamePrefix(), "ExpectIntact."});
    const std::string kMetricDnsRcode = base::StrCat({kPrefix, "DnsRcode"});
    const std::string kMetricIntegrity = base::StrCat({kPrefix, "Integrity"});
    const std::string kMetricRecordWithError =
        base::StrCat({kPrefix, "RecordWithError"});
    const std::string kMetricResolveTimeIntegrity =
        base::StrCat({kPrefix, "ResolveTimeIntegrityRecord"});
    const std::string kMetricResolveTimeNonIntegrity =
        base::StrCat({kPrefix, "ResolveTimeNonIntegrityRecord"});
    const std::string kMetricResolveTimeRatio =
        base::StrCat({kPrefix, "ResolveTimeRatio"});

    ExpectSample(kMetricDnsRcode, rcode);
    ExpectSample(kMetricIntegrity, integrity);
    ExpectSample(kMetricRecordWithError, record_with_error);
    ExpectSample(kMetricResolveTimeIntegrity, resolve_time_integrity);
    ExpectSample(kMetricResolveTimeNonIntegrity, resolve_time_non_integrity);
    ExpectSample(kMetricResolveTimeRatio, resolve_time_ratio);
  }

  void VerifyMetricsForExpectNoerror(
      base::Optional<HttpssvcDnsRcode> rcode,
      base::Optional<int> record_received,
      base::Optional<base::TimeDelta> resolve_time_integrity,
      base::Optional<base::TimeDelta> resolve_time_non_integrity,
      base::Optional<int> resolve_time_ratio) const {
    const std::string kPrefix =
        base::StrCat({BuildMetricNamePrefix(), "ExpectNoerror."});
    const std::string kMetricDnsRcode = base::StrCat({kPrefix, "DnsRcode"});
    const std::string kMetricRecordReceived =
        base::StrCat({kPrefix, "RecordReceived"});
    const std::string kMetricResolveTimeIntegrity =
        base::StrCat({kPrefix, "ResolveTimeIntegrityRecord"});
    const std::string kMetricResolveTimeNonIntegrity =
        base::StrCat({kPrefix, "ResolveTimeNonIntegrityRecord"});
    const std::string kMetricResolveTimeRatio =
        base::StrCat({kPrefix, "ResolveTimeRatio"});

    ExpectSample(kMetricDnsRcode, rcode);
    ExpectSample(kMetricRecordReceived, record_received);
    ExpectSample(kMetricResolveTimeIntegrity, resolve_time_integrity);
    ExpectSample(kMetricResolveTimeNonIntegrity, resolve_time_non_integrity);
    ExpectSample(kMetricResolveTimeRatio, resolve_time_ratio);
  }

  void VerifyMetricsForExpectIntact() {
    VerifyMetricsForExpectIntact(base::nullopt, base::nullopt, base::nullopt,
                                 base::nullopt, base::nullopt, base::nullopt);
  }

  void VerifyMetricsForExpectNoerror() {
    VerifyMetricsForExpectNoerror(base::nullopt, base::nullopt, base::nullopt,
                                  base::nullopt, base::nullopt);
  }

  const base::HistogramTester& histo() const { return histogram_; }
  const HttpssvcFeatureConfig& config() const { return config_; }

 protected:
  bool querying_experimental_;

 private:
  HttpssvcFeatureConfig config_;
  base::test::ScopedFeatureList scoped_feature_list_;
  base::HistogramTester histogram_;
  std::string doh_provider_ = "Other";
};

// This instantiation focuses on whether the correct metrics are recorded. The
// domain list parser is already tested against encoding quirks in
// |HttpssvcMetricsTestDomainParsing|, so we fix the quirks at false.
INSTANTIATE_TEST_SUITE_P(
    HttpssvcMetricsTestSimple,
    HttpssvcMetricsTest,
    testing::Combine(
        // Whether we are querying an experimental domain.
        testing::Bool(),
        // HttpssvcFeatureTuple
        testing::Combine(
            testing::Values(true) /* DnsHttpssvc feature enabled? */,
            testing::Values(true) /* DnsHttpssvcUseIntegrity */,
            testing::Values(false) /* DnsHttpssvcUseHttpssvc */,
            testing::Values(false) /* DnsHttpssvcControlDomainWildcard */)));

TEST_P(HttpssvcDomainParsingTest, ParseFeatureParamIntegrityDomains) {
  HttpssvcExperimentDomainCache domain_cache;

  // We are not testing this feature param yet.
  CHECK(!config().use_httpssvc);

  const std::string kReservedDomain = "neither.example";
  EXPECT_FALSE(domain_cache.IsExperimental(kReservedDomain));
  EXPECT_EQ(domain_cache.IsControl(kReservedDomain),
            config().enabled && config().control_domain_wildcard);

  // If |config().use_integrity| is true, then we expect all domains in
  // |expected_experiment_domains_| to be experimental (same goes for
  // control domains). Otherwise, no domain should be considered experimental or
  // control.

  if (!config().enabled) {
    // When the HTTPSSVC feature is disabled, no domain should be considered
    // experimental or control.
    for (const std::string& experiment_domain : expected_experiment_domains_) {
      EXPECT_FALSE(domain_cache.IsExperimental(experiment_domain));
      EXPECT_FALSE(domain_cache.IsControl(experiment_domain));
    }
    for (const std::string& control_domain : expected_control_domains_) {
      EXPECT_FALSE(domain_cache.IsExperimental(control_domain));
      EXPECT_FALSE(domain_cache.IsControl(control_domain));
    }
  } else if (config().use_integrity) {
    for (const std::string& experiment_domain : expected_experiment_domains_) {
      EXPECT_TRUE(domain_cache.IsExperimental(experiment_domain));
      EXPECT_FALSE(domain_cache.IsControl(experiment_domain));
    }
    for (const std::string& control_domain : expected_control_domains_) {
      EXPECT_FALSE(domain_cache.IsExperimental(control_domain));
      EXPECT_TRUE(domain_cache.IsControl(control_domain));
    }
    return;
  }
}

// Only record metrics for a non-integrity query.
TEST_P(HttpssvcMetricsTest, AddressAndIntegrityMissing) {
  if (!config().enabled || !config().use_integrity) {
    VerifyMetricsForExpectIntact();
    VerifyMetricsForExpectNoerror();
    return;
  }
  const base::TimeDelta kResolveTime = base::TimeDelta::FromMilliseconds(10);
  base::Optional<HttpssvcMetrics> metrics(querying_experimental_);
  metrics->SaveForNonIntegrity(base::nullopt, kResolveTime,
                               HttpssvcDnsRcode::kNoError);
  metrics.reset();  // Record the metrics to UMA.

  VerifyMetricsForExpectIntact();
  VerifyMetricsForExpectNoerror();
}

TEST_P(HttpssvcMetricsTest, AddressAndIntegrityIntact) {
  if (!config().enabled || !config().use_integrity) {
    VerifyMetricsForExpectIntact();
    VerifyMetricsForExpectNoerror();
    return;
  }
  const base::TimeDelta kResolveTime = base::TimeDelta::FromMilliseconds(10);
  const base::TimeDelta kResolveTimeIntegrity =
      base::TimeDelta::FromMilliseconds(15);
  base::Optional<HttpssvcMetrics> metrics(querying_experimental_);
  metrics->SaveForIntegrity(base::nullopt, HttpssvcDnsRcode::kNoError, {true},
                            kResolveTimeIntegrity);
  metrics->SaveForNonIntegrity(base::nullopt, kResolveTime,
                               HttpssvcDnsRcode::kNoError);
  metrics.reset();  // Record the metrics to UMA.

  if (querying_experimental_) {
    VerifyMetricsForExpectIntact(
        base::nullopt /* rcode */, {true} /* integrity */,
        base::nullopt /* record_with_error */,
        {kResolveTimeIntegrity} /* resolve_time_integrity */,
        {kResolveTime} /* resolve_time_non_integrity */,
        {15} /* resolve_time_ratio */);

    VerifyMetricsForExpectNoerror();
    return;
  }

  VerifyMetricsForExpectIntact();

  VerifyMetricsForExpectNoerror(
      {HttpssvcDnsRcode::kNoError} /* rcode */, {1} /* record_received */,
      {kResolveTimeIntegrity} /* resolve_time_integrity */,
      {kResolveTime} /* resolve_time_non_integrity */,
      {15} /* resolve_time_ratio */);
}

// This test simulates an INTEGRITY response that includes no INTEGRITY records,
// but does have an error value for the RCODE.
TEST_P(HttpssvcMetricsTest, AddressAndIntegrityMissingWithRcode) {
  if (!config().enabled || !config().use_integrity) {
    VerifyMetricsForExpectIntact();
    VerifyMetricsForExpectNoerror();
    return;
  }
  const base::TimeDelta kResolveTime = base::TimeDelta::FromMilliseconds(10);
  const base::TimeDelta kResolveTimeIntegrity =
      base::TimeDelta::FromMilliseconds(15);

  base::Optional<HttpssvcMetrics> metrics(querying_experimental_);
  metrics->SaveForIntegrity(base::nullopt, HttpssvcDnsRcode::kNxDomain, {},
                            kResolveTimeIntegrity);
  metrics->SaveForNonIntegrity(base::nullopt, kResolveTime,
                               HttpssvcDnsRcode::kNoError);
  metrics.reset();  // Record the metrics to UMA.

  if (querying_experimental_) {
    VerifyMetricsForExpectIntact(
        {HttpssvcDnsRcode::kNxDomain} /* rcode */,
        base::nullopt /* integrity */, base::nullopt /* record_with_error */,
        {kResolveTimeIntegrity} /* resolve_time_integrity */,
        {kResolveTime} /* resolve_time_non_integrity */,
        {15} /* resolve_time_ratio */);

    VerifyMetricsForExpectNoerror();
    return;
  }

  VerifyMetricsForExpectIntact();

  VerifyMetricsForExpectNoerror(
      {HttpssvcDnsRcode::kNxDomain} /* rcode */,
      base::nullopt /* record_received */,
      {kResolveTimeIntegrity} /* resolve_time_integrity */,
      {kResolveTime} /* resolve_time_non_integrity */,
      {15} /* resolve_time_ratio */);
}

// This test simulates an INTEGRITY response that includes an intact INTEGRITY
// record, but also has an error RCODE.
TEST_P(HttpssvcMetricsTest, AddressAndIntegrityIntactWithRcode) {
  if (!config().enabled || !config().use_integrity) {
    VerifyMetricsForExpectIntact();
    VerifyMetricsForExpectNoerror();
    return;
  }

  const base::TimeDelta kResolveTime = base::TimeDelta::FromMilliseconds(10);
  const base::TimeDelta kResolveTimeIntegrity =
      base::TimeDelta::FromMilliseconds(15);

  base::Optional<HttpssvcMetrics> metrics(querying_experimental_);
  metrics->SaveForIntegrity(base::nullopt, HttpssvcDnsRcode::kNxDomain, {true},
                            kResolveTimeIntegrity);
  metrics->SaveForNonIntegrity(base::nullopt, kResolveTime,
                               HttpssvcDnsRcode::kNoError);
  metrics.reset();  // Record the metrics to UMA.

  if (querying_experimental_) {
    VerifyMetricsForExpectIntact(
        // "DnsRcode" metric is omitted because we received an INTEGRITY record.
        base::nullopt /* rcode */,
        // "Integrity" metric is omitted because the RCODE is not NOERROR.
        base::nullopt /* integrity */, {true} /* record_with_error */,
        {kResolveTimeIntegrity} /* resolve_time_integrity */,
        {kResolveTime} /* resolve_time_non_integrity */,
        {15} /* resolve_time_ratio */);

    VerifyMetricsForExpectNoerror();
    return;
  }

  VerifyMetricsForExpectIntact();

  VerifyMetricsForExpectNoerror(
      {HttpssvcDnsRcode::kNxDomain} /* rcode */, {true} /* record_received */,
      {kResolveTimeIntegrity} /* resolve_time_integrity */,
      {kResolveTime} /* resolve_time_non_integrity */,
      {15} /* resolve_time_ratio */);
}

// This test simulates an INTEGRITY response that includes a mangled INTEGRITY
// record *and* has an error RCODE.
TEST_P(HttpssvcMetricsTest, AddressAndIntegrityMangledWithRcode) {
  if (!config().enabled || !config().use_integrity) {
    VerifyMetricsForExpectIntact();
    VerifyMetricsForExpectNoerror();
    return;
  }
  const base::TimeDelta kResolveTime = base::TimeDelta::FromMilliseconds(10);
  const base::TimeDelta kResolveTimeIntegrity =
      base::TimeDelta::FromMilliseconds(15);
  base::Optional<HttpssvcMetrics> metrics(querying_experimental_);
  metrics->SaveForIntegrity(base::nullopt, HttpssvcDnsRcode::kNxDomain, {false},
                            kResolveTimeIntegrity);
  metrics->SaveForNonIntegrity(base::nullopt, kResolveTime,
                               HttpssvcDnsRcode::kNoError);
  metrics.reset();  // Record the metrics to UMA.

  if (querying_experimental_) {
    VerifyMetricsForExpectIntact(
        // "DnsRcode" metric is omitted because we received an INTEGRITY record.
        base::nullopt /* rcode */,
        // "Integrity" metric is omitted because the RCODE is not NOERROR.
        base::nullopt /* integrity */, {true} /* record_with_error */,
        {kResolveTimeIntegrity} /* resolve_time_integrity */,
        {kResolveTime} /* resolve_time_non_integrity */,
        {15} /* resolve_time_ratio */);

    VerifyMetricsForExpectNoerror();
    return;
  }

  VerifyMetricsForExpectIntact();

  VerifyMetricsForExpectNoerror(
      {HttpssvcDnsRcode::kNxDomain} /* rcode */, {true} /* record_received */,
      {kResolveTimeIntegrity} /* resolve_time_integrity */,
      {kResolveTime} /* resolve_time_non_integrity */,
      {15} /* resolve_time_ratio */);
}

// This test simulates successful address queries and an INTEGRITY query that
// timed out.
TEST_P(HttpssvcMetricsTest, AddressAndIntegrityTimedOut) {
  if (!config().enabled || !config().use_integrity) {
    VerifyMetricsForExpectIntact();
    VerifyMetricsForExpectNoerror();
    return;
  }
  const base::TimeDelta kResolveTime = base::TimeDelta::FromMilliseconds(10);
  const base::TimeDelta kResolveTimeIntegrity =
      base::TimeDelta::FromMilliseconds(15);
  base::Optional<HttpssvcMetrics> metrics(querying_experimental_);
  metrics->SaveForIntegrity(base::nullopt, HttpssvcDnsRcode::kTimedOut, {},
                            kResolveTimeIntegrity);
  metrics->SaveForNonIntegrity(base::nullopt, kResolveTime,
                               HttpssvcDnsRcode::kNoError);
  metrics.reset();  // Record the metrics to UMA.

  if (querying_experimental_) {
    VerifyMetricsForExpectIntact(
        {HttpssvcDnsRcode::kTimedOut} /* rcode */,
        // "Integrity" metric is omitted because the RCODE is not NOERROR.
        base::nullopt /* integrity */, base::nullopt /* record_with_error */,
        {kResolveTimeIntegrity} /* resolve_time_integrity */,
        {kResolveTime} /* resolve_time_non_integrity */,
        {15} /* resolve_time_ratio */);

    VerifyMetricsForExpectNoerror();
    return;
  }

  VerifyMetricsForExpectIntact();

  VerifyMetricsForExpectNoerror(
      {HttpssvcDnsRcode::kTimedOut} /* rcode */,
      base::nullopt /* record_received */,
      {kResolveTimeIntegrity} /* resolve_time_integrity */,
      {kResolveTime} /* resolve_time_non_integrity */,
      {15} /* resolve_time_ratio */);
}

}  // namespace net