// Copyright 2022 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/extensions/api/omnibox/suggestion_parser.h"

#include <memory>
#include <string_view>

#include "base/run_loop.h"
#include "base/test/bind.h"
#include "base/test/test_future.h"
#include "content/public/test/browser_task_environment.h"
#include "extensions/buildflags/buildflags.h"
#include "services/data_decoder/public/cpp/test_support/in_process_data_decoder.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

static_assert(BUILDFLAG(ENABLE_EXTENSIONS_CORE));

namespace extensions {

namespace {

constexpr api::omnibox::DescriptionStyleType kMatch =
    api::omnibox::DescriptionStyleType::kMatch;
constexpr api::omnibox::DescriptionStyleType kDim =
    api::omnibox::DescriptionStyleType::kDim;
constexpr api::omnibox::DescriptionStyleType kUrl =
    api::omnibox::DescriptionStyleType::kUrl;

// A custom matcher for an omnibox::MatchClassification.
testing::Matcher<api::omnibox::MatchClassification> GetStyleMatcher(
    api::omnibox::DescriptionStyleType type,
    int offset,
    int length) {
  return testing::AllOf(
      ::testing::Field(&api::omnibox::MatchClassification::type,
                       ::testing::Eq(type)),
      ::testing::Field(&api::omnibox::MatchClassification::offset,
                       ::testing::Eq(offset)),
      ::testing::Field(&api::omnibox::MatchClassification::length,
                       ::testing::Eq(length)));
}

}  // namespace

class SuggestionParserUnitTest : public testing::Test {
 public:
  SuggestionParserUnitTest() = default;
  ~SuggestionParserUnitTest() override = default;

  // A helper method to synchronously parses `str` as input and return the
  // result.
  DescriptionAndStyles ParseSingleInput(std::string_view str) {
    DescriptionAndStylesResult result;
    ParseImpl({str}, &result);
    if (result.descriptions_and_styles.size() != 1) {
      ADD_FAILURE() << "Failed to parse single input. Resulting size: "
                    << result.descriptions_and_styles.size();
      return DescriptionAndStyles();
    }

    return std::move(result.descriptions_and_styles[0]);
  }
  // Same as above, accepting multiple string inputs.
  std::vector<DescriptionAndStyles> ParseInputs(
      const std::vector<std::string_view>& strs) {
    DescriptionAndStylesResult result;
    ParseImpl(strs, &result);
    EXPECT_EQ(std::string(), result.error);
    return std::move(result.descriptions_and_styles);
  }

  // Returns the parsing error from attempting to parse `strs`.
  std::string GetParseError(const std::vector<std::string_view>& strs) {
    DescriptionAndStylesResult result;
    ParseImpl(strs, &result);
    return result.error;
  }

 private:
  void ParseImpl(const std::vector<std::string_view>& strs,
                 DescriptionAndStylesResult* result_out) {
    base::test::TestFuture<DescriptionAndStylesResult> parse_future;
    if (strs.size() == 1) {
      ParseDescriptionAndStyles(strs[0], parse_future.GetCallback());
    } else {
      ParseDescriptionsAndStyles(strs, parse_future.GetCallback());
    }

    *result_out = parse_future.Take();
    // Exactly one of error and result should be populated.
    bool has_parsed_entries = !result_out->descriptions_and_styles.empty();
    bool has_error = !result_out->error.empty();
    EXPECT_TRUE(has_parsed_entries ^ has_error)
        << has_parsed_entries << ", " << has_error;
  }

  content::BrowserTaskEnvironment task_environment_;
  data_decoder::test::InProcessDataDecoder data_decoder_;
};

// Tests a number of basic cases for XML suggestion parsing.
TEST_F(SuggestionParserUnitTest, BasicCases) {
  {
    DescriptionAndStyles result =
        ParseSingleInput("hello <match>match</match> world");
    EXPECT_EQ(u"hello match world", result.description);
    EXPECT_THAT(result.styles,
                testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
  }
  {
    DescriptionAndStyles result = ParseSingleInput(
        "<dim>hello</dim> <match>match</match> <url>world</url>");
    EXPECT_EQ(u"hello match world", result.description);
    EXPECT_THAT(result.styles,
                testing::ElementsAre(GetStyleMatcher(kDim, 0, 5),
                                     GetStyleMatcher(kMatch, 6, 5),
                                     GetStyleMatcher(kUrl, 12, 5)));
  }
  {
    DescriptionAndStyles result =
        ParseSingleInput("hello <dim>dim <match>dimmed match</match></dim>");
    EXPECT_EQ(u"hello dim dimmed match", result.description);
    EXPECT_THAT(result.styles,
                testing::ElementsAre(GetStyleMatcher(kDim, 6, 16),
                                     GetStyleMatcher(kMatch, 10, 12)));
  }
}

// Tests parsing multiple entries passed to the suggestion parsing.
TEST_F(SuggestionParserUnitTest, MultipleEntries) {
  {
    std::vector<DescriptionAndStyles> result = ParseInputs(
        {"first <match>match</match> entry", "second <url>url</url> entry",
         "final <dim>dim</dim> entry"});
    ASSERT_EQ(3u, result.size());
    EXPECT_EQ(u"first match entry", result[0].description);
    EXPECT_THAT(result[0].styles,
                testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
    EXPECT_EQ(u"second url entry", result[1].description);
    EXPECT_THAT(result[1].styles,
                testing::ElementsAre(GetStyleMatcher(kUrl, 7, 3)));
    EXPECT_EQ(u"final dim entry", result[2].description);
    EXPECT_THAT(result[2].styles,
                testing::ElementsAre(GetStyleMatcher(kDim, 6, 3)));
  }
  {
    // A fun "hack" that extensions can pull: When parsing multiple suggestions,
    // we join them together with each as an element with the
    // "internal-suggestion" tag. This means that, if an extension wanted to,
    // it could inject inner </internal-suggestion> tags to synthesize extra
    // suggestions. This isn't a security risk at all - it can't do anything
    // besides get extra suggestions, and we don't limit the number of
    // suggestions extensions can provide. There's no reason for extensions to
    // do this, but we add a test as documentation of this "quirk".
    constexpr char kJointSuggestion[] =
        "first <match>match</match></internal-suggestion><internal-suggestion>"
        "second <url>url</url>";
    std::vector<DescriptionAndStyles> result =
        ParseInputs({kJointSuggestion, "final <dim>dim</dim>"});
    ASSERT_EQ(3u, result.size());
    EXPECT_EQ(u"first match", result[0].description);
    EXPECT_THAT(result[0].styles,
                testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
    EXPECT_EQ(u"second url", result[1].description);
    EXPECT_THAT(result[1].styles,
                testing::ElementsAre(GetStyleMatcher(kUrl, 7, 3)));
    EXPECT_EQ(u"final dim", result[2].description);
    EXPECT_THAT(result[2].styles,
                testing::ElementsAre(GetStyleMatcher(kDim, 6, 3)));
  }
}

// Tests cases where XML parsing is expected to fail.
TEST_F(SuggestionParserUnitTest, ParsingFails) {
  // Note: These aren't expected to be terribly robust tests, since XML parsing
  // is exercised significantly more in the XmlParser-related tests.
  EXPECT_THAT(GetParseError({"<dim>no closing tag"}),
              testing::HasSubstr("Opening and ending tag mismatch"));
  EXPECT_THAT(GetParseError({"<dim>hello <url>foo</dim> world</url>"}),
              testing::HasSubstr("Opening and ending tag mismatch"));
  // Test an error in one of three inputs.
  EXPECT_THAT(GetParseError({"first <match>match</match> entry",
                             "second <url>url<url> entry",
                             "final <dim>dim</dim> entry"}),
              testing::HasSubstr("Opening and ending tag mismatch"));

  // Test "injection" attacks. Because we synthesize XML documents for and don't
  // do any escaping for the element tags we use ("fragment" and
  // "internal-suggestion"), extensions can prematurely end our tags. This is
  // safe; it just results in invalid XML.
  EXPECT_THAT(GetParseError({"first </fragment>DROP TABLE supersecret"}),
              testing::HasSubstr("Extra content at the end of the document"));
  EXPECT_THAT(
      GetParseError(
          {"first "
           "</internal-suggestion></fragment>fetch('https://example.com');",
           "second entry"}),
      testing::HasSubstr("Extra content at the end of the document"));

  // Test a suggestion that would add a second "fragment" element to the
  // parsed XML. The XML that ends up being parsed is:
  // <fragment>first suggestion</fragment>
  // <fragment>second</fragment>
  EXPECT_THAT(
      GetParseError({"first suggestion</fragment><fragment>second</fragment>"}),
      testing::HasSubstr("Extra content at the end of the document"));

  // Test an injection that inserts unexpected children in our synthesized XML
  // document. The XML that ends up being parsed is:
  // <fragment>
  //   <internal-suggestion>first</internal-suggestion>
  //   <other-class>Foobar</other-class>   <-- This was snuck in.
  //   <internal-suggestion>second></internal-suggestion>
  //   <internal-suggestion>final</internal-suggestion>
  // </fragment>
  // This is actually valid XML, and we reject it with our generic error in the
  // handling of the parsed value.
  {
    constexpr char kSneakyXML[] =
        "first</internal-suggestion><other-class>Foobar</other-class>"
        "<internal-suggestion>second";
    EXPECT_EQ("Invalid XML", GetParseError({kSneakyXML, "final suggestion"}));
  }
}

// Tests that XML strings are properly sanitized from any forbidden characters.
TEST_F(SuggestionParserUnitTest, Sanitization) {
  {
    DescriptionAndStyles result =
        ParseSingleInput("  hello <match>match</match> world");
    EXPECT_EQ(u"hello match world", result.description);
    EXPECT_THAT(result.styles,
                testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
  }
  {
    DescriptionAndStyles result =
        ParseSingleInput("hell\ro <match>ma\ttch</match> wor\nld");
    EXPECT_EQ(u"hello match world", result.description);
    EXPECT_THAT(result.styles,
                testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
  }
}

// Tests that unknown tag types and attributes are properly ignored.
TEST_F(SuggestionParserUnitTest, UnknownTagsAndAttributesAreIgnored) {
  {
    DescriptionAndStyles result =
        ParseSingleInput("hello <match some-attr=\"foo\">match</match> world");
    EXPECT_EQ(u"hello match world", result.description);
    EXPECT_THAT(result.styles,
                testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
  }
  {
    DescriptionAndStyles result =
        ParseSingleInput("hello <unknown>match</unknown> world");
    EXPECT_EQ(u"hello match world", result.description);
    EXPECT_THAT(result.styles, testing::IsEmpty());
  }
}

}  // namespace extensions