Add PopularSites test.

components/ntp_tiles/popular_sites_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/ntp_tiles/popular_sites.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/json/json_parser.h"
+#include "base/json/json_writer.h"
+#include "base/run_loop.h"
+#include "base/strings/stringprintf.h"
+#include "base/test/sequenced_worker_pool_owner.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "base/values.h"
+#include "components/ntp_tiles/pref_names.h"
+#include "components/pref_registry/pref_registry_syncable.h"
+#include "components/pref_registry/testing_pref_service_syncable.h"
+#include "net/http/http_status_code.h"
+#include "net/url_request/test_url_fetcher_factory.h"
+#include "net/url_request/url_request_status.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::Eq;
+using testing::StrEq;
+
+namespace ntp_tiles {
+namespace {
+
+const char kTitle[] = "title";
+const char kUrl[] = "url";
+const char kLargeIconUrl[] = "large_icon_url";
+const char kFaviconUrl[] = "favicon_url";
+
+using TestPopularSite = std::vector<std::pair<std::string, std::string>>;
+using TestPopularSiteVector = std::vector<TestPopularSite>;
+
+::testing::Matcher<const base::string16&> Str16Eq(const std::string& s) {
+  return ::testing::Eq(base::UTF8ToUTF16(s));
+}
+
+::testing::Matcher<const GURL&> URLEq(const std::string& s) {
+  return ::testing::Eq(GURL(s));
+}
+
+// Copied from iOS code. Perhaps should be in a shared location.

[markusheintz_, 2016/11/04 14:40:16]

I guess this qualifies as a TODO :-)

+class JsonUnsafeParser {
+ public:
+  using SuccessCallback = base::Callback<void(std::unique_ptr<base::Value>)>;
+  using ErrorCallback = base::Callback<void(const std::string&)>;
+
+  // As with SafeJsonParser, runs either success_callback or error_callback on
+  // the calling thread, but not before the call returns.
+  static void Parse(const std::string& unsafe_json,
+                    const SuccessCallback& success_callback,
+                    const ErrorCallback& error_callback) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            [](const std::string& unsafe_json,
+               const SuccessCallback& success_callback,
+               const ErrorCallback& error_callback) {
+              std::string error_msg;
+              int error_line, error_column;
+              std::unique_ptr<base::Value> value =
+                  base::JSONReader::ReadAndReturnError(
+                      unsafe_json, base::JSON_ALLOW_TRAILING_COMMAS, nullptr,
+                      &error_msg, &error_line, &error_column);
+              if (value) {
+                success_callback.Run(std::move(value));
+              } else {
+                error_callback.Run(base::StringPrintf(
+                    "%s (%d:%d)", error_msg.c_str(), error_line, error_column));
+              }
+            },
+            unsafe_json, success_callback, error_callback));
+  }
+
+  JsonUnsafeParser() = delete;
+};
+
+class PopularSitesTest : public ::testing::Test {
+ protected:
+  PopularSitesTest()
+      : worker_pool_owner_(2, "PopularSitesTest."),
+        url_fetcher_factory_(nullptr) {
+    PopularSites::RegisterProfilePrefs(prefs_.registry());
+    CHECK(cache_dir_.CreateUniqueTempDir());
+  }
+
+  void SetCountryAndVersion(const std::string& country,
+                            const std::string& version) {
+    prefs_.SetString(prefs::kPopularSitesOverrideCountry, country);
+    prefs_.SetString(prefs::kPopularSitesOverrideVersion, version);
+  }
+
+  void RespondWithJSON(const std::string& url,
+                       const TestPopularSiteVector& sites) {
+    base::ListValue sites_value;
+    for (const TestPopularSite& site : sites) {
+      auto site_value = base::MakeUnique<base::DictionaryValue>();
+      for (const std::pair<std::string, std::string>& kv : site) {
+        site_value->SetString(kv.first, kv.second);
+      }
+      sites_value.Append(std::move(site_value));
+    }
+    std::string sites_string;
+    base::JSONWriter::Write(sites_value, &sites_string);
+    url_fetcher_factory_.SetFakeResponse(GURL(url), sites_string, net::HTTP_OK,
+                                         net::URLRequestStatus::SUCCESS);
+  }
+
+  void RespondWith404(const std::string& url) {
+    url_fetcher_factory_.SetFakeResponse(GURL(url), "404", net::HTTP_NOT_FOUND,
+                                         net::URLRequestStatus::SUCCESS);
+  }
+
+  bool FetchPopularSites(bool force_download,
+                         std::vector<PopularSites::Site>* sites) {
+    scoped_refptr<net::TestURLRequestContextGetter> url_request_context(
+        new net::TestURLRequestContextGetter(
+            base::ThreadTaskRunnerHandle::Get()));
+    PopularSites popular_sites(worker_pool_owner_.pool().get(), &prefs_,
+                               /*template_url_service=*/nullptr,
+                               /*variations_service=*/nullptr,
+                               url_request_context.get(), cache_dir_.GetPath(),
+                               base::Bind(JsonUnsafeParser::Parse));
+
+    base::RunLoop loop;
+    bool save_success = false;
+    popular_sites.StartFetch(
+        force_download,
+        base::Bind(
+            [](bool* save_success, base::RunLoop* loop, bool success) {
+              *save_success = success;
+              loop->Quit();
+            },
+            &save_success, &loop));
+    loop.Run();
+    *sites = popular_sites.sites();
+    return save_success;
+  }
+
+  base::MessageLoopForUI ui_loop_;
+  base::SequencedWorkerPoolOwner worker_pool_owner_;
+  base::ScopedTempDir cache_dir_;
+  user_prefs::TestingPrefServiceSyncable prefs_;
+  net::FakeURLFetcherFactory url_fetcher_factory_;
+};
+
+TEST_F(PopularSitesTest, Basic) {
+  SetCountryAndVersion("ZZ", "9");
+  RespondWithJSON(
+      "https://www.gstatic.com/chrome/ntp/suggested_sites_ZZ_9.json",
+      {{
+          {kTitle, "Wikipedia, fhta Ph'nglui mglw'nafh"},
+          {kUrl, "https://zz.m.wikipedia.org/"},
+          {kLargeIconUrl, "https://zz.m.wikipedia.org/wikipedia.png"},
+      }});
+
+  std::vector<PopularSites::Site> sites;
+  EXPECT_TRUE(FetchPopularSites(/*force_download=*/false, &sites));
+
+  ASSERT_THAT(sites.size(), Eq(1u));
+  EXPECT_THAT(sites[0].title, Str16Eq("Wikipedia, fhta Ph'nglui mglw'nafh"));
+  EXPECT_THAT(sites[0].url, URLEq("https://zz.m.wikipedia.org/"));
+  EXPECT_THAT(sites[0].large_icon_url,
+              URLEq("https://zz.m.wikipedia.org/wikipedia.png"));
+  EXPECT_THAT(sites[0].favicon_url, URLEq(""));
+}
+
+TEST_F(PopularSitesTest, Fallback) {
+  SetCountryAndVersion("ZZ", "9");
+  RespondWith404(
+      "https://www.gstatic.com/chrome/ntp/suggested_sites_ZZ_9.json");
+  RespondWithJSON(
+      "https://www.gstatic.com/chrome/ntp/suggested_sites_DEFAULT_5.json",
+      {{
+           {kTitle, "YouTube"},
+           {kUrl, "https://m.youtube.com/"},
+           {kLargeIconUrl, "https://s.ytimg.com/apple-touch-icon.png"},
+       },
+       {
+           {kTitle, "The Chromium Project"},
+           {kUrl, "https://www.chromium.org/"},
+           {kFaviconUrl, "https://www.chromium.org/favicon.ico"},
+       }});
+
+  std::vector<PopularSites::Site> sites;
+  EXPECT_TRUE(FetchPopularSites(/*force_download=*/false, &sites));
+
+  ASSERT_THAT(sites.size(), Eq(2u));
+  EXPECT_THAT(sites[0].title, Str16Eq("YouTube"));
+  EXPECT_THAT(sites[0].url, URLEq("https://m.youtube.com/"));
+  EXPECT_THAT(sites[0].large_icon_url,
+              URLEq("https://s.ytimg.com/apple-touch-icon.png"));
+  EXPECT_THAT(sites[0].favicon_url, URLEq(""));
+  EXPECT_THAT(sites[1].title, Str16Eq("The Chromium Project"));
+  EXPECT_THAT(sites[1].url, URLEq("https://www.chromium.org/"));
+  EXPECT_THAT(sites[1].large_icon_url, URLEq(""));
+  EXPECT_THAT(sites[1].favicon_url,
+              URLEq("https://www.chromium.org/favicon.ico"));
+}
+
+TEST_F(PopularSitesTest, Failure) {
+  SetCountryAndVersion("ZZ", "9");
+  RespondWith404(
+      "https://www.gstatic.com/chrome/ntp/suggested_sites_ZZ_9.json");
+  RespondWith404(
+      "https://www.gstatic.com/chrome/ntp/suggested_sites_DEFAULT_5.json");
+
+  std::vector<PopularSites::Site> sites;
+  EXPECT_FALSE(FetchPopularSites(/*force_download=*/false, &sites));
+  ASSERT_THAT(sites.size(), Eq(0u));
+}
+
+}  // namespace
+}  // namespace ntp_tiles