Add a Physical Web omnibox autocomplete provider

components/omnibox/browser/physical_web_provider_unittest.cc

+// Copyright 2016 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 "components/omnibox/browser/physical_web_provider.h"
+
+#include <memory>
+#include <string>
+
+#include "base/memory/ptr_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
+#include "components/metrics/proto/omnibox_event.pb.h"
+#include "components/omnibox/browser/mock_autocomplete_provider_client.h"
+#include "components/omnibox/browser/test_scheme_classifier.h"
+#include "components/physical_web/data_source/physical_web_data_source.h"
+#include "grit/components_strings.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "url/gurl.h"
+
+namespace {
+
+// A mock implementation of the Physical Web data source that allows setting
+// metadata for nearby URLs directly.
+class MockPhysicalWebDataSource : public PhysicalWebDataSource {
+ public:
+  MockPhysicalWebDataSource() : metadata_(new base::ListValue()) {}
+  ~MockPhysicalWebDataSource() override {}
+
+  void StartDiscovery(bool network_request_enabled) override {}
+  void StopDiscovery() override {}
+
+  std::unique_ptr<base::ListValue> GetMetadata() override {
+    return metadata_->CreateDeepCopy();
+  }
+
+  bool HasUnresolvedDiscoveries() override {
+    return false;
+  }
+
+  // for testing
+  void SetMetadata(std::unique_ptr<base::ListValue> metadata) {
+    metadata_ = std::move(metadata);
+  }
+
+ private:
+  std::unique_ptr<base::ListValue> metadata_;
+};
+
+// An autocomplete provider client that embeds the mock Physical Web data
+// source.
+class FakeAutocompleteProviderClient
+    : public testing::NiceMock<MockAutocompleteProviderClient> {
+ public:
+  FakeAutocompleteProviderClient()
+      : physical_web_data_source_(base::MakeUnique<MockPhysicalWebDataSource>())
+  {
+  }
+
+  const AutocompleteSchemeClassifier& GetSchemeClassifier() const override {
+    return scheme_classifier_;
+  }
+
+  PhysicalWebDataSource* GetPhysicalWebDataSource() override {
+    return physical_web_data_source_.get();
+  }
+
+  // Convenience method to avoid downcasts when accessing the mock data source.
+  MockPhysicalWebDataSource* GetMockPhysicalWebDataSource() {
+    return physical_web_data_source_.get();
+  }
+
+ private:
+  std::unique_ptr<MockPhysicalWebDataSource> physical_web_data_source_;
+  TestSchemeClassifier scheme_classifier_;
+};
+
+class PhysicalWebProviderTest : public testing::Test {
+ protected:
+  PhysicalWebProviderTest() : provider_(NULL) {}
+  ~PhysicalWebProviderTest() override {}
+
+  void SetUp() override {
+    client_.reset(new FakeAutocompleteProviderClient());
+    provider_ = PhysicalWebProvider::Create(client_.get());
+  }
+
+  void TearDown() override {
+    provider_ = NULL;
+  }
+
+  // Create a dummy metadata list with |metadata_count| items. Each item is
+  // populated with a unique scanned URL and page metadata.
+  static std::unique_ptr<base::ListValue> CreateMetadata(
+      size_t metadata_count) {
+    auto metadata_list = base::MakeUnique<base::ListValue>();
+    for (size_t i = 0; i < metadata_count; ++i) {
+      std::string item_id = base::SizeTToString(i);
+      std::string url = "https://example.com/" + item_id;
+      auto metadata_item = base::MakeUnique<base::DictionaryValue>();
+      metadata_item->SetString("scannedUrl", url);
+      metadata_item->SetString("resolvedUrl", url);
+      metadata_item->SetString("icon", url);
+      metadata_item->SetString("title", "Example title " + item_id);
+      metadata_item->SetString("description", "Example description " + item_id);
+      metadata_list->Append(std::move(metadata_item));
+    }
+    return metadata_list;
+  }
+
+  std::unique_ptr<FakeAutocompleteProviderClient> client_;
+  scoped_refptr<PhysicalWebProvider> provider_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PhysicalWebProviderTest);
+};
+
+TEST_F(PhysicalWebProviderTest, TestEmptyMetadataListCreatesNoMatches) {
+  MockPhysicalWebDataSource* data_source =
+      client_->GetMockPhysicalWebDataSource();
+  EXPECT_TRUE(data_source);
+
+  data_source->SetMetadata(CreateMetadata(0));
+
+  // Construct an AutocompleteInput representing a typical "zero-suggest"
+  // case. The provider will verify that the content of the omnibox input field
+  // was not entered by the user.
+  std::string url("http://www.cnn.com/");
+  const AutocompleteInput input(base::ASCIIToUTF16(url), base::string16::npos,
+      std::string(), GURL(url), metrics::OmniboxEventProto::OTHER,
+      true, false, true, true, true, TestSchemeClassifier());
+  provider_->Start(input, false);
+
+  EXPECT_TRUE(provider_->matches().empty());
+}
+
+TEST_F(PhysicalWebProviderTest, TestSingleMetadataItemCreatesOneMatch) {
+  MockPhysicalWebDataSource* data_source =
+      client_->GetMockPhysicalWebDataSource();
+  EXPECT_TRUE(data_source);
+
+  // Extract the URL and title before inserting the metadata into the data
+  // source.
+  std::unique_ptr<base::ListValue> metadata_list = CreateMetadata(1);
+  base::DictionaryValue* metadata_item;
+  EXPECT_TRUE(metadata_list->GetDictionary(0, &metadata_item));
+  std::string resolved_url;
+  EXPECT_TRUE(metadata_item->GetString("resolvedUrl", &resolved_url));
+  std::string title;
+  EXPECT_TRUE(metadata_item->GetString("title", &title));
+
+  data_source->SetMetadata(std::move(metadata_list));
+
+  // Construct an AutocompleteInput representing a typical "zero-suggest"
+  // case. The provider will verify that the content of the omnibox input field
+  // was not entered by the user.
+  std::string url("http://www.cnn.com/");
+  const AutocompleteInput input(base::ASCIIToUTF16(url), base::string16::npos,
+      std::string(), GURL(url), metrics::OmniboxEventProto::OTHER,
+      true, false, true, true, true, TestSchemeClassifier());
+  provider_->Start(input, false);
+
+  // Check that there is only one match item and its fields are correct.
+  EXPECT_EQ(1U, provider_->matches().size());
+  const AutocompleteMatch& metadata_match = provider_->matches().front();
+  EXPECT_EQ(AutocompleteMatchType::PHYSICAL_WEB, metadata_match.type);
+  EXPECT_EQ(resolved_url, metadata_match.destination_url.spec());
+  EXPECT_EQ(resolved_url, base::UTF16ToASCII(metadata_match.contents));
+  EXPECT_EQ(title, base::UTF16ToASCII(metadata_match.description));
+}
+
+TEST_F(PhysicalWebProviderTest, TestManyMetadataItemsCreatesOverflowItem) {
+  // This test is intended to verify that an overflow item is created when the
+  // number of nearby Physical Web URLs exceeds the maximum allowable matches
+  // for this provider. The actual limit for the PhysicalWebProvider may be
+  // changed in the future, so create enough metadata to exceed the
+  // AutocompleteProvider's limit.
+  const size_t metadata_count = AutocompleteProvider::kMaxMatches + 1;
+
+  MockPhysicalWebDataSource* data_source =
+      client_->GetMockPhysicalWebDataSource();
+  EXPECT_TRUE(data_source);
+
+  data_source->SetMetadata(CreateMetadata(metadata_count));
+
+  // Construct an AutocompleteInput representing a typical "zero-suggest"
+  // case. The provider will verify that the content of the omnibox input field
+  // was not entered by the user.
+  std::string url("http://www.cnn.com/");
+  const AutocompleteInput input(base::ASCIIToUTF16(url), base::string16::npos,
+      std::string(), GURL(url), metrics::OmniboxEventProto::OTHER,
+      true, false, true, true, true, TestSchemeClassifier());
+  provider_->Start(input, false);
+
+  const size_t match_count = provider_->matches().size();
+  EXPECT_LT(match_count, metadata_count);
+
+  // Check that the overflow item is at the end of the match list and its fields
+  // are correct.
+  const AutocompleteMatch& overflow_match = provider_->matches().back();
+  EXPECT_EQ(AutocompleteMatchType::PHYSICAL_WEB_OVERFLOW, overflow_match.type);
+  EXPECT_EQ("chrome://physical-web/", overflow_match.destination_url.spec());
+  EXPECT_EQ("chrome://physical-web/",
+      base::UTF16ToASCII(overflow_match.contents));
+  std::string description = l10n_util::GetPluralStringFUTF8(
+      IDS_PHYSICAL_WEB_OVERFLOW, metadata_count - match_count + 1);
+  EXPECT_EQ(description, base::UTF16ToASCII(overflow_match.description));
+}
+
+TEST_F(PhysicalWebProviderTest, TestNoMatchesWithUserInput) {
+  MockPhysicalWebDataSource* data_source =
+      client_->GetMockPhysicalWebDataSource();
+  EXPECT_TRUE(data_source);
+
+  data_source->SetMetadata(CreateMetadata(1));
+
+  // Construct an AutocompleteInput to simulate user input in the omnibox input
+  // field. The provider should not generate any matches.
+  std::string text("user input");
+  const AutocompleteInput input(base::ASCIIToUTF16(text), text.length(),
+      std::string(), GURL(),
+      metrics::OmniboxEventProto::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS,
+      true, false, true, true, false, TestSchemeClassifier());
+  provider_->Start(input, false);
+
+  EXPECT_TRUE(provider_->matches().empty());
+}
+
+}