[rac] Use stale libaddressinput data if download fails

third_party/libaddressinput/chromium/cpp/test/retriever_test.cc

 // Copyright (C) 2013 Google Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "retriever.h"
 
 #include <libaddressinput/callback.h>
 #include <libaddressinput/downloader.h>
+#include <libaddressinput/storage.h>
 #include <libaddressinput/util/scoped_ptr.h>
 
+#include <cstddef>
+#include <ctime>
 #include <string>
 
 #include <gtest/gtest.h>
 
 #include "fake_downloader.h"
 #include "fake_storage.h"
 #include "region_data_constants.h"
 
 namespace i18n {
 namespace addressinput {
 
+namespace {
+
 const char kKey[] = "data/CA/AB--fr";
 
 // Empty data that the downloader can return.
 const char kEmptyData[] = "{}";
 
+// The MD5 checksum for kEmptyData. Retriever uses MD5 to validate data
+// integrity.
+const char kEmptyDataChecksum[] = "99914b932bd37a50b983c5e7c90ae93b";
+
+// Returns a string serialization of the current time.
+std::string BuildCurrentTimestampString() {
+  time_t timestamp = time(NULL);
+  char timestamp_string[2 + 3 * sizeof timestamp];
+  snprintf(timestamp_string, sizeof timestamp_string, "%ld", timestamp);
+  return timestamp_string;
+}
+
+}  // namespace
+
 // Tests for Retriever object.
 class RetrieverTest : public testing::Test {
  protected:
   RetrieverTest()
-      : success_(false),
+      : storage_(NULL),
+        retriever_(),
+        success_(false),
         key_(),
         data_() {
     ResetRetriever(FakeDownloader::kFakeDataUrl);
   }
 
   virtual ~RetrieverTest() {}
 
   scoped_ptr<Retriever::Callback> BuildCallback() {
     return ::i18n::addressinput::BuildCallback(
         this, &RetrieverTest::OnDataReady);
   }
 
   void ResetRetriever(const std::string& url) {
+    storage_ = new FakeStorage;
     retriever_.reset(
         new Retriever(url,
                       scoped_ptr<Downloader>(new FakeDownloader),
-                      scoped_ptr<Storage>(new FakeStorage)));
+                      scoped_ptr<Storage>(storage_)));
   }
 
   std::string GetUrlForKey(const std::string& key) {
     return retriever_->GetUrlForKey(key);
   }
 
   std::string GetKeyForUrl(const std::string& url) {
     return retriever_->GetKeyForUrl(url);
   }
 
+  Storage* storage_;  // Owned by |retriever_|.
   scoped_ptr<Retriever> retriever_;
   bool success_;
   std::string key_;
   std::string data_;
 
  private:
   void OnDataReady(bool success,
                    const std::string& key,
                    const std::string& data) {
     success_ = success;
@@ skipping 61 matching lines @@
                           scoped_ptr<Storage>(new FakeStorage));
   const char kFallbackDataKey[] = "data/US";
   bad_retriever.Retrieve(kFallbackDataKey, BuildCallback());
 
   EXPECT_TRUE(success_);
   EXPECT_EQ(kFallbackDataKey, key_);
   EXPECT_FALSE(data_.empty());
   EXPECT_NE(kEmptyData, data_);
 }
 
+TEST_F(RetrieverTest, NoChecksumAndTimestampWillRedownload) {
+  storage_->Put(kKey, kEmptyData);
+  retriever_->Retrieve(kKey, BuildCallback());
+  EXPECT_TRUE(success_);
+  EXPECT_EQ(kKey, key_);
+  EXPECT_FALSE(data_.empty());
+  EXPECT_NE(kEmptyData, data_);
+}
+
+TEST_F(RetrieverTest, ChecksumAndTimestampWillNotRedownload) {
+  storage_->Put(kKey,
+                "timestamp=" + BuildCurrentTimestampString() + "\n" +
+                    "checksum=" + kEmptyDataChecksum + "\n" +
+                    kEmptyData);
+  retriever_->Retrieve(kKey, BuildCallback());
+  EXPECT_TRUE(success_);
+  EXPECT_EQ(kKey, key_);
+  EXPECT_EQ(kEmptyData, data_);
+}
+
+TEST_F(RetrieverTest, OldTimestampWillRedownload) {
+  storage_->Put(kKey,
+                std::string("timestamp=0\n") +
+                    "checksum=" + kEmptyDataChecksum + "\n" +
+                    kEmptyData);
+  retriever_->Retrieve(kKey, BuildCallback());
+  EXPECT_TRUE(success_);
+  EXPECT_EQ(kKey, key_);
+  EXPECT_FALSE(data_.empty());
+  EXPECT_NE(kEmptyData, data_);
+}
+
+TEST_F(RetrieverTest, OldTimestampOkIfDownloadFails) {
+  storage_ = new FakeStorage;
+  Retriever bad_retriever(FakeDownloader::kFakeDataUrl,
+                          scoped_ptr<Downloader>(new FaultyDownloader),
+                          scoped_ptr<Storage>(storage_));
+  storage_->Put(kKey,
+                std::string("timestamp=0\n") +
+                    "checksum=" + kEmptyDataChecksum + "\n" +
+                    kEmptyData);
+  bad_retriever.Retrieve(kKey, BuildCallback());
+  EXPECT_TRUE(success_);
+  EXPECT_EQ(kKey, key_);
+  EXPECT_EQ(kEmptyData, data_);
+}
+
+TEST_F(RetrieverTest, WrongChecksumWillRedownload) {
+  static const char kNonEmptyData[] = "{\"non-empty\": \"data\"}";
+  storage_->Put(kKey,
+                "timestamp=" + BuildCurrentTimestampString() + "\n" +
+                    "checksum=" + kEmptyDataChecksum + "\n" +
+                    kNonEmptyData);
+  retriever_->Retrieve(kKey, BuildCallback());
+  EXPECT_TRUE(success_);
+  EXPECT_EQ(kKey, key_);
+  EXPECT_FALSE(data_.empty());
+  EXPECT_NE(kNonEmptyData, data_);
+}
+
 // The downloader that doesn't get back to you.
 class HangingDownloader : public Downloader {
  public:
   HangingDownloader() {}
   virtual ~HangingDownloader() {}
 
   // Downloader implementation.
   virtual void Download(const std::string& url,
                         scoped_ptr<Callback> downloaded) {}
 };
@@ skipping 24 matching lines @@
   EXPECT_EQ("", GetKeyForUrl("http://www.google.com/"));
   EXPECT_EQ("", GetKeyForUrl(""));
   EXPECT_EQ("", GetKeyForUrl("test:///"));
   EXPECT_EQ("data", GetKeyForUrl("test:///data"));
   EXPECT_EQ("data/US", GetKeyForUrl("test:///data/US"));
   EXPECT_EQ("data/CA--fr", GetKeyForUrl("test:///data/CA--fr"));
 }
 
 }  // namespace addressinput
 }  // namespace i18n