archive_manager_unittest.cc 8.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213
  1. // Copyright 2015 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/offline_pages/core/archive_manager.h"
  5. #include <algorithm>
  6. #include <memory>
  7. #include <set>
  8. #include "base/bind.h"
  9. #include "base/files/file.h"
  10. #include "base/files/file_path.h"
  11. #include "base/files/file_util.h"
  12. #include "base/files/scoped_temp_dir.h"
  13. #include "base/system/sys_info.h"
  14. #include "base/test/metrics/histogram_tester.h"
  15. #include "base/test/test_simple_task_runner.h"
  16. #include "base/threading/thread_task_runner_handle.h"
  17. #include "testing/gtest/include/gtest/gtest.h"
  18. namespace offline_pages {
  19. enum class CallbackStatus {
  20. NOT_CALLED,
  21. CALLED_FALSE,
  22. CALLED_TRUE,
  23. };
  24. class ArchiveManagerTest : public testing::Test {
  25. public:
  26. ArchiveManagerTest();
  27. void SetUp() override;
  28. void PumpLoop();
  29. void ResetResults();
  30. void ResetManager(const base::FilePath& temporary_dir,
  31. const base::FilePath& private_archive_dir,
  32. const base::FilePath& public_archive_dir);
  33. void Callback(bool result);
  34. void GetStorageStatsCallback(
  35. const ArchiveManager::StorageStats& storage_sizes);
  36. ArchiveManager* manager() { return manager_.get(); }
  37. const base::FilePath& temporary_archive_path() const {
  38. return manager_->GetTemporaryArchivesDir();
  39. }
  40. const base::FilePath& private_archive_path() const {
  41. return manager_->GetPrivateArchivesDir();
  42. }
  43. const base::FilePath& public_archive_path() const {
  44. return manager_->GetPublicArchivesDir();
  45. }
  46. CallbackStatus callback_status() const { return callback_status_; }
  47. const std::set<base::FilePath>& last_archive_paths() const {
  48. return last_archive_paths_;
  49. }
  50. ArchiveManager::StorageStats last_storage_sizes() const {
  51. return last_storage_sizes_;
  52. }
  53. base::HistogramTester* histogram_tester() { return histogram_tester_.get(); }
  54. private:
  55. scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
  56. base::ThreadTaskRunnerHandle task_runner_handle_;
  57. base::ScopedTempDir temporary_dir_;
  58. base::ScopedTempDir private_archive_dir_;
  59. base::ScopedTempDir public_archive_dir_;
  60. std::unique_ptr<ArchiveManager> manager_;
  61. CallbackStatus callback_status_;
  62. std::set<base::FilePath> last_archive_paths_;
  63. ArchiveManager::StorageStats last_storage_sizes_;
  64. std::unique_ptr<base::HistogramTester> histogram_tester_;
  65. };
  66. ArchiveManagerTest::ArchiveManagerTest()
  67. : task_runner_(new base::TestSimpleTaskRunner),
  68. task_runner_handle_(task_runner_),
  69. callback_status_(CallbackStatus::NOT_CALLED),
  70. last_storage_sizes_({0, 0, 0}) {}
  71. void ArchiveManagerTest::SetUp() {
  72. ASSERT_TRUE(temporary_dir_.CreateUniqueTempDir());
  73. ASSERT_TRUE(private_archive_dir_.CreateUniqueTempDir());
  74. ASSERT_TRUE(public_archive_dir_.CreateUniqueTempDir());
  75. ResetManager(temporary_dir_.GetPath(), private_archive_dir_.GetPath(),
  76. public_archive_dir_.GetPath());
  77. histogram_tester_ = std::make_unique<base::HistogramTester>();
  78. }
  79. void ArchiveManagerTest::PumpLoop() {
  80. task_runner_->RunUntilIdle();
  81. }
  82. void ArchiveManagerTest::ResetResults() {
  83. callback_status_ = CallbackStatus::NOT_CALLED;
  84. last_archive_paths_.clear();
  85. }
  86. void ArchiveManagerTest::ResetManager(
  87. const base::FilePath& temporary_dir,
  88. const base::FilePath& private_archive_dir,
  89. const base::FilePath& public_archive_dir) {
  90. manager_ = std::make_unique<ArchiveManager>(
  91. temporary_dir, private_archive_dir, public_archive_dir,
  92. base::ThreadTaskRunnerHandle::Get());
  93. }
  94. void ArchiveManagerTest::Callback(bool result) {
  95. callback_status_ =
  96. result ? CallbackStatus::CALLED_TRUE : CallbackStatus::CALLED_FALSE;
  97. }
  98. void ArchiveManagerTest::GetStorageStatsCallback(
  99. const ArchiveManager::StorageStats& storage_sizes) {
  100. last_storage_sizes_ = storage_sizes;
  101. }
  102. TEST_F(ArchiveManagerTest, EnsureArchivesDirCreated) {
  103. base::FilePath temporary_archive_dir =
  104. temporary_archive_path().Append(FILE_PATH_LITERAL("test_path"));
  105. base::FilePath private_archive_dir =
  106. private_archive_path().Append(FILE_PATH_LITERAL("test_path"));
  107. base::FilePath public_archive_dir(FILE_PATH_LITERAL("/sdcard/Download"));
  108. ResetManager(temporary_archive_dir, private_archive_dir, public_archive_dir);
  109. EXPECT_FALSE(base::PathExists(temporary_archive_dir));
  110. EXPECT_FALSE(base::PathExists(private_archive_dir));
  111. // Ensure archives dir exists, when it doesn't.
  112. manager()->EnsureArchivesDirCreated(base::BindOnce(
  113. &ArchiveManagerTest::Callback, base::Unretained(this), true));
  114. PumpLoop();
  115. EXPECT_EQ(CallbackStatus::CALLED_TRUE, callback_status());
  116. EXPECT_TRUE(base::PathExists(temporary_archive_dir));
  117. EXPECT_TRUE(base::PathExists(private_archive_dir));
  118. // The public dir does not get created by us, so we don't test its creation.
  119. histogram_tester()->ExpectUniqueSample(
  120. "OfflinePages.ArchiveManager.ArchiveDirsCreationResult2.Persistent",
  121. -base::File::Error::FILE_OK, 1);
  122. histogram_tester()->ExpectUniqueSample(
  123. "OfflinePages.ArchiveManager.ArchiveDirsCreationResult2.Temporary",
  124. -base::File::Error::FILE_OK, 1);
  125. // Try again when the file already exists.
  126. ResetResults();
  127. manager()->EnsureArchivesDirCreated(base::BindOnce(
  128. &ArchiveManagerTest::Callback, base::Unretained(this), true));
  129. PumpLoop();
  130. EXPECT_EQ(CallbackStatus::CALLED_TRUE, callback_status());
  131. EXPECT_TRUE(base::PathExists(temporary_archive_dir));
  132. EXPECT_TRUE(base::PathExists(private_archive_dir));
  133. histogram_tester()->ExpectTotalCount(
  134. "OfflinePages.ArchiveManager.ArchiveDirsCreationResult2.Persistent", 1);
  135. histogram_tester()->ExpectTotalCount(
  136. "OfflinePages.ArchiveManager.ArchiveDirsCreationResult2.Temporary", 1);
  137. }
  138. TEST_F(ArchiveManagerTest, GetStorageStats) {
  139. base::FilePath archive_path_1;
  140. EXPECT_TRUE(base::CreateTemporaryFileInDir(temporary_archive_path(),
  141. &archive_path_1));
  142. base::FilePath archive_path_2;
  143. EXPECT_TRUE(
  144. base::CreateTemporaryFileInDir(private_archive_path(), &archive_path_2));
  145. base::FilePath archive_path_3;
  146. EXPECT_TRUE(
  147. base::CreateTemporaryFileInDir(public_archive_path(), &archive_path_3));
  148. manager()->GetStorageStats(base::BindOnce(
  149. &ArchiveManagerTest::GetStorageStatsCallback, base::Unretained(this)));
  150. PumpLoop();
  151. EXPECT_GT(last_storage_sizes().internal_free_disk_space, 0);
  152. EXPECT_GT(last_storage_sizes().external_free_disk_space, 0);
  153. EXPECT_EQ(last_storage_sizes().temporary_archives_size,
  154. base::ComputeDirectorySize(temporary_archive_path()));
  155. EXPECT_EQ(last_storage_sizes().private_archives_size,
  156. base::ComputeDirectorySize(private_archive_path()));
  157. EXPECT_EQ(last_storage_sizes().public_archives_size,
  158. base::ComputeDirectorySize(public_archive_path()));
  159. }
  160. TEST_F(ArchiveManagerTest, TryWithInvalidTemporaryPath) {
  161. base::FilePath invalid_path;
  162. ResetManager(invalid_path, private_archive_path(), public_archive_path());
  163. manager()->GetStorageStats(base::BindOnce(
  164. &ArchiveManagerTest::GetStorageStatsCallback, base::Unretained(this)));
  165. PumpLoop();
  166. EXPECT_EQ(base::SysInfo::AmountOfFreeDiskSpace(temporary_archive_path()),
  167. last_storage_sizes().internal_free_disk_space);
  168. EXPECT_EQ(base::ComputeDirectorySize(private_archive_path()),
  169. last_storage_sizes().internal_archives_size());
  170. EXPECT_EQ(0, last_storage_sizes().temporary_archives_size);
  171. }
  172. TEST_F(ArchiveManagerTest, TryWithInvalidPublicPath) {
  173. base::FilePath invalid_path;
  174. ResetManager(temporary_archive_path(), private_archive_path(), invalid_path);
  175. manager()->GetStorageStats(base::BindOnce(
  176. &ArchiveManagerTest::GetStorageStatsCallback, base::Unretained(this)));
  177. PumpLoop();
  178. EXPECT_EQ(base::SysInfo::AmountOfFreeDiskSpace(public_archive_path()),
  179. last_storage_sizes().external_free_disk_space);
  180. EXPECT_EQ(base::ComputeDirectorySize(temporary_archive_path()) +
  181. base::ComputeDirectorySize(private_archive_path()),
  182. last_storage_sizes().internal_archives_size());
  183. EXPECT_EQ(0, last_storage_sizes().public_archives_size);
  184. }
  185. } // namespace offline_pages