[NTP Snippets] Persist remote categories in prefs

components/ntp_snippets/remote/ntp_snippets_service_unittest.cc

 // Copyright 2015 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_snippets/remote/ntp_snippets_service.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 74 matching lines @@
 const char kSnippetTitle[] = "Title";
 const char kSnippetText[] = "Snippet";
 const char kSnippetSalientImage[] = "http://localhost/salient_image";
 const char kSnippetPublisherName[] = "Foo News";
 const char kSnippetAmpUrl[] = "http://localhost/amp";
 
 const char kSnippetUrl2[] = "http://foo.com/bar";
 
 const char kTestJsonDefaultCategoryTitle[] = "Some title";
 
+const int kUnknownRemoteCategoryId = 1234;
+
 base::Time GetDefaultCreationTime() {
   base::Time out_time;
   EXPECT_TRUE(base::Time::FromUTCExploded(kDefaultCreationTime, &out_time));
   return out_time;
 }
 
 base::Time GetDefaultExpirationTime() {
   return base::Time::Now() + base::TimeDelta::FromHours(1);
 }
 
@@ skipping 13 matching lines @@
 
 std::string GetTestJson(const std::vector<std::string>& snippets) {
   return GetTestJson(snippets, kTestJsonDefaultCategoryTitle);
 }
 
 std::string GetTestJsonWithoutTitle(const std::vector<std::string>& snippets) {
   return GetTestJson(snippets, std::string());
 }
 
 std::string GetMultiCategoryJson(const std::vector<std::string>& articles,
-                                 const std::vector<std::string>& others) {
+                                 const std::vector<std::string>& others,
+                                 int other_id = 2) {
   return base::StringPrintf(
       "{\n"
       "  \"categories\": [{\n"
       "    \"id\": 1,\n"
       "    \"localizedTitle\": \"Articles for You\",\n"
       "    \"suggestions\": [%s]\n"
       "  }, {\n"
-      "    \"id\": 2,\n"
+      "    \"id\": %i,\n"
       "    \"localizedTitle\": \"Other Things\",\n"
       "    \"suggestions\": [%s]\n"
       "  }]\n"
       "}\n",
-      base::JoinString(articles, ", ").c_str(),
+      base::JoinString(articles, ", ").c_str(), other_id,
       base::JoinString(others, ", ").c_str());
 }
 
 std::string FormatTime(const base::Time& t) {
   base::Time::Exploded x;
   t.UTCExplode(&x);
   return base::StringPrintf("%04d-%02d-%02dT%02d:%02d:%02dZ", x.year, x.month,
                             x.day_of_month, x.hour, x.minute, x.second);
 }
 
@@ skipping 316 matching lines @@
   Category articles_category() {
     return category_factory_.FromKnownCategory(KnownCategories::ARTICLES);
   }
 
   ContentSuggestion::ID MakeOtherID(const std::string& id_within_category) {
     return ContentSuggestion::ID(other_category(), id_within_category);
   }
 
   Category other_category() { return category_factory_.FromRemoteCategory(2); }
 
+  Category unknown_category() {
+    return category_factory_.FromRemoteCategory(kUnknownRemoteCategoryId);
+  }
+
  protected:
   const GURL& test_url() { return test_url_; }
   FakeContentSuggestionsProviderObserver& observer() { return *observer_; }
   MockScheduler& mock_scheduler() { return scheduler_; }
   NiceMock<MockImageFetcher>* image_fetcher() { return image_fetcher_; }
   FakeImageDecoder* image_decoder() { return image_decoder_; }
 
   // Provide the json to be returned by the fake fetcher.
   void SetUpFetchResponse(const std::string& json) {
     fake_url_fetcher_factory_.SetFakeResponse(test_url_, json, net::HTTP_OK,
@@ skipping 243 matching lines @@
     EXPECT_EQ(MakeOtherID(std::string(kSnippetUrl) + "/1"), suggestion.id());
     EXPECT_EQ(kSnippetTitle, base::UTF16ToUTF8(suggestion.title()));
     EXPECT_EQ(kSnippetText, base::UTF16ToUTF8(suggestion.snippet_text()));
     EXPECT_EQ(GetDefaultCreationTime(), suggestion.publish_date());
     EXPECT_EQ(kSnippetPublisherName,
               base::UTF16ToUTF8(suggestion.publisher_name()));
     EXPECT_EQ(GURL(kSnippetAmpUrl), suggestion.amp_url());
   }
 }
 
+TEST_F(NTPSnippetsServiceTest, PersistCategoryInfos) {
+  auto service = MakeSnippetsService();
+
+  LoadFromJSONString(service.get(),
+                     GetMultiCategoryJson({GetSnippetN(0)}, {GetSnippetN(1)},
+                                          kUnknownRemoteCategoryId));
+
+  ASSERT_NE(observer().StatusForCategory(articles_category()),
+            CategoryStatus::NOT_PROVIDED);
+  ASSERT_NE(observer().StatusForCategory(unknown_category()),
+            CategoryStatus::NOT_PROVIDED);
+
+  CategoryInfo info_articles_before =
+      service->GetCategoryInfo(articles_category());
+  CategoryInfo info_unknown_before =
+      service->GetCategoryInfo(unknown_category());
+
+  // Recreate the service to simulate a Chrome restart.
+  ResetSnippetsService(&service);
+
+  // The categories should have been restored.
+  ASSERT_NE(observer().StatusForCategory(articles_category()),
+            CategoryStatus::NOT_PROVIDED);
+  ASSERT_NE(observer().StatusForCategory(unknown_category()),
+            CategoryStatus::NOT_PROVIDED);
+
+  CategoryInfo info_articles_after =
+      service->GetCategoryInfo(articles_category());
+  CategoryInfo info_unknown_after =
+      service->GetCategoryInfo(unknown_category());
+
+  EXPECT_EQ(info_articles_before.title(), info_articles_after.title());
+  EXPECT_EQ(info_unknown_before.title(), info_unknown_after.title());
+}
+
 TEST_F(NTPSnippetsServiceTest, Clear) {
   auto service = MakeSnippetsService();
 
   std::string json_str(GetTestJson({GetSnippet()}));
 
   LoadFromJSONString(service.get(), json_str);
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()), SizeIs(1));
 
   service->ClearCachedSuggestions(articles_category());
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()), IsEmpty());
@@ skipping 479 matching lines @@
         base::StringPrintf("http://localhost/snippet-id-%d", i)));
   }
   LoadFromJSONString(service.get(), GetTestJson(suggestions));
   // TODO(tschumann): We should probably trim out any additional results and
   // only serve the MaxSnippetCount items.
   EXPECT_THAT(service->GetSnippetsForTesting(articles_category()),
               SizeIs(service->GetMaxSnippetCountForTesting() + 1));
 }
 
 }  // namespace ntp_snippets