[PhysicalWeb] Add fake data source and helpers for testing.

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/fake_physical_web_data_source.h"
 #include "components/physical_web/data_source/physical_web_data_source.h"
 #include "components/physical_web/data_source/physical_web_listener.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 "ui/gfx/text_elider.h"
 #include "url/gurl.h"
 
+using physical_web::FakePhysicalWebDataSource;
 using physical_web::PhysicalWebDataSource;
 using physical_web::PhysicalWebListener;
 
 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;
-  }
-
-  void RegisterListener(PhysicalWebListener* physical_web_listener) override {}
-
-  void UnregisterListener(
-      PhysicalWebListener* physical_web_listener) override {}
-
-  // 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
+// An autocomplete provider client that embeds the fake Physical Web data
 // source.
 class FakeAutocompleteProviderClient
     : public testing::NiceMock<MockAutocompleteProviderClient> {
  public:
   FakeAutocompleteProviderClient()
       : physical_web_data_source_(
-            base::MakeUnique<MockPhysicalWebDataSource>()),
-        is_off_the_record_(false)
-  {
-  }
+            base::MakeUnique<FakePhysicalWebDataSource>()),
+        is_off_the_record_(false) {}
 
   const AutocompleteSchemeClassifier& GetSchemeClassifier() const override {
     return scheme_classifier_;
   }
 
   PhysicalWebDataSource* GetPhysicalWebDataSource() override {
     return physical_web_data_source_.get();
   }
 
   bool IsOffTheRecord() const override {
     return is_off_the_record_;
   }
 
-  // Convenience method to avoid downcasts when accessing the mock data source.
-  MockPhysicalWebDataSource* GetMockPhysicalWebDataSource() {
+  // Convenience method to avoid downcasts when accessing the fake data source.
+  FakePhysicalWebDataSource* GetFakePhysicalWebDataSource() {
     return physical_web_data_source_.get();
   }
 
   // Allow tests to enable incognito mode.
   void SetOffTheRecord(bool is_off_the_record) {
     is_off_the_record_ = is_off_the_record;
   }
 
  private:
-  std::unique_ptr<MockPhysicalWebDataSource> physical_web_data_source_;
+  std::unique_ptr<FakePhysicalWebDataSource> physical_web_data_source_;
   TestSchemeClassifier scheme_classifier_;
   bool is_off_the_record_;
 };
 
 }  // namespace
 
 class PhysicalWebProviderTest : public testing::Test {
  protected:
   PhysicalWebProviderTest() : provider_(NULL) {}
   ~PhysicalWebProviderTest() override {}
@@ skipping 96 matching lines @@
   // |should_expect_default_match| or |should_expect_overflow_item| are true.
   // Metadata matches are not checked.
   void OverflowItemTestCase(const AutocompleteInput& input,
                             std::unique_ptr<base::ListValue> metadata_list,
                             const std::string& title_truncated,
                             size_t expected_match_count,
                             bool should_expect_default_match,
                             bool should_expect_overflow_item) {
     const size_t metadata_count = metadata_list->GetSize();
 
-    MockPhysicalWebDataSource* data_source =
-        client_->GetMockPhysicalWebDataSource();
+    FakePhysicalWebDataSource* data_source =
+        client_->GetFakePhysicalWebDataSource();
     EXPECT_TRUE(data_source);
 
     data_source->SetMetadata(std::move(metadata_list));
 
     provider_->Start(input, false);
 
     const size_t match_count = provider_->matches().size();
     EXPECT_EQ(expected_match_count, match_count);
 
     const size_t match_count_without_default =
@@ skipping 25 matching lines @@
   }
 
   std::unique_ptr<FakeAutocompleteProviderClient> client_;
   scoped_refptr<PhysicalWebProvider> provider_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PhysicalWebProviderTest);
 };
 
 TEST_F(PhysicalWebProviderTest, TestEmptyMetadataListCreatesNoMatches) {
-  MockPhysicalWebDataSource* data_source =
-      client_->GetMockPhysicalWebDataSource();
+  FakePhysicalWebDataSource* data_source =
+      client_->GetFakePhysicalWebDataSource();
   EXPECT_TRUE(data_source);
 
   data_source->SetMetadata(CreateMetadata(0));
 
   // Run the test with no text in the omnibox input to simulate NTP.
   provider_->Start(CreateInputForNTP(), false);
   EXPECT_TRUE(provider_->matches().empty());
 
   // Run the test again with a URL in the omnibox input.
   provider_->Start(CreateInputWithCurrentUrl("http://www.cnn.com"), false);
   EXPECT_TRUE(provider_->matches().empty());
 }
 
 TEST_F(PhysicalWebProviderTest, TestSingleMetadataItemCreatesOneMatch) {
-  MockPhysicalWebDataSource* data_source =
-      client_->GetMockPhysicalWebDataSource();
+  FakePhysicalWebDataSource* data_source =
+      client_->GetFakePhysicalWebDataSource();
   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(physical_web::kResolvedUrlKey, &resolved_url));
@@ skipping 25 matching lines @@
       EXPECT_TRUE(match.allowed_to_be_default_match);
       ++default_match_count;
     }
   }
   EXPECT_EQ(2U, provider_->matches().size());
   EXPECT_EQ(1U, metadata_match_count);
   EXPECT_EQ(1U, default_match_count);
 }
 
 TEST_F(PhysicalWebProviderTest, TestNoMatchesWithUserInput) {
-  MockPhysicalWebDataSource* data_source =
-      client_->GetMockPhysicalWebDataSource();
+  FakePhysicalWebDataSource* data_source =
+      client_->GetFakePhysicalWebDataSource();
   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::UTF8ToUTF16(text), text.length(), std::string(), GURL(),
       metrics::OmniboxEventProto::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS,
@@ skipping 57 matching lines @@
 
   OverflowItemTestCase(CreateInputForNTP(), std::move(metadata_list),
                        "ויקיפדיה", PhysicalWebProvider::kPhysicalWebMaxMatches,
                        false, true);
 }
 
 TEST_F(PhysicalWebProviderTest, TestNoMatchesInIncognito) {
   // Enable incognito mode
   client_->SetOffTheRecord(true);
 
-  MockPhysicalWebDataSource* data_source =
-      client_->GetMockPhysicalWebDataSource();
+  FakePhysicalWebDataSource* data_source =
+      client_->GetFakePhysicalWebDataSource();
   EXPECT_TRUE(data_source);
 
   data_source->SetMetadata(CreateMetadata(1));
   provider_->Start(CreateInputForNTP(), false);
 
   EXPECT_TRUE(provider_->matches().empty());
 }