| // Copyright 2024 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/omnibox/browser/history_embeddings_provider.h" |
| |
| #include <memory> |
| #include <optional> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/functional/bind.h" |
| #include "base/functional/callback.h" |
| #include "base/memory/scoped_refptr.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/test/bind.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/test/task_environment.h" |
| #include "base/time/time.h" |
| #include "components/history/core/browser/history_service.h" |
| #include "components/history/core/browser/url_row.h" |
| #include "components/history/core/test/history_service_test_util.h" |
| #include "components/history_embeddings/answerer.h" |
| #include "components/history_embeddings/history_embeddings_features.h" |
| #include "components/history_embeddings/history_embeddings_service.h" |
| #include "components/history_embeddings/mock_history_embeddings_service.h" |
| #include "components/omnibox/browser/autocomplete_enums.h" |
| #include "components/omnibox/browser/autocomplete_input.h" |
| #include "components/omnibox/browser/autocomplete_match.h" |
| #include "components/omnibox/browser/autocomplete_provider_listener.h" |
| #include "components/omnibox/browser/fake_autocomplete_provider_client.h" |
| #include "components/omnibox/browser/omnibox_triggered_feature_service.h" |
| #include "components/omnibox/browser/test_scheme_classifier.h" |
| #include "components/optimization_guide/proto/features/history_answer.pb.h" |
| #include "components/os_crypt/async/browser/os_crypt_async.h" |
| #include "components/os_crypt/async/browser/test_utils.h" |
| #include "components/passage_embeddings/passage_embeddings_test_util.h" |
| #include "components/search_engines/template_url.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/metrics_proto/omnibox_event.pb.h" |
| #include "ui/base/page_transition_types.h" |
| #include "url/gurl.h" |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| #include "chromeos/constants/chromeos_features.h" |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| |
| using testing::AllOf; |
| using testing::ElementsAre; |
| using testing::Field; |
| using enum history_embeddings::ComputeAnswerStatus; |
| |
| namespace { |
| AutocompleteInput CreateAutocompleteInput(const std::u16string input) { |
| return {input, metrics::OmniboxEventProto::OTHER, TestSchemeClassifier()}; |
| } |
| |
| history_embeddings::ScoredUrlRow CreateScoredUrlRow( |
| float score, |
| const std::string& url, |
| const std::u16string& title) { |
| history_embeddings::ScoredUrlRow scored_url_row( |
| history_embeddings::ScoredUrl(0, 0, {}, score, 0)); |
| scored_url_row.row = history::URLRow{GURL{url}}; |
| scored_url_row.row.set_title(title); |
| scored_url_row.passages_embeddings.passages.add_passages("passage"); |
| scored_url_row.passages_embeddings.embeddings.emplace_back( |
| std::vector<float>(768, 1.0f)); |
| scored_url_row.scores.push_back(score); |
| return scored_url_row; |
| } |
| |
| history_embeddings::SearchResult CreateSearchResult( |
| const std::string& query, |
| const std::u16string& title) { |
| history_embeddings::SearchResult result; |
| result.query = query; |
| result.scored_url_rows = { |
| CreateScoredUrlRow(.5, "https://url.com/", title), |
| }; |
| return result; |
| } |
| |
| TemplateURL CreateTemplateUrl() { |
| TemplateURLData template_url_data; |
| template_url_data.SetShortName(u"shortname"); |
| template_url_data.SetKeyword(u"keyword"); |
| template_url_data.SetURL("https://url.com"); |
| return TemplateURL{template_url_data}; |
| } |
| } // namespace |
| |
| class FakeHistoryEmbeddingsProvider : public HistoryEmbeddingsProvider { |
| public: |
| using HistoryEmbeddingsProvider::HistoryEmbeddingsProvider; |
| using HistoryEmbeddingsProvider::OnReceivedSearchResult; |
| |
| using HistoryEmbeddingsProvider::done_; |
| using HistoryEmbeddingsProvider::input_; |
| using HistoryEmbeddingsProvider::matches_; |
| using HistoryEmbeddingsProvider::starter_pack_engine_; |
| |
| private: |
| ~FakeHistoryEmbeddingsProvider() override = default; |
| }; |
| |
| class HistoryEmbeddingsProviderTest : public testing::Test, |
| public AutocompleteProviderListener { |
| public: |
| void SetUp() override { |
| testing::Test::SetUp(); |
| |
| os_crypt_ = os_crypt_async::GetTestOSCryptAsyncForTesting( |
| /*is_sync_for_unittests=*/true); |
| |
| auto feature_parameters = history_embeddings::GetFeatureParameters(); |
| feature_parameters.use_ml_answerer = false; |
| history_embeddings::SetFeatureParametersForTesting(feature_parameters); |
| |
| CHECK(history_dir_.CreateUniqueTempDir()); |
| client_ = std::make_unique<FakeAutocompleteProviderClient>(); |
| client_->set_history_service( |
| history::CreateHistoryService(history_dir_.GetPath(), true)); |
| client_->set_history_embeddings_service( |
| std::make_unique<testing::NiceMock< |
| history_embeddings::MockHistoryEmbeddingsService>>( |
| os_crypt_.get(), client_->GetHistoryService(), |
| passage_embeddings_test_env_.embedder_metadata_provider(), |
| passage_embeddings_test_env_.embedder())); |
| history_embeddings_service_ = static_cast< |
| testing::NiceMock<history_embeddings::MockHistoryEmbeddingsService>*>( |
| client_->GetHistoryEmbeddingsService()); |
| history_embeddings_provider_ = |
| new FakeHistoryEmbeddingsProvider(client_.get(), this); |
| |
| // When `Search()` is called, pushes a callback to `search_callbacks_` that |
| // can be ran to simulate `Search()` responding asyncly. |
| ON_CALL(*history_embeddings_service_, |
| Search(testing::_, testing::_, testing::_, testing::_, testing::_, |
| testing::_)) |
| .WillByDefault( |
| [&](history_embeddings::SearchResult* previous_search_result, |
| std::string query, std::optional<base::Time> time_range_start, |
| size_t count, bool skip_answering, |
| history_embeddings::SearchResultCallback callback) { |
| search_callbacks_.push_back(base::BindOnce( |
| [](history_embeddings::SearchResultCallback callback, |
| std::string query, std::u16string response) { |
| std::move(callback).Run( |
| CreateSearchResult(query, response)); |
| }, |
| std::move(callback))); |
| return history_embeddings::SearchResult(); |
| }); |
| } |
| |
| // AutocompleteProviderListener: |
| void OnProviderUpdate(bool updated_matches, |
| const AutocompleteProvider* provider) override { |
| last_update_matches_ = history_embeddings_provider_->matches_; |
| } |
| |
| base::ScopedTempDir history_dir_; |
| std::unique_ptr<os_crypt_async::OSCryptAsync> os_crypt_; |
| base::test::TaskEnvironment task_environment_; |
| passage_embeddings::TestEnvironment passage_embeddings_test_env_; |
| std::unique_ptr<FakeAutocompleteProviderClient> client_; |
| raw_ptr<testing::NiceMock<history_embeddings::MockHistoryEmbeddingsService>> |
| history_embeddings_service_; |
| scoped_refptr<FakeHistoryEmbeddingsProvider> history_embeddings_provider_; |
| // Callbacks created when `Search()` is called. Running a callback with |
| // `(query, response)` will simulate `Search()` responding with a result with |
| // query `query` and 1 row with title `response`. |
| std::vector<base::OnceCallback<void(std::string, std::u16string)>> |
| search_callbacks_; |
| // The last set of matches the provider gave the autocomplete controller. |
| ACMatches last_update_matches_; |
| }; |
| |
| TEST_F(HistoryEmbeddingsProviderTest, Start) { |
| OmniboxTriggeredFeatureService* trigger_service = |
| client_->GetOmniboxTriggeredFeatureService(); |
| OmniboxTriggeredFeatureService::Feature trigger_feature = |
| metrics::OmniboxEventProto_Feature_HISTORY_EMBEDDINGS_FEATURE; |
| |
| AutocompleteInput short_input = CreateAutocompleteInput(u"query"); |
| AutocompleteInput sync_long_input = |
| CreateAutocompleteInput(u"query query query"); |
| sync_long_input.set_omit_asynchronous_matches(true); |
| AutocompleteInput long_input = CreateAutocompleteInput(u"query query query"); |
| |
| // When the feature is disabled, should early exit. |
| EXPECT_CALL(*client_, IsHistoryEmbeddingsEnabled()) |
| .WillOnce(testing::Return(false)); |
| EXPECT_CALL(*history_embeddings_service_, |
| Search(testing::_, testing::_, testing::_, testing::_, testing::_, |
| testing::_)) |
| .Times(0); |
| history_embeddings_provider_->Start(long_input, false); |
| EXPECT_FALSE(trigger_service->GetFeatureTriggeredInSession(trigger_feature)); |
| |
| // Short queries should be blocked. |
| auto feature_parameters = history_embeddings::GetFeatureParameters(); |
| feature_parameters.search_query_minimum_word_count = 3; |
| history_embeddings::SetFeatureParametersForTesting(feature_parameters); |
| base::test::ScopedFeatureList enabled_feature; |
| enabled_feature.InitWithFeaturesAndParameters( |
| {{history_embeddings::kHistoryEmbeddings, {}}, |
| #if BUILDFLAG(IS_CHROMEOS) |
| {chromeos::features::kFeatureManagementHistoryEmbedding, {{}}} |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| }, |
| /*disabled_features=*/{}); |
| EXPECT_CALL(*client_, IsHistoryEmbeddingsEnabled()) |
| .WillRepeatedly(testing::Return(true)); |
| |
| EXPECT_CALL(*history_embeddings_service_, |
| Search(testing::_, testing::_, testing::_, testing::_, testing::_, |
| testing::_)) |
| .Times(0); |
| history_embeddings_provider_->Start(short_input, false); |
| EXPECT_FALSE(trigger_service->GetFeatureTriggeredInSession(trigger_feature)); |
| trigger_service->ResetSession(); |
| |
| // Sync queries should be blocked. |
| EXPECT_CALL(*history_embeddings_service_, |
| Search(testing::_, testing::_, testing::_, testing::_, testing::_, |
| testing::_)) |
| .Times(0); |
| history_embeddings_provider_->Start(sync_long_input, false); |
| EXPECT_FALSE(trigger_service->GetFeatureTriggeredInSession(trigger_feature)); |
| trigger_service->ResetSession(); |
| |
| // Long queries should pass. |
| EXPECT_CALL(*history_embeddings_service_, |
| Search(testing::_, "query query query", |
| std::optional<base::Time>{}, 3u, false, testing::_)) |
| .Times(1); |
| history_embeddings_provider_->Start(long_input, false); |
| EXPECT_TRUE(trigger_service->GetFeatureTriggeredInSession(trigger_feature)); |
| } |
| |
| TEST_F(HistoryEmbeddingsProviderTest, Start_MultipleSequentialSearches) { |
| EXPECT_CALL(*client_, IsHistoryEmbeddingsEnabled()) |
| .WillRepeatedly(testing::Return(true)); |
| |
| // Start 1st search. |
| history_embeddings_provider_->Start(CreateAutocompleteInput(u"1 1 1"), false); |
| EXPECT_TRUE(last_update_matches_.empty()); |
| |
| // Check results are populated when 1st search responds. |
| std::move(search_callbacks_[0]).Run("1 1 1", u"1"); |
| EXPECT_THAT(last_update_matches_, |
| testing::ElementsAre( |
| testing::Field(&AutocompleteMatch::description, u"1"))); |
| |
| // Start 2nd search. |
| history_embeddings_provider_->Start(CreateAutocompleteInput(u"2 2 2"), false); |
| EXPECT_THAT(last_update_matches_, |
| testing::ElementsAre( |
| testing::Field(&AutocompleteMatch::description, u"1"))); |
| |
| // Check results are populated when 2nd search responds. |
| std::move(search_callbacks_[1]).Run("2 2 2", u"2"); |
| EXPECT_THAT(last_update_matches_, |
| testing::ElementsAre( |
| testing::Field(&AutocompleteMatch::description, u"2"))); |
| } |
| |
| TEST_F(HistoryEmbeddingsProviderTest, Start_MultipleParallelSearches) { |
| EXPECT_CALL(*client_, IsHistoryEmbeddingsEnabled()) |
| .WillRepeatedly(testing::Return(true)); |
| |
| // Start 1st search. |
| history_embeddings_provider_->Start(CreateAutocompleteInput(u"1 1 1"), false); |
| EXPECT_TRUE(last_update_matches_.empty()); |
| |
| // Start 2nd search. |
| history_embeddings_provider_->Start(CreateAutocompleteInput(u"2 2 2"), false); |
| EXPECT_TRUE(last_update_matches_.empty()); |
| |
| // Check results are not populated when 1st search responds. |
| std::move(search_callbacks_[0]).Run("1 1 1", u"1"); |
| EXPECT_TRUE(last_update_matches_.empty()); |
| |
| // Check results are populated when 2nd search responds. |
| std::move(search_callbacks_[1]).Run("2 2 2", u"2"); |
| EXPECT_THAT(last_update_matches_, |
| testing::ElementsAre( |
| testing::Field(&AutocompleteMatch::description, u"2"))); |
| } |
| |
| TEST_F(HistoryEmbeddingsProviderTest, |
| Start_MultipleParallelSearchesWithSameQuery) { |
| EXPECT_CALL(*client_, IsHistoryEmbeddingsEnabled()) |
| .WillRepeatedly(testing::Return(true)); |
| |
| // Start 1st search. |
| history_embeddings_provider_->Start(CreateAutocompleteInput(u"1 1 1"), false); |
| EXPECT_TRUE(last_update_matches_.empty()); |
| |
| // Start 2nd search. |
| history_embeddings_provider_->Start(CreateAutocompleteInput(u"1 1 1"), false); |
| EXPECT_TRUE(last_update_matches_.empty()); |
| |
| // Check results are populated when 1st search responds. Even though the |
| // provider usually only cares about the most recent `Search()`, since the |
| // input didn't change, it can use the 1st `Search()`. |
| std::move(search_callbacks_[0]).Run("1 1 1", u"1"); |
| EXPECT_THAT(last_update_matches_, |
| testing::ElementsAre( |
| testing::Field(&AutocompleteMatch::description, u"1"))); |
| |
| // Check results aren't replaced when 2nd search responds. The provider |
| // already reported `done_ = true` and it would break autocompletion to send |
| // an update after doing so. |
| std::move(search_callbacks_[1]).Run("1 1 1", u"2"); |
| EXPECT_THAT(last_update_matches_, |
| testing::ElementsAre( |
| testing::Field(&AutocompleteMatch::description, u"1"))); |
| } |
| |
| TEST_F(HistoryEmbeddingsProviderTest, |
| Start_MultipleParallelSearchesWithIneligibleQuery) { |
| auto feature_parameters = history_embeddings::GetFeatureParameters(); |
| feature_parameters.search_query_minimum_word_count = 3; |
| history_embeddings::SetFeatureParametersForTesting(feature_parameters); |
| base::test::ScopedFeatureList enabled_feature; |
| enabled_feature.InitWithFeaturesAndParameters( |
| {{history_embeddings::kHistoryEmbeddings, {}}, |
| #if BUILDFLAG(IS_CHROMEOS) |
| {chromeos::features::kFeatureManagementHistoryEmbedding, {{}}} |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| }, |
| /*disabled_features=*/{}); |
| EXPECT_CALL(*client_, IsHistoryEmbeddingsEnabled()) |
| .WillRepeatedly(testing::Return(true)); |
| |
| // Start 1st search. |
| history_embeddings_provider_->Start(CreateAutocompleteInput(u"1 1 1"), false); |
| EXPECT_TRUE(last_update_matches_.empty()); |
| |
| // Start 2nd search. It's too short. |
| history_embeddings_provider_->Start(CreateAutocompleteInput(u"2 2"), false); |
| EXPECT_TRUE(last_update_matches_.empty()); |
| |
| // Ensure a stale search doesn't populate matches. |
| std::move(search_callbacks_[0]).Run("1 1 1", u"1"); |
| EXPECT_TRUE(last_update_matches_.empty()); |
| |
| // Ensure a 2nd search wasn't made. |
| EXPECT_EQ(search_callbacks_.size(), 1u); |
| } |
| |
| TEST_F(HistoryEmbeddingsProviderTest, Start_Stop_SearchCompletesAfterStop) { |
| EXPECT_CALL(*client_, IsHistoryEmbeddingsEnabled()) |
| .WillRepeatedly(testing::Return(true)); |
| |
| // Start search. |
| history_embeddings_provider_->Start(CreateAutocompleteInput(u"1 1 1"), false); |
| EXPECT_TRUE(last_update_matches_.empty()); |
| |
| history_embeddings_provider_->Stop(AutocompleteStopReason::kClobbered); |
| |
| // Results returned after `Stop()` should be discarded. |
| std::move(search_callbacks_[0]).Run("1 1 1", u"1"); |
| EXPECT_TRUE(last_update_matches_.empty()); |
| } |
| |
| TEST_F(HistoryEmbeddingsProviderTest, Stop) { |
| history_embeddings_provider_->done_ = false; |
| |
| // TODO(crbug.com/364303536) Temporarily allow history embeddings provider to |
| // ignore `Stop()`. |
| history_embeddings_provider_->Stop(AutocompleteStopReason::kInactivity); |
| EXPECT_FALSE(history_embeddings_provider_->done_); |
| |
| history_embeddings_provider_->Stop(AutocompleteStopReason::kClobbered); |
| EXPECT_TRUE(history_embeddings_provider_->done_); |
| } |
| |
| TEST_F(HistoryEmbeddingsProviderTest, DeleteMatch) { |
| AutocompleteMatch match(history_embeddings_provider_.get(), 1000, true, |
| AutocompleteMatchType::HISTORY_EMBEDDINGS); |
| match.destination_url = GURL{"https://en.wikipedia.org/wiki/Matenadaran"}; |
| history_embeddings_provider_->matches_.push_back(match); |
| history_embeddings_provider_->DeleteMatch(match); |
| EXPECT_TRUE(history_embeddings_provider_->matches_.empty()); |
| } |
| |
| TEST_F(HistoryEmbeddingsProviderTest, |
| OnReceivedSearchResult_CreatesAutocompleteMatches) { |
| history_embeddings::SearchResult result; |
| result.query = "query"; |
| result.scored_url_rows = { |
| CreateScoredUrlRow(.5, "https://url.com/", u"title"), |
| }; |
| history_embeddings_provider_->done_ = false; |
| history_embeddings_provider_->input_ = CreateAutocompleteInput(u"query"); |
| history_embeddings_provider_->OnReceivedSearchResult(std::move(result)); |
| |
| EXPECT_TRUE(history_embeddings_provider_->done_); |
| ASSERT_EQ(history_embeddings_provider_->matches_.size(), 1u); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].provider.get(), |
| history_embeddings_provider_.get()); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].relevance, 500); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].deletable, true); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].type, |
| AutocompleteMatchType::HISTORY_EMBEDDINGS); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].destination_url.spec(), |
| "https://url.com/"); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].description, u"title"); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].contents, |
| u"https://url.com/"); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].keyword, u""); |
| EXPECT_TRUE(PageTransitionCoreTypeIs( |
| history_embeddings_provider_->matches_[0].transition, |
| ui::PAGE_TRANSITION_TYPED)); |
| } |
| |
| TEST_F(HistoryEmbeddingsProviderTest, |
| OnReceivedSearchResult_CreatesScopedAutocompleteMatches) { |
| // Verifies autocomplete match is created correctly when the user is in |
| // keyword mode. |
| TemplateURL template_url = CreateTemplateUrl(); |
| history_embeddings_provider_->starter_pack_engine_ = &template_url; |
| |
| history_embeddings::SearchResult result; |
| result.query = "query"; |
| result.scored_url_rows = { |
| CreateScoredUrlRow(.5, "https://url.com/", u"title"), |
| }; |
| history_embeddings_provider_->done_ = false; |
| history_embeddings_provider_->input_ = CreateAutocompleteInput(u"query"); |
| history_embeddings_provider_->OnReceivedSearchResult(std::move(result)); |
| |
| EXPECT_TRUE(history_embeddings_provider_->done_); |
| ASSERT_EQ(history_embeddings_provider_->matches_.size(), 1u); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].provider.get(), |
| history_embeddings_provider_.get()); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].relevance, 500); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].deletable, true); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].type, |
| AutocompleteMatchType::HISTORY_EMBEDDINGS); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].destination_url.spec(), |
| "https://url.com/"); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].description, u"title"); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].contents, |
| u"https://url.com/"); |
| EXPECT_EQ(history_embeddings_provider_->matches_[0].keyword, u"keyword"); |
| EXPECT_TRUE(PageTransitionCoreTypeIs( |
| history_embeddings_provider_->matches_[0].transition, |
| ui::PAGE_TRANSITION_KEYWORD)); |
| } |
| |
| TEST_F(HistoryEmbeddingsProviderTest, |
| OnReceivedSearchResult_CreatesScopedAutocompleteAnswerMatches) { |
| auto feature_parameters = history_embeddings::GetFeatureParameters(); |
| feature_parameters.answers_in_omnibox_scoped = true; |
| feature_parameters.trim_after_host_in_results = true; |
| history_embeddings::SetFeatureParametersForTesting(feature_parameters); |
| |
| base::test::ScopedFeatureList enabled_feature; |
| enabled_feature.InitWithFeaturesAndParameters( |
| {{history_embeddings::kHistoryEmbeddings, {}}, |
| #if BUILDFLAG(IS_CHROMEOS) |
| {chromeos::features::kFeatureManagementHistoryEmbedding, {{}}} |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| }, |
| /*disabled_features=*/{}); |
| |
| TemplateURL template_url = CreateTemplateUrl(); |
| history_embeddings_provider_->starter_pack_engine_ = &template_url; |
| |
| // 1st response with status `kUnspecified`. |
| history_embeddings::SearchResult result; |
| result.query = "query"; |
| result.scored_url_rows = { |
| CreateScoredUrlRow(.75, "https://url1.com/", u"title"), |
| CreateScoredUrlRow(.50, "https://url2.com/path?key=value", u"title"), |
| CreateScoredUrlRow(.25, "https://url3.com/", u"title"), |
| }; |
| base::Time time; |
| EXPECT_TRUE(base::Time::FromLocalExploded( |
| {.year = 2025, .month = 3, .day_of_month = 23}, &time)); |
| result.scored_url_rows[1].row.set_last_visit(time); |
| |
| history_embeddings_provider_->done_ = false; |
| history_embeddings_provider_->input_ = CreateAutocompleteInput(u"query"); |
| history_embeddings_provider_->input_.set_keyword_mode_entry_method( |
| metrics::OmniboxEventProto_KeywordModeEntryMethod_TAB); |
| history_embeddings_provider_->OnReceivedSearchResult(result.Clone()); |
| |
| // Set up expected matches. |
| auto expected_match_1 = |
| AllOf(Field(&AutocompleteMatch::relevance, 750), |
| Field(&AutocompleteMatch::type, |
| AutocompleteMatchType::HISTORY_EMBEDDINGS), |
| Field(&AutocompleteMatch::destination_url, "https://url1.com/")); |
| auto expected_match_2 = |
| AllOf(Field(&AutocompleteMatch::relevance, 500), |
| Field(&AutocompleteMatch::type, |
| AutocompleteMatchType::HISTORY_EMBEDDINGS), |
| Field(&AutocompleteMatch::destination_url, |
| "https://url2.com/path?key=value")); |
| auto expected_match_3 = |
| AllOf(Field(&AutocompleteMatch::relevance, 250), |
| Field(&AutocompleteMatch::type, |
| AutocompleteMatchType::HISTORY_EMBEDDINGS), |
| Field(&AutocompleteMatch::destination_url, "https://url3.com/")); |
| |
| // Expect only non-answer matches. |
| EXPECT_FALSE(history_embeddings_provider_->done_); |
| EXPECT_THAT( |
| history_embeddings_provider_->matches_, |
| ElementsAre(expected_match_1, expected_match_2, expected_match_3)); |
| |
| // 2nd response with status `kLoading`. |
| auto result_loading = result.Clone(); |
| result_loading.answerer_result.status = kLoading; |
| result_loading.answerer_result.query = "query"; |
| history_embeddings_provider_->OnReceivedSearchResult( |
| std::move(result_loading)); |
| |
| // Expect the same non-answer matches as well as a 'loading' answer match, |
| // scored 1 less than the top match. |
| EXPECT_FALSE(history_embeddings_provider_->done_); |
| EXPECT_THAT( |
| history_embeddings_provider_->matches_, |
| ElementsAre( |
| expected_match_1, expected_match_2, expected_match_3, |
| AllOf(Field(&AutocompleteMatch::relevance, 749), |
| Field(&AutocompleteMatch::type, |
| AutocompleteMatchType::HISTORY_EMBEDDINGS_ANSWER), |
| Field(&AutocompleteMatch::destination_url, ""), |
| Field(&AutocompleteMatch::history_embeddings_answer_header_text, |
| u"Searching for a summary\x2026"), |
| Field(&AutocompleteMatch::description, u"")))); |
| |
| // 3rd response with status `kSuccess`. |
| auto result_success = result.Clone(); |
| result_success.answerer_result.status = kSuccess; |
| result_success.answerer_result.query = "query"; |
| result_success.answerer_result.answer.set_score(1); |
| result_success.answerer_result.answer.set_text("answer text"); |
| result_success.answerer_result.url = "https://url2.com/path?key=value"; |
| history_embeddings_provider_->OnReceivedSearchResult( |
| std::move(result_success)); |
| |
| // Expect the same non-answer matches as well as a flushed out answer match, |
| // scored 1 less than the corresponding match. |
| EXPECT_TRUE(history_embeddings_provider_->done_); |
| EXPECT_THAT( |
| history_embeddings_provider_->matches_, |
| ElementsAre( |
| expected_match_1, expected_match_2, expected_match_3, |
| AllOf(Field(&AutocompleteMatch::relevance, 499), |
| Field(&AutocompleteMatch::type, |
| AutocompleteMatchType::HISTORY_EMBEDDINGS_ANSWER), |
| Field(&AutocompleteMatch::destination_url, |
| "chrome://history/?q=query"), |
| Field(&AutocompleteMatch::history_embeddings_answer_header_text, |
| u"Summary"), |
| Field(&AutocompleteMatch::description, u"answer text"), |
| Field(&AutocompleteMatch::contents, |
| u"url2.com • Visited Mar 23, 2025")))); |
| |
| // Test error cases. |
| std::u16string execution_error = |
| u"Something went wrong. Please try again later."; |
| std::u16string non_temporary_error = u"Sorry, I can't help you with that."; |
| for (const auto& [status, expected_answer_text] : std::vector< |
| std::pair<history_embeddings::ComputeAnswerStatus, std::u16string>>{ |
| {kUnanswerable, u""}, |
| {kModelUnavailable, u""}, |
| {kExecutionFailure, execution_error}, |
| {kExecutionCancelled, u""}, |
| {kFiltered, u""}}) { |
| SCOPED_TRACE("Testing status: " + |
| base::NumberToString(static_cast<int>(status))); |
| auto result_error = result.Clone(); |
| result_error.answerer_result.status = status; |
| history_embeddings_provider_->done_ = false; |
| history_embeddings_provider_->OnReceivedSearchResult( |
| std::move(result_error)); |
| |
| EXPECT_TRUE(history_embeddings_provider_->done_); |
| if (expected_answer_text.empty()) { |
| EXPECT_THAT( |
| history_embeddings_provider_->matches_, |
| ElementsAre(expected_match_1, expected_match_2, expected_match_3)); |
| } else { |
| EXPECT_THAT( |
| history_embeddings_provider_->matches_, |
| ElementsAre( |
| expected_match_1, expected_match_2, expected_match_3, |
| AllOf( |
| Field(&AutocompleteMatch::relevance, 749), |
| Field(&AutocompleteMatch::type, |
| AutocompleteMatchType::HISTORY_EMBEDDINGS_ANSWER), |
| Field(&AutocompleteMatch::destination_url, ""), |
| Field( |
| &AutocompleteMatch::history_embeddings_answer_header_text, |
| u"Summary"), |
| Field(&AutocompleteMatch::description, expected_answer_text), |
| Field(&AutocompleteMatch::contents, u"")))); |
| } |
| } |
| } |
