components/omnibox/base_search_provider_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/omnibox/base_search_provider.h"
   6
   7 #include "base/strings/string16.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "components/omnibox/autocomplete_match.h"
  10 #include "components/omnibox/autocomplete_match_type.h"
  11 #include "components/omnibox/autocomplete_provider_client.h"
  12 #include "components/omnibox/autocomplete_scheme_classifier.h"
  13 #include "components/omnibox/search_suggestion_parser.h"
  14 #include "components/omnibox/suggestion_answer.h"
  15 #include "components/search_engines/search_terms_data.h"
  16 #include "components/search_engines/template_url_service.h"
  17 #include "components/search_engines/template_url_service_client.h"
  18 #include "testing/gmock/include/gmock/gmock.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 using testing::NiceMock;
  22 using testing::Return;
  23 using testing::_;
  24
  25 class MockAutocompleteProviderClient : public AutocompleteProviderClient {
  26  public:
  27   MockAutocompleteProviderClient() {}
  28   MOCK_METHOD0(RequestContext, net::URLRequestContextGetter*());
  29   MOCK_METHOD0(IsOffTheRecord, bool());
  30   MOCK_METHOD0(AcceptLanguages, std::string());
  31   MOCK_METHOD0(SearchSuggestEnabled, bool());
  32   MOCK_METHOD0(ShowBookmarkBar, bool());
  33   MOCK_METHOD0(SchemeClassifier, const AutocompleteSchemeClassifier&());
  34   MOCK_METHOD6(
  35       Classify,
  36       void(const base::string16& text,
  37            bool prefer_keyword,
  38            bool allow_exact_keyword_match,
  39            metrics::OmniboxEventProto::PageClassification page_classification,
  40            AutocompleteMatch* match,
  41            GURL* alternate_nav_url));
  42   MOCK_METHOD0(InMemoryDatabase, history::URLDatabase*());
  43   MOCK_METHOD2(DeleteMatchingURLsForKeywordFromHistory,
  44                void(history::KeywordID keyword_id, const base::string16& term));
  45   MOCK_METHOD0(TabSyncEnabledAndUnencrypted, bool());
  46   MOCK_METHOD1(PrefetchImage, void(const GURL& url));
  47
  48  private:
  49   DISALLOW_COPY_AND_ASSIGN(MockAutocompleteProviderClient);
  50 };
  51
  52 class TestBaseSearchProvider : public BaseSearchProvider {
  53  public:
  54   typedef BaseSearchProvider::MatchMap MatchMap;
  55
  56   // Note: Takes ownership of client. scoped_ptr<> would be the right way to
  57   // express that, but NiceMock<> can't forward a scoped_ptr.
  58   TestBaseSearchProvider(TemplateURLService* template_url_service,
  59                          AutocompleteProviderClient* client,
  60                          AutocompleteProvider::Type type)
  61       : BaseSearchProvider(template_url_service,
  62                            scoped_ptr<AutocompleteProviderClient>(client),
  63                            type) {}
  64   MOCK_METHOD1(DeleteMatch, void(const AutocompleteMatch& match));
  65   MOCK_CONST_METHOD1(AddProviderInfo, void(ProvidersInfo* provider_info));
  66   MOCK_CONST_METHOD1(GetTemplateURL, const TemplateURL*(bool is_keyword));
  67   MOCK_CONST_METHOD1(GetInput, const AutocompleteInput(bool is_keyword));
  68   MOCK_CONST_METHOD1(ShouldAppendExtraParams,
  69                      bool(const SearchSuggestionParser::SuggestResult& result));
  70   MOCK_METHOD1(RecordDeletionResult, void(bool success));
  71
  72   MOCK_METHOD2(Start,
  73                void(const AutocompleteInput& input, bool minimal_changes));
  74   void AddMatchToMap(const SearchSuggestionParser::SuggestResult& result,
  75                      const std::string& metadata,
  76                      int accepted_suggestion,
  77                      bool mark_as_deletable,
  78                      bool in_keyword_mode,
  79                      MatchMap* map) {
  80     BaseSearchProvider::AddMatchToMap(result,
  81                                       metadata,
  82                                       accepted_suggestion,
  83                                       mark_as_deletable,
  84                                       in_keyword_mode,
  85                                       map);
  86   }
  87
  88  protected:
  89   virtual ~TestBaseSearchProvider() {}
  90
  91  private:
  92   DISALLOW_COPY_AND_ASSIGN(TestBaseSearchProvider);
  93 };
  94
  95 class BaseSearchProviderTest : public testing::Test {
  96  public:
  97   ~BaseSearchProviderTest() override {}
  98
  99  protected:
 100   void SetUp() override {
 101     service_.reset(
 102         new TemplateURLService(NULL,
 103                                scoped_ptr<SearchTermsData>(new SearchTermsData),
 104                                NULL,
 105                                scoped_ptr<TemplateURLServiceClient>(),
 106                                NULL,
 107                                NULL,
 108                                base::Closure()));
 109     provider_ = new NiceMock<TestBaseSearchProvider>(
 110         service_.get(),
 111         new NiceMock<MockAutocompleteProviderClient>,
 112         AutocompleteProvider::TYPE_SEARCH);
 113   }
 114
 115   scoped_refptr<NiceMock<TestBaseSearchProvider> > provider_;
 116   scoped_ptr<TemplateURLService> service_;
 117 };
 118
 119 TEST_F(BaseSearchProviderTest, PreserveAnswersWhenDeduplicating) {
 120   TemplateURLData data;
 121   data.SetURL("http://foo.com/url?bar={searchTerms}");
 122   scoped_ptr<TemplateURL> template_url(new TemplateURL(data));
 123
 124   TestBaseSearchProvider::MatchMap map;
 125   base::string16 query = base::ASCIIToUTF16("weather los angeles");
 126   base::string16 answer_contents = base::ASCIIToUTF16("some answer content");
 127   base::string16 answer_type = base::ASCIIToUTF16("2334");
 128   scoped_ptr<SuggestionAnswer> answer(new SuggestionAnswer());
 129   answer->set_type(2334);
 130
 131   EXPECT_CALL(*provider_, GetInput(_))
 132       .WillRepeatedly(Return(AutocompleteInput()));
 133   EXPECT_CALL(*provider_, GetTemplateURL(_))
 134       .WillRepeatedly(Return(template_url.get()));
 135
 136   SearchSuggestionParser::SuggestResult more_relevant(
 137       query, AutocompleteMatchType::SEARCH_HISTORY, query, base::string16(),
 138       base::string16(), base::string16(), base::string16(), nullptr,
 139       std::string(), std::string(), false, 1300, true, false, query);
 140   provider_->AddMatchToMap(
 141       more_relevant, std::string(), TemplateURLRef::NO_SUGGESTION_CHOSEN,
 142       false, false, &map);
 143
 144   SearchSuggestionParser::SuggestResult less_relevant(
 145       query, AutocompleteMatchType::SEARCH_SUGGEST, query, base::string16(),
 146       base::string16(), answer_contents, answer_type,
 147       SuggestionAnswer::copy(answer.get()), std::string(), std::string(),
 148       false, 850, true, false, query);
 149   provider_->AddMatchToMap(
 150       less_relevant, std::string(), TemplateURLRef::NO_SUGGESTION_CHOSEN,
 151       false, false, &map);
 152
 153   ASSERT_EQ(1U, map.size());
 154   AutocompleteMatch match = map.begin()->second;
 155   ASSERT_EQ(1U, match.duplicate_matches.size());
 156   AutocompleteMatch duplicate = match.duplicate_matches[0];
 157
 158   EXPECT_EQ(answer_contents, match.answer_contents);
 159   EXPECT_EQ(answer_type, match.answer_type);
 160   EXPECT_TRUE(answer->Equals(*match.answer));
 161   EXPECT_EQ(AutocompleteMatchType::SEARCH_HISTORY, match.type);
 162   EXPECT_EQ(1300, match.relevance);
 163
 164   EXPECT_EQ(answer_contents, duplicate.answer_contents);
 165   EXPECT_EQ(answer_type, duplicate.answer_type);
 166   EXPECT_TRUE(answer->Equals(*duplicate.answer));
 167   EXPECT_EQ(AutocompleteMatchType::SEARCH_SUGGEST, duplicate.type);
 168   EXPECT_EQ(850, duplicate.relevance);
 169
 170   // Ensure answers are not copied over existing answers.
 171   map.clear();
 172   base::string16 answer_contents2 = base::ASCIIToUTF16("different answer");
 173   base::string16 answer_type2 = base::ASCIIToUTF16("8242");
 174   scoped_ptr<SuggestionAnswer> answer2(new SuggestionAnswer());
 175   answer2->set_type(8242);
 176   more_relevant = SearchSuggestionParser::SuggestResult(
 177       query, AutocompleteMatchType::SEARCH_HISTORY, query, base::string16(),
 178       base::string16(), answer_contents2, answer_type2,
 179       SuggestionAnswer::copy(answer2.get()), std::string(), std::string(),
 180       false, 1300, true, false, query);
 181   provider_->AddMatchToMap(
 182       more_relevant, std::string(), TemplateURLRef::NO_SUGGESTION_CHOSEN,
 183       false, false, &map);
 184   provider_->AddMatchToMap(
 185       less_relevant, std::string(), TemplateURLRef::NO_SUGGESTION_CHOSEN,
 186       false, false, &map);
 187   ASSERT_EQ(1U, map.size());
 188   match = map.begin()->second;
 189   ASSERT_EQ(1U, match.duplicate_matches.size());
 190   duplicate = match.duplicate_matches[0];
 191
 192   EXPECT_EQ(answer_contents2, match.answer_contents);
 193   EXPECT_EQ(answer_type2, match.answer_type);
 194   EXPECT_TRUE(answer2->Equals(*match.answer));
 195   EXPECT_EQ(AutocompleteMatchType::SEARCH_HISTORY, match.type);
 196   EXPECT_EQ(1300, match.relevance);
 197
 198   EXPECT_EQ(answer_contents, duplicate.answer_contents);
 199   EXPECT_EQ(answer_type, duplicate.answer_type);
 200   EXPECT_TRUE(answer->Equals(*duplicate.answer));
 201   EXPECT_EQ(AutocompleteMatchType::SEARCH_SUGGEST, duplicate.type);
 202   EXPECT_EQ(850, duplicate.relevance);
 203 }