// Copyright 2018 The Chromium OS 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 <string>
#include <utility>

#include <base/json/json_reader.h>
#include <base/values.h>
#include <brillo/map_utils.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "runtime_probe/probe_result_checker.h"

namespace runtime_probe {

typedef FieldConverter::ReturnCode ReturnCode;

TEST(StringFieldConverterTest, TestIntToString) {
  base::Value dict_value(base::Value::Type::DICTIONARY);
  dict_value.SetIntKey("key", 123);

  auto converter = StringFieldConverter::Build("");

  ASSERT_EQ(converter->Convert("key", &dict_value), ReturnCode::OK)
      << "failed to convert 123 to string";

  auto* string_value = dict_value.FindStringKey("key");
  ASSERT_NE(string_value, nullptr);
  ASSERT_EQ(*string_value, "123");
}

TEST(StringFieldConverterTest, TestInvalidRegexPattern) {
  auto invalid = StringFieldConverter::Build("!re hello[");
  ASSERT_EQ(invalid, nullptr);

  auto valid = StringFieldConverter::Build("!eq hello[");
  ASSERT_TRUE(valid);
}

TEST(IntegerFieldConverterTest, TestStringToInt) {
  for (const auto s : {"123", "  123", "123  ", "  123  "}) {
    base::Value dict_value(base::Value::Type::DICTIONARY);
    dict_value.SetStringKey("key", s);

    auto converter = IntegerFieldConverter::Build("");

    ASSERT_EQ(converter->Convert("key", &dict_value), ReturnCode::OK)
        << "failed to convert string: " << s;

    auto int_value = dict_value.FindIntKey("key");
    ASSERT_TRUE(int_value.has_value());
    ASSERT_EQ(*int_value, 123) << s << " is not converted to 123";
  }
}

TEST(HexFieldConverterTest, TestHexStringToDecString) {
  static const struct {
    std::string input;
    std::string output;
  } cases[] = {
      {"7b", "123"},
      {"0x7b", "123"},
      {"  0x7b", "123"},
      {"  0x7b  ", "123"},
      {"0x7b  ", "123"},
      {"-0x7b", "-123"},
      {"0x80000000", "2147483648"},
      {"-0x80000000", "-2147483648"},
  };
  for (const auto& [in, out] : cases) {
    base::Value dict_value(base::Value::Type::DICTIONARY);
    dict_value.SetStringKey("key", in);

    auto converter = HexFieldConverter::Build("");

    ASSERT_EQ(converter->Convert("key", &dict_value), ReturnCode::OK)
        << "failed to convert string: \"" << in << "\"";

    auto* string_value = dict_value.FindStringKey("key");
    ASSERT_NE(string_value, nullptr);
    ASSERT_EQ(*string_value, out)
        << "\"" << in << "\" is not converted to " << out;
  }
}

TEST(HexFieldConverterTest, TestIntToDecString) {
  static const struct {
    int input;
    std::string output;
  } cases[] = {
      {0x7b, "123"},
      {-0x7b, "-123"},
  };
  for (const auto& [in, out] : cases) {
    base::Value dict_value(base::Value::Type::DICTIONARY);
    dict_value.SetIntKey("key", in);

    auto converter = HexFieldConverter::Build("");

    ASSERT_EQ(converter->Convert("key", &dict_value), ReturnCode::OK)
        << "failed to convert string: " << in;

    auto* string_value = dict_value.FindStringKey("key");
    ASSERT_NE(string_value, nullptr);
    ASSERT_EQ(*string_value, out) << in << " is not converted to " << out;
  }
}

TEST(IntegerFieldConverterTest, TestDoubleToInt) {
  double v = 123.5;
  base::Value dict_value(base::Value::Type::DICTIONARY);
  dict_value.SetDoubleKey("key", v);

  auto converter = IntegerFieldConverter::Build("");

  ASSERT_EQ(converter->Convert("key", &dict_value), ReturnCode::OK)
      << "failed to convert double";

  auto int_value = dict_value.FindIntKey("key");
  ASSERT_TRUE(int_value.has_value());
  ASSERT_EQ(*int_value, 123) << v << " is not converted to 123";
}

TEST(DoubleFieldConverterTest, TestStringToDouble) {
  for (const auto s : {"123.5", "  123.5", "123.5  ", "  123.5  "}) {
    base::Value dict_value(base::Value::Type::DICTIONARY);
    dict_value.SetStringKey("key", s);

    auto converter = DoubleFieldConverter::Build("");

    ASSERT_EQ(converter->Convert("key", &dict_value), ReturnCode::OK)
        << "failed to convert string: " << s;

    auto double_value = dict_value.FindDoubleKey("key");
    ASSERT_TRUE(double_value.has_value());
    ASSERT_EQ(*double_value, 123.5) << s << " is not converted to 123.5";
  }
}

TEST(DoubleFieldConverterTest, TestInvalidStringToDouble) {
  for (const auto s : {"this is not double", "", "   "}) {
    base::Value dict_value(base::Value::Type::DICTIONARY);
    dict_value.SetStringKey("key", s);

    auto converter = DoubleFieldConverter::Build("");

    ASSERT_EQ(converter->Convert("key", &dict_value),
              ReturnCode::INCOMPATIBLE_VALUE)
        << "Converting " << s << " to double should fail";
  }
}

TEST(StringFieldConverterTest, TestValidateRule) {
  const auto json_string = R"({
    "0": "hello world",
    "1": "hello ???",
    "2": "??? hello ???",
    "3": "??? hello"
  })";
  auto dict_value = base::JSONReader::Read(json_string);
  ASSERT_TRUE(dict_value.has_value());
  ASSERT_TRUE(dict_value->is_dict());
  {
    auto converter = StringFieldConverter::Build("!ne hello world");
    ASSERT_EQ(converter->operator_, ValidatorOperator::NE);
    ASSERT_EQ(converter->regex_, nullptr);
    ASSERT_EQ(converter->operand_, "hello world");
    ASSERT_EQ(converter->Validate("0", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("1", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("2", &*dict_value), ReturnCode::OK);
  }
  {
    auto converter = StringFieldConverter::Build("!eq hello world");
    ASSERT_EQ(converter->operator_, ValidatorOperator::EQ);
    ASSERT_EQ(converter->regex_, nullptr);
    ASSERT_EQ(converter->operand_, "hello world");
    ASSERT_EQ(converter->Validate("0", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("1", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("2", &*dict_value),
              ReturnCode::INVALID_VALUE);
  }
  {
    auto converter = StringFieldConverter::Build("!re hello .*");
    ASSERT_EQ(converter->operator_, ValidatorOperator::RE);
    ASSERT_EQ(converter->regex_->pattern(), "hello .*");
    ASSERT_EQ(converter->Validate("0", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("1", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("2", &*dict_value),
              ReturnCode::INVALID_VALUE);
  }
  {
    auto converter = StringFieldConverter::Build("!re .* hello");
    ASSERT_EQ(converter->operator_, ValidatorOperator::RE);
    ASSERT_EQ(converter->regex_->pattern(), ".* hello");
    ASSERT_EQ(converter->Validate("0", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("1", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("2", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("3", &*dict_value), ReturnCode::OK);
  }
}

TEST(IntegerFieldConverterTest, TestValidateRule) {
  const auto json_string = R"({
    "0": 0,
    "1": 1,
    "2": 2
  })";
  auto dict_value = base::JSONReader::Read(json_string);
  ASSERT_TRUE(dict_value.has_value());
  ASSERT_TRUE(dict_value->is_dict());
  {
    auto converter = IntegerFieldConverter::Build("!ne 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::NE);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("1", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("2", &*dict_value), ReturnCode::OK);
  }
  {
    auto converter = IntegerFieldConverter::Build("!eq 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::EQ);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("1", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("2", &*dict_value),
              ReturnCode::INVALID_VALUE);
  }
  {
    auto converter = IntegerFieldConverter::Build("!gt 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::GT);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("1", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("2", &*dict_value), ReturnCode::OK);
  }
  {
    auto converter = IntegerFieldConverter::Build("!ge 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::GE);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("1", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("2", &*dict_value), ReturnCode::OK);
  }
  {
    auto converter = IntegerFieldConverter::Build("!lt 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::LT);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("1", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("2", &*dict_value),
              ReturnCode::INVALID_VALUE);
  }
  {
    auto converter = IntegerFieldConverter::Build("!le 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::LE);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("1", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("2", &*dict_value),
              ReturnCode::INVALID_VALUE);
  }
}

TEST(HexFieldConverterTest, TestValidateRule) {
  const auto json_string = R"({
    "0": 0,
    "1": 1,
    "2": 2
  })";
  auto dict_value = base::JSONReader::Read(json_string);
  ASSERT_TRUE(dict_value.has_value());
  ASSERT_TRUE(dict_value->is_dict());
  {
    auto converter = HexFieldConverter::Build("!ne 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::NE);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("1", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("2", &*dict_value), ReturnCode::OK);
  }
  {
    auto converter = HexFieldConverter::Build("!eq 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::EQ);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("1", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("2", &*dict_value),
              ReturnCode::INVALID_VALUE);
  }
  {
    auto converter = HexFieldConverter::Build("!gt 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::GT);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("1", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("2", &*dict_value), ReturnCode::OK);
  }
  {
    auto converter = HexFieldConverter::Build("!ge 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::GE);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("1", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("2", &*dict_value), ReturnCode::OK);
  }
  {
    auto converter = HexFieldConverter::Build("!lt 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::LT);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("1", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("2", &*dict_value),
              ReturnCode::INVALID_VALUE);
  }
  {
    auto converter = HexFieldConverter::Build("!le 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::LE);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("1", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("2", &*dict_value),
              ReturnCode::INVALID_VALUE);
  }
}

TEST(DoubleFieldConverterTest, TestValidateRule) {
  const auto json_string = R"({
    "0": 0,
    "1": 1,
    "2": 2
  })";
  auto dict_value = base::JSONReader::Read(json_string);
  ASSERT_TRUE(dict_value.has_value());
  ASSERT_TRUE(dict_value->is_dict());
  {
    auto converter = DoubleFieldConverter::Build("!ne 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::NE);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("1", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("2", &*dict_value), ReturnCode::OK);
  }
  {
    auto converter = DoubleFieldConverter::Build("!eq 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::EQ);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("1", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("2", &*dict_value),
              ReturnCode::INVALID_VALUE);
  }
  {
    auto converter = DoubleFieldConverter::Build("!gt 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::GT);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("1", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("2", &*dict_value), ReturnCode::OK);
  }
  {
    auto converter = DoubleFieldConverter::Build("!ge 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::GE);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("1", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("2", &*dict_value), ReturnCode::OK);
  }
  {
    auto converter = DoubleFieldConverter::Build("!lt 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::LT);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("1", &*dict_value),
              ReturnCode::INVALID_VALUE);
    ASSERT_EQ(converter->Validate("2", &*dict_value),
              ReturnCode::INVALID_VALUE);
  }
  {
    auto converter = DoubleFieldConverter::Build("!le 1");
    ASSERT_EQ(converter->operator_, ValidatorOperator::LE);
    ASSERT_EQ(converter->operand_, 1);
    ASSERT_EQ(converter->Validate("0", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("1", &*dict_value), ReturnCode::OK);
    ASSERT_EQ(converter->Validate("2", &*dict_value),
              ReturnCode::INVALID_VALUE);
  }
}

TEST(ProbeResultCheckerTest, TestFromValue) {
  const auto json_string = R"({
    "string_field": [true, "str"],
    "string_field_exact_match": [true, "str", "!eq xx[yy"],
    "string_field_with_validate_rule": [true, "str", "!re hello_.*"],
    "int_field": [true, "int"],
    "double_field": [true, "double"],
    "hex_field": [false, "hex"]
  })";
  auto dict_value = base::JSONReader::Read(json_string);
  ASSERT_TRUE(dict_value.has_value());
  ASSERT_TRUE(dict_value->is_dict());

  auto expect_fields = ProbeResultChecker::FromValue(*dict_value);
  ASSERT_TRUE(expect_fields.get());

  const auto& required = expect_fields->required_fields_;
  ASSERT_THAT(brillo::GetMapKeys(required),
              ::testing::UnorderedElementsAre("string_field",
                                              "string_field_exact_match",
                                              "string_field_with_validate_rule",
                                              "int_field", "double_field"));
  ASSERT_TRUE(
      dynamic_cast<StringFieldConverter*>(required.at("string_field").get()));
  ASSERT_TRUE(dynamic_cast<StringFieldConverter*>(
      required.at("string_field_exact_match").get()));
  ASSERT_TRUE(dynamic_cast<StringFieldConverter*>(
      required.at("string_field_exact_match").get()));
  ASSERT_TRUE(dynamic_cast<StringFieldConverter*>(
      required.at("string_field_with_validate_rule").get()));
  ASSERT_TRUE(
      dynamic_cast<IntegerFieldConverter*>(required.at("int_field").get()));
  ASSERT_TRUE(
      dynamic_cast<DoubleFieldConverter*>(required.at("double_field").get()));

  const auto& optional = expect_fields->optional_fields_;
  ASSERT_THAT(brillo::GetMapKeys(optional),
              ::testing::UnorderedElementsAre("hex_field"));
  ASSERT_TRUE(dynamic_cast<HexFieldConverter*>(optional.at("hex_field").get()));
}

TEST(ProbeResultCheckerTest, TestApplySuccess) {
  const auto expect_string = R"({
    "str": [true, "str"],
    "int": [true, "int"],
    "hex": [true, "hex"],
    "double": [true, "double"]
  })";

  const auto probe_result_string = R"({
    "str": "string result",
    "int": "1024",
    "hex": "0x7b",
    "double": "1e2"
  })";

  auto expect = base::JSONReader::Read(expect_string);
  ASSERT_TRUE(expect.has_value());
  ASSERT_TRUE(expect->is_dict());

  auto probe_result = base::JSONReader::Read(probe_result_string);
  ASSERT_TRUE(probe_result.has_value());
  ASSERT_TRUE(probe_result->is_dict());

  auto checker = ProbeResultChecker::FromValue(*expect);

  ASSERT_TRUE(checker->Apply(&*probe_result));

  auto* str_value = probe_result->FindStringKey("str");
  ASSERT_NE(str_value, nullptr);
  ASSERT_EQ(*str_value, "string result");

  auto int_value = probe_result->FindIntKey("int");
  ASSERT_TRUE(int_value.has_value());
  ASSERT_EQ(*int_value, 1024);

  auto* hex_value = probe_result->FindStringKey("hex");
  ASSERT_NE(hex_value, nullptr);
  ASSERT_EQ(*hex_value, "123");

  auto double_value = probe_result->FindDoubleKey("double");
  ASSERT_TRUE(double_value.has_value());
  ASSERT_EQ(*double_value, 100);
}

TEST(ProbeResultCheckerTest, TestApplyWithLimitsSuccess) {
  const auto expect_string = R"({
    "str": [true, "str", "!eq string result"],
    "int": [true, "int", "!gt 1000"],
    "hex": [true, "hex", "!ne 0x0"],
    "double": [true, "double", "!lt 1e3"]
  })";

  const auto probe_result_string = R"({
    "str": "string result",
    "int": "1024",
    "hex": "0x7b",
    "double": "1e2"
  })";

  auto expect = base::JSONReader::Read(expect_string);
  ASSERT_TRUE(expect.has_value());
  ASSERT_TRUE(expect->is_dict());

  auto probe_result = base::JSONReader::Read(probe_result_string);
  ASSERT_TRUE(probe_result.has_value());
  ASSERT_TRUE(probe_result->is_dict());

  auto checker = ProbeResultChecker::FromValue(*expect);

  ASSERT_TRUE(checker->Apply(&*probe_result));

  auto* str_value = probe_result->FindStringKey("str");
  ASSERT_NE(str_value, nullptr);
  ASSERT_EQ(*str_value, "string result");

  auto int_value = probe_result->FindIntKey("int");
  ASSERT_TRUE(int_value.has_value());
  ASSERT_EQ(*int_value, 1024);

  auto* hex_value = probe_result->FindStringKey("hex");
  ASSERT_NE(hex_value, nullptr);
  ASSERT_EQ(*hex_value, "123");

  auto double_value = probe_result->FindDoubleKey("double");
  ASSERT_TRUE(double_value.has_value());
  ASSERT_EQ(*double_value, 100);
}

TEST(ProbeResultCheckerTest, TestApplyWithLimitsFail) {
  // For each field converter, |TestValidateRule| should already check each kind
  // of operators.  This function only checks if |Apply| function would return
  // |false| if any of the fields is invalid.
  const auto expect_string = R"({
    "str": [true, "str", "!eq string result"],
    "int": [true, "int", "!gt 1000"],
    "hex": [true, "hex", "!ne 0x0"],
    "double": [true, "double", "!lt 1e3"]
  })";
  const auto probe_result_string = R"({
    "str": "This doesn't match!",
    "int": "1024",
    "hex": "0x7b",
    "double": "1e2"
  })";

  auto expect = base::JSONReader::Read(expect_string);
  ASSERT_TRUE(expect.has_value());
  ASSERT_TRUE(expect->is_dict());

  auto probe_result = base::JSONReader::Read(probe_result_string);
  ASSERT_TRUE(probe_result.has_value());
  ASSERT_TRUE(probe_result->is_dict());

  auto checker = ProbeResultChecker::FromValue(*expect);

  ASSERT_FALSE(checker->Apply(&*probe_result));
}

}  // namespace runtime_probe