Offline By Default

services/url_response_disk_cache/url_response_disk_cache_apptest.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 "base/files/file_util.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/application_test_base.h"
@@ skipping 33 matching lines @@
 
 HttpHeaderPtr RandomEtagHeader() {
   auto etag_header = HttpHeader::New();
   etag_header->name = "ETag";
   etag_header->value = base::StringPrintf("%f", base::RandDouble());
   return etag_header;
 }
 
 }  // namespace
 
-TEST_F(URLResponseDiskCacheAppTest, GetFile) {
+TEST_F(URLResponseDiskCacheAppTest, UpdateAndGet) {

[ppi, 2015/09/08 15:46:26]

Should we have some tests for the new methods too?

[qsr, 2015/09/11 15:47:57]

It is extremely hard to do. Update is completely asynchronous, and best effort.
In practice, unless I wait for a long time, I have no way to know when a Get()
will return a value.

I updated the test with a 1s wait, but I really do not like this.

   URLResponsePtr url_response = mojo::URLResponse::New();
   url_response->url = "http://www.example.com/1";
   url_response->headers.push_back(RandomEtagHeader());
   DataPipe pipe;
   std::string content = base::RandBytesAsString(32);
   uint32_t num_bytes = content.size();
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe.producer_handle.get(), content.c_str(),
                          &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(content.size(), num_bytes);
   pipe.producer_handle.reset();
   url_response->body = pipe.consumer_handle.Pass();
   base::FilePath file;
   base::FilePath cache_dir;
-  url_response_disk_cache_->GetFile(
+  url_response_disk_cache_->UpdateAndGet(
       url_response.Pass(),
       [&file, &cache_dir](Array<uint8_t> received_file_path,
                           Array<uint8_t> received_cache_dir_path) {
         file = toPath(received_file_path.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(file.empty());
   std::string received_content;
   ASSERT_TRUE(base::ReadFileToString(file, &received_content));
   EXPECT_EQ(content, received_content);
 }
 
-TEST_F(URLResponseDiskCacheAppTest, GetExtractedContent) {
+TEST_F(URLResponseDiskCacheAppTest, UpdateAndGetExtracted) {
   URLResponsePtr url_response = mojo::URLResponse::New();
   url_response->url = "http://www.example.com/2";
   url_response->headers.push_back(RandomEtagHeader());
   DataPipe pipe;
   std::string content = base::RandBytesAsString(32);
   uint32_t num_bytes = kTestData.size;
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe.producer_handle.get(), kTestData.data, &num_bytes,
                          MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(kTestData.size, num_bytes);
   pipe.producer_handle.reset();
   url_response->body = pipe.consumer_handle.Pass();
   base::FilePath extracted_dir;
   base::FilePath cache_dir;
-  url_response_disk_cache_->GetExtractedContent(
+  url_response_disk_cache_->UpdateAndGetExtracted(
       url_response.Pass(),
       [&extracted_dir, &cache_dir](Array<uint8_t> received_extracted_dir,
                                    Array<uint8_t> received_cache_dir_path) {
         extracted_dir = toPath(received_extracted_dir.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(extracted_dir.empty());
   base::FilePath file1 = extracted_dir.Append("file1");
   std::string file_content;
@@ skipping 18 matching lines @@
   std::string content = base::RandBytesAsString(32);
   uint32_t num_bytes = content.size();
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe1.producer_handle.get(), content.c_str(),
                          &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(content.size(), num_bytes);
   pipe1.producer_handle.reset();
   url_response->body = pipe1.consumer_handle.Pass();
   base::FilePath file;
   base::FilePath cache_dir;
-  url_response_disk_cache_->GetFile(
+  url_response_disk_cache_->UpdateAndGet(
       url_response.Pass(),
       [&file, &cache_dir](Array<uint8_t> received_file_path,
                           Array<uint8_t> received_cache_dir_path) {
         file = toPath(received_file_path.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(file.empty());
   std::string received_content;
   ASSERT_TRUE(base::ReadFileToString(file, &received_content));
@@ skipping 16 matching lines @@
   }
   DataPipe pipe2;
   std::string new_content = base::RandBytesAsString(32);
   num_bytes = new_content.size();
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe2.producer_handle.get(), new_content.c_str(),
                          &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(new_content.size(), num_bytes);
   pipe2.producer_handle.reset();
   url_response->body = pipe2.consumer_handle.Pass();
-  url_response_disk_cache_->GetFile(
+  url_response_disk_cache_->UpdateAndGet(
       url_response.Pass(),
       [&file, &cache_dir](Array<uint8_t> received_file_path,
                           Array<uint8_t> received_cache_dir_path) {
         file = toPath(received_file_path.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(file.empty());
   ASSERT_TRUE(base::ReadFileToString(file, &received_content));
   EXPECT_EQ(content, received_content);
@@ skipping 10 matching lines @@
   url_response->headers.push_back(RandomEtagHeader());
   DataPipe pipe3;
   new_content = base::RandBytesAsString(32);
   num_bytes = new_content.size();
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe3.producer_handle.get(), new_content.c_str(),
                          &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(new_content.size(), num_bytes);
   pipe3.producer_handle.reset();
   url_response->body = pipe3.consumer_handle.Pass();
-  url_response_disk_cache_->GetFile(
+  url_response_disk_cache_->UpdateAndGet(
       url_response.Pass(),
       [&file, &cache_dir](Array<uint8_t> received_file_path,
                           Array<uint8_t> received_cache_dir_path) {
         file = toPath(received_file_path.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(file.empty());
   ASSERT_TRUE(base::ReadFileToString(file, &received_content));
   EXPECT_EQ(new_content, received_content);
   saved_file = cache_dir.Append("file");
   EXPECT_FALSE(base::PathExists(saved_file));
   ASSERT_TRUE(base::WriteFile(saved_file, cached_content.data(),
                               cached_content.size()));
 
   // Request using a response without an etag header. Check that the new
   // content is returned, and the cached files is deleted.
   url_response = mojo::URLResponse::New();
   url_response->url = "http://www.example.com/3";
   DataPipe pipe4;
   new_content = base::RandBytesAsString(32);
   num_bytes = new_content.size();
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe4.producer_handle.get(), new_content.c_str(),
                          &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(new_content.size(), num_bytes);
   pipe4.producer_handle.reset();
   url_response->body = pipe4.consumer_handle.Pass();
-  url_response_disk_cache_->GetFile(
+  url_response_disk_cache_->UpdateAndGet(
       url_response.Pass(),
       [&file, &cache_dir](Array<uint8_t> received_file_path,
                           Array<uint8_t> received_cache_dir_path) {
         file = toPath(received_file_path.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(file.empty());
   ASSERT_TRUE(base::ReadFileToString(file, &received_content));
   EXPECT_EQ(new_content, received_content);
   saved_file = cache_dir.Append("file");
   EXPECT_FALSE(base::PathExists(saved_file));
   ASSERT_TRUE(base::WriteFile(saved_file, cached_content.data(),
                               cached_content.size()));
 
   // Request using a response with an etag header while the cache version
   // doesn't have one. Check that the new content is returned, and the cached
   // files is deleted.
   url_response = mojo::URLResponse::New();
   url_response->url = "http://www.example.com/3";
   DataPipe pipe5;
   new_content = base::RandBytesAsString(32);
   num_bytes = new_content.size();
   ASSERT_EQ(MOJO_RESULT_OK,
             WriteDataRaw(pipe5.producer_handle.get(), new_content.c_str(),
                          &num_bytes, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   ASSERT_EQ(new_content.size(), num_bytes);
   pipe5.producer_handle.reset();
   url_response->body = pipe5.consumer_handle.Pass();
-  url_response_disk_cache_->GetFile(
+  url_response_disk_cache_->UpdateAndGet(
       url_response.Pass(),
       [&file, &cache_dir](Array<uint8_t> received_file_path,
                           Array<uint8_t> received_cache_dir_path) {
         file = toPath(received_file_path.Pass());
         cache_dir = toPath(received_cache_dir_path.Pass());
       });
   url_response_disk_cache_.WaitForIncomingResponse();
   ASSERT_FALSE(file.empty());
   ASSERT_TRUE(base::ReadFileToString(file, &received_content));
   EXPECT_EQ(new_content, received_content);
   saved_file = cache_dir.Append("file");
   EXPECT_FALSE(base::PathExists(saved_file));
 }
 
 }  // namespace mojo