Support inexact path matching when extracting terms from Template URL.

components/search_engines/template_url_unittest.cc

 // Copyright 2014 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 <stddef.h>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 699 matching lines @@
   GURL result(url.url_ref().ReplaceSearchTerms(args, search_terms_data_));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://bar/?rlz=" + base::UTF16ToUTF8(rlz_string) + "&x",
             result.spec());
 }
 
 TEST_F(TemplateURLTest, HostAndSearchTermKey) {
   struct TestData {
     const std::string url;
     const std::string host;
+    const url::Parsed::ComponentType location;
     const std::string path;
+    const bool ignore_path_ending;
     const std::string search_term_key;
+    const std::string search_term_value_prefix;
+    const std::string search_term_value_suffix;
   } test_data[] = {
-    { "http://blah/?foo=bar&q={searchTerms}&b=x", "blah", "/", "q"},
-    { "http://blah/{searchTerms}", "blah", "/", ""},
+    { "http://blah/?foo=bar&q={searchTerms}&b=x",
+      "blah", url::Parsed::QUERY, "/", false, "q", "", ""},
+
+    { "http://blah/?foo=bar#q={searchTerms}&b=x",
+      "blah", url::Parsed::REF, "/", false, "q", "", ""},
+
+    { "http://blah/{searchTerms}",
+      "blah", url::Parsed::PATH, "/", false, "", "/", ""},
+
+    { "http://blah/{searchTerms}/",
+      "blah", url::Parsed::PATH, "//", false, "", "/", "/"},
+
+    { "http://blah/begin/{searchTerms}/end",
+      "blah", url::Parsed::PATH, "/begin//end", false, "", "/begin/", "/end"},
 
     // No term should result in empty values.
-    { "http://blah/", "", "", ""},
+    { "http://blah/", "", url::Parsed::QUERY, "", false, "", "", ""},
+
+    // Term in the host shouldn't match.
+    { "http://{searchTerms}", "", url::Parsed::QUERY, "", false, "", "", "" },
+
+    // searchTerms is a key, not a value, so this should result in an empty
+    // value.
+    { "http://blah/?foo=bar#x=012345678901234&a=b&{searchTerms}=x",
+      "", url::Parsed::QUERY, "", false, "", "", "" },
 
     // Multiple terms should result in empty values.
-    { "http://blah/?q={searchTerms}&x={searchTerms}", "", "", ""},
+    { "http://blah/?q={searchTerms}&x={searchTerms}",
+      "", url::Parsed::QUERY, "", false, "", "", "" },
 
-    // Term in the host shouldn't match.
-    { "http://{searchTerms}", "", "", ""},
+    { "http://blah/{searchTerms}?q={searchTerms}",
+      "", url::Parsed::QUERY, "", false, "", "", "" },
 
-    { "http://blah/?q={searchTerms}", "blah", "/", "q"},
-    { "https://blah/?q={searchTerms}", "blah", "/", "q"},
+    { "http://blah/{searchTerms}#x={searchTerms}",
+      "", url::Parsed::QUERY, "", false, "", "", "" },
 
-    // Single term with extra chars in value should match.
-    { "http://blah/?q=stock:{searchTerms}", "blah", "/", "q"},
+    // Fixed prefixes and suffixes in query or ref.
+    { "http://blah/?q=stock:{searchTerms}",
+      "blah", url::Parsed::QUERY, "/", false, "q", "stock:", ""},
+
+    { "http://www.example.com/?q=chromium-{searchTerms}@chromium.org",
+      "www.example.com", url::Parsed::QUERY, "/", false, "q", "chromium-",
+      "@chromium.org" },
+
+    { "http://www.example.com/#q=chromium-{searchTerms}@chromium.org",
+      "www.example.com", url::Parsed::REF, "/", false, "q", "chromium-",
+      "@chromium.org" },
+
+    { "http://www.example.com/chromium-{searchTerms}@chromium.org/info",
+      "www.example.com", url::Parsed::PATH, "/chromium-@chromium.org/info",
+      false, "", "/chromium-", "@chromium.org/info" },
+
+    // Ignoring ending of path.
+    { "http://blah/{google:ignorePathEnding}?q={searchTerms}",
+      "blah", url::Parsed::QUERY, "/", true, "q", "", "" },
+
+    { "http://blah/path/{google:ignorePathEnding}/end#q={searchTerms}",
+      "blah", url::Parsed::REF, "/path/", true, "q", "", "" },
+
+    { "http://blah/path/{searchTerms}/{google:ignorePathEnding}",
+      "blah", url::Parsed::PATH, "/path//", true, "", "/path/", "/" },
+
+    { "http://blah/path/{searchTerms}/data/{google:ignorePathEnding}",
+      "blah", url::Parsed::PATH, "/path//data/", true, "", "/path/", "/data/" },
+
+    { "http://blah/path/{searchTerms}{google:ignorePathEnding}",
+      "blah", url::Parsed::PATH, "/path/", false, "", "/path/", "" },
+
+    { "http://blah/path/{google:ignorePathEnding}{searchTerms}",
+      "", url::Parsed::QUERY, "", false, "", "", "" },
   };
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     TemplateURLData data;
     data.SetURL(test_data[i].url);
     TemplateURL url(data);
-    EXPECT_EQ(test_data[i].host, url.url_ref().GetHost(search_terms_data_));
-    EXPECT_EQ(test_data[i].path, url.url_ref().GetPath(search_terms_data_));
+    const TemplateURLRef& url_ref = url.url_ref();
+    EXPECT_EQ(test_data[i].host, url_ref.GetHost(search_terms_data_));
+    EXPECT_EQ(test_data[i].location,
+              url_ref.GetSearchTermKeyLocation(search_terms_data_));
+    EXPECT_EQ(test_data[i].path, url_ref.GetPath(search_terms_data_));
+    EXPECT_EQ(test_data[i].ignore_path_ending,
+              url_ref.GetIgnorePathEnding(search_terms_data_));
     EXPECT_EQ(test_data[i].search_term_key,
-              url.url_ref().GetSearchTermKey(search_terms_data_));
+              url_ref.GetSearchTermKey(search_terms_data_));
+    EXPECT_EQ(test_data[i].search_term_value_prefix,
+              url_ref.GetSearchTermValuePrefix(search_terms_data_));
+    EXPECT_EQ(test_data[i].search_term_value_suffix,
+              url_ref.GetSearchTermValueSuffix(search_terms_data_));
   }
 }
 
-TEST_F(TemplateURLTest, SearchTermKeyLocation) {
-  struct TestData {
-    const std::string url;
-    const url::Parsed::ComponentType location;
-    const std::string path;
-    size_t position_in_path;
-  } test_data[] = {
-    { "http://blah/{searchTerms}/", url::Parsed::PATH, "//", 1 },
-    { "http://blah/{searchTerms}", url::Parsed::PATH, "/", 1 },
-    { "http://blah/begin/{searchTerms}/end", url::Parsed::PATH, "/begin//end", 7 },
-
-    { "http://blah/?foo=bar&q={searchTerms}&b=x", url::Parsed::QUERY,
-      "/", std::string::npos },
-    { "http://blah/?foo=bar#x={searchTerms}&b=x", url::Parsed::REF,
-      "/", std::string::npos },
-    // searchTerms is a key, not a value, so this should result in an empty
-    // value.
-    { "http://blah/?foo=bar#x=012345678901234&a=b&{searchTerms}=x",
-      url::Parsed::QUERY, std::string(), std::string::npos },
-
-    // Multiple search terms should result in empty values.
-    { "http://blah/{searchTerms}?q={searchTerms}", url::Parsed::QUERY,
-      "", std::string::npos },
-    { "http://blah/{searchTerms}#x={searchTerms}", url::Parsed::QUERY,
-      "", std::string::npos },
-    { "http://blah/?q={searchTerms}#x={searchTerms}", url::Parsed::QUERY,
-      "", std::string::npos },
-  };
-
-  for (size_t i = 0; i < arraysize(test_data); ++i) {
-    TemplateURLData data;
-    data.SetURL(test_data[i].url);
-    TemplateURL url(data);
-    EXPECT_EQ(test_data[i].location,
-              url.url_ref().GetSearchTermKeyLocation(search_terms_data_));
-    EXPECT_EQ(test_data[i].path,
-              url.url_ref().GetPath(search_terms_data_));
-    EXPECT_EQ(test_data[i].position_in_path,
-              url.url_ref().GetSearchTermPositionInPath(search_terms_data_));
-  }
-}
-
 TEST_F(TemplateURLTest, GoogleBaseSuggestURL) {
   static const struct {
     const char* const base_url;
     const char* const base_suggest_url;
   } data[] = {
     { "http://google.com/", "http://google.com/complete/", },
     { "http://www.google.com/", "http://www.google.com/complete/", },
     { "http://www.google.co.uk/", "http://www.google.co.uk/complete/", },
     { "http://www.google.com.by/", "http://www.google.com.by/complete/", },
     { "http://google.com/intl/xx/", "http://google.com/complete/", },
@@ skipping 305 matching lines @@
 
   EXPECT_FALSE(url.ExtractSearchTermsFromURL(
       GURL("http://term-in-path.com/begin"), search_terms_data_, &result));
   EXPECT_EQ(base::string16(), result);
 
   EXPECT_FALSE(url.ExtractSearchTermsFromURL(
       GURL("http://term-in-path.com/end"), search_terms_data_, &result));
   EXPECT_EQ(base::string16(), result);
 }
 
+// Test that extracting search terms from URL works correctly when
+// the "{google:ignorePathEnding}" marker is contained in a search template.
+TEST_F(TemplateURLTest, ExtractSearchTermsFromURLWithIgnorePathEnding) {
+  struct TestCase {
+    std::string search_template;
+    GURL url;
+    bool result;
+    base::string16 search_terms;
+  };
+
+  const std::string template1 =
+      "http://h.com/begin/{google:ignorePathEnding}?q={searchTerms}";
+  const std::string template2 =
+      "http://h.com/begin/{searchTerms}/{google:ignorePathEnding}";
+  const std::string template3 =
+      "http://h.com/begin/{searchTerms}/mid/{google:ignorePathEnding}";
+
+  const TestCase test_cases[] = {
+    // Cases if "{searchTerms}" are located in query.
+    { template1, GURL("http://h.com/begin/blablabla?q=something"),
+      true, ASCIIToUTF16("something") },
+
+    { template1, GURL("http://h.com/begin/bla/bla/bla?q=anotherthing"),
+      true, ASCIIToUTF16("anotherthing") },
+
+    { template1, GURL("http://h.com/begin/?q=thirdthing"),
+      true, ASCIIToUTF16("thirdthing") },
+
+    { template1, GURL("http://h.com/begin?q=abc"), false, base::string16() },
+    { template1, GURL("http://h.com/about?q=abc"), false, base::string16() },
+    { template1, GURL("http://h.com?q=abc"), false, base::string16() },
+
+    // Cases if "{searchTerms}" are located in path.
+    { template2, GURL("http://h.com/begin/something/blablabla"),
+      true, ASCIIToUTF16("something") },
+
+    { template2, GURL("http://h.com/begin/anotherthing/bla/bla/bla"),
+      true, ASCIIToUTF16("anotherthing") },
+
+    { template2, GURL("http://h.com/begin/thirdthing/"),
+      true, ASCIIToUTF16("thirdthing") },
+
+    { template2, GURL("http://h.com/begin//"), false, base::string16() },
+    { template2, GURL("http://h.com/begin/abc"), false, base::string16() },
+    { template2, GURL("http://h.com/begin/"), false, base::string16() },
+    { template2, GURL("http://h.com/begin"), false, base::string16() },
+    { template2, GURL("http://h.com/begin"), false, base::string16() },
+    { template2, GURL("http://h.com/about"), false, base::string16() },
+    { template2, GURL("http://h.com"), false, base::string16() },
+
+    { template3, GURL("http://h.com/begin/bla/bla/mid/bla"),
+      true, ASCIIToUTF16("bla/bla") },
+    { template3, GURL("http://h.com/begin/bla/bla/mid/"),
+      true, ASCIIToUTF16("bla/bla") },
+  };
+
+  for (size_t i = 0; i != arraysize(test_cases); ++i) {
+    const TestCase& test_case = test_cases[i];
+    TemplateURLData data;
+    data.SetURL(test_case.search_template);
+    TemplateURL template_url(data);
+    base::string16 search_terms;
+    const bool result = template_url.ExtractSearchTermsFromURL(
+        test_case.url, search_terms_data_, &search_terms);
+    EXPECT_EQ(test_case.result, result) << "i=" << i;
+    EXPECT_EQ(test_case.search_terms, search_terms) << "i=" << i;
+  }
+}
+
 // Checks that the ExtractSearchTermsFromURL function works correctly
 // for urls containing non-latin characters in UTF8 encoding.
 TEST_F(TemplateURLTest, ExtractSearchTermsFromUTF8URL) {
   TemplateURLData data;
   data.SetURL("http://utf-8.ru/?q={searchTerms}");
   data.alternate_urls.push_back("http://utf-8.ru/#q={searchTerms}");
   data.alternate_urls.push_back("http://utf-8.ru/path/{searchTerms}");
   TemplateURL url(data);
   base::string16 result;
 
@@ skipping 674 matching lines @@
       GURL("https://www.foo.org/search?q=Y+Z"),
       search_terms_data_, &search_terms));
   EXPECT_EQ(base::ASCIIToUTF16("Y Z"), search_terms);
   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
       GURL("https://www.foo.org/s#q=123"),
       search_terms_data_, &search_terms));
   EXPECT_EQ(base::ASCIIToUTF16("123"), search_terms);
 
   search_terms_data_.set_google_base_url("http://www.google.com/");
 }