apps/saved_files_service_unittest.cc

   1 // Copyright 2013 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <algorithm>
   6
   7 #include "apps/saved_files_service.h"
   8 #include "base/files/file_path.h"
   9 #include "base/memory/raw_ptr.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/test/values_test_util.h"
  12 #include "base/values.h"
  13 #include "chrome/browser/extensions/test_extension_environment.h"
  14 #include "chrome/test/base/testing_profile.h"
  15 #include "extensions/browser/api/file_system/saved_file_entry.h"
  16 #include "extensions/browser/extension_prefs.h"
  17 #include "extensions/browser/extension_system.h"
  18 #include "extensions/common/extension.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 #define TRACE_CALL(expression) \
  22   do {                         \
  23     SCOPED_TRACE(#expression); \
  24     expression;                \
  25   } while (0)
  26
  27 using apps::SavedFilesService;
  28 using extensions::SavedFileEntry;
  29
  30 namespace {
  31
  32 std::string GenerateId(int i) {
  33   return base::NumberToString(i) + ":filename.ext";
  34 }
  35
  36 }  // namespace
  37
  38 class SavedFilesServiceUnitTest : public testing::Test {
  39  protected:
  40   void SetUp() override {
  41     static const char kManifest[] =
  42         "{"
  43         "  \"app\": {"
  44         "    \"background\": {"
  45         "      \"scripts\": [\"background.js\"]"
  46         "    }"
  47         "  },"
  48         "  \"permissions\": ["
  49         "    {\"fileSystem\": [\"retainEntries\"]}"
  50         "  ]"
  51         "}";
  52     testing::Test::SetUp();
  53     extension_ = env_.MakeExtension(base::test::ParseJsonDict(kManifest));
  54     service_ = SavedFilesService::Get(env_.profile());
  55     path_ = base::FilePath(FILE_PATH_LITERAL("filename.ext"));
  56   }
  57
  58   void TearDown() override {
  59     SavedFilesService::ClearMaxSequenceNumberForTest();
  60     SavedFilesService::ClearLruSizeForTest();
  61     testing::Test::TearDown();
  62   }
  63
  64   // Check that a registered file entry has the correct value.
  65   void CheckEntrySequenceNumber(int id, int sequence_number) {
  66     std::string id_string = GenerateId(id);
  67     SCOPED_TRACE(id_string);
  68     EXPECT_TRUE(service_->IsRegistered(extension_->id(), id_string));
  69     const SavedFileEntry* entry =
  70         service_->GetFileEntry(extension_->id(), id_string);
  71     ASSERT_TRUE(entry);
  72     EXPECT_EQ(id_string, entry->id);
  73     EXPECT_EQ(path_, entry->path);
  74     EXPECT_TRUE(entry->is_directory);
  75     EXPECT_EQ(sequence_number, entry->sequence_number);
  76   }
  77
  78   // Check that a range of registered file entries have the correct values.
  79   void CheckRangeEnqueuedInOrder(int start, int end) {
  80     SavedFileEntry entry;
  81     for (int i = start; i < end; i++) {
  82       CheckEntrySequenceNumber(i, i + 1);
  83     }
  84   }
  85
  86   extensions::TestExtensionEnvironment env_;
  87   raw_ptr<const extensions::Extension> extension_;
  88   raw_ptr<SavedFilesService> service_;
  89   base::FilePath path_;
  90 };
  91
  92 TEST_F(SavedFilesServiceUnitTest, RetainTwoFilesTest) {
  93   service_->RegisterFileEntry(extension_->id(), GenerateId(1), path_, true);
  94   service_->RegisterFileEntry(extension_->id(), GenerateId(2), path_, true);
  95   service_->RegisterFileEntry(extension_->id(), GenerateId(3), path_, true);
  96
  97   // Test that no entry has a sequence number.
  98   TRACE_CALL(CheckEntrySequenceNumber(1, 0));
  99   TRACE_CALL(CheckEntrySequenceNumber(2, 0));
 100   TRACE_CALL(CheckEntrySequenceNumber(3, 0));
 101
 102   // Test that only entry #1 has a sequence number.
 103   service_->EnqueueFileEntry(extension_->id(), GenerateId(1));
 104   TRACE_CALL(CheckEntrySequenceNumber(1, 1));
 105   TRACE_CALL(CheckEntrySequenceNumber(2, 0));
 106
 107   // Test that entry #1 has not changed sequence number because it is the most
 108   // recently enqueued entry.
 109   service_->EnqueueFileEntry(extension_->id(), GenerateId(1));
 110   TRACE_CALL(CheckEntrySequenceNumber(1, 1));
 111   TRACE_CALL(CheckEntrySequenceNumber(2, 0));
 112
 113   // Test that entry #1 is unchanged and entry #2 has been assigned the next
 114   // sequence number.
 115   service_->EnqueueFileEntry(extension_->id(), GenerateId(2));
 116   TRACE_CALL(CheckEntrySequenceNumber(1, 1));
 117   TRACE_CALL(CheckEntrySequenceNumber(2, 2));
 118
 119   // Test that both entries #1 and #2 are unchanged because #2 is the most
 120   // recently enqueued entry.
 121   service_->EnqueueFileEntry(extension_->id(), GenerateId(2));
 122   TRACE_CALL(CheckEntrySequenceNumber(1, 1));
 123   TRACE_CALL(CheckEntrySequenceNumber(2, 2));
 124
 125   // Test that entry #1 has been assigned the next sequence number.
 126   service_->EnqueueFileEntry(extension_->id(), GenerateId(1));
 127   TRACE_CALL(CheckEntrySequenceNumber(1, 3));
 128   TRACE_CALL(CheckEntrySequenceNumber(2, 2));
 129   TRACE_CALL(CheckEntrySequenceNumber(3, 0));
 130
 131   EXPECT_FALSE(service_->IsRegistered(extension_->id(), "another id"));
 132   SavedFileEntry entry;
 133   EXPECT_FALSE(service_->GetFileEntry(extension_->id(), "another id"));
 134
 135   // ClearQueueIfNoRetainPermission should be a no-op because the app has the
 136   // fileSystem.retainEntries permission.
 137   service_->ClearQueueIfNoRetainPermission(extension_);
 138   TRACE_CALL(CheckEntrySequenceNumber(1, 3));
 139   TRACE_CALL(CheckEntrySequenceNumber(2, 2));
 140   TRACE_CALL(CheckEntrySequenceNumber(3, 0));
 141
 142   // Test that after a clear, retained file entries are unchanged, but file
 143   // entries that have been registered but not retained are no longer
 144   // registered.
 145   service_->Clear(extension_->id());
 146   TRACE_CALL(CheckEntrySequenceNumber(1, 3));
 147   TRACE_CALL(CheckEntrySequenceNumber(2, 2));
 148   EXPECT_FALSE(service_->IsRegistered(extension_->id(), GenerateId(3)));
 149 }
 150
 151 TEST_F(SavedFilesServiceUnitTest, NoRetainEntriesPermissionTest) {
 152   static const char kManifest[] =
 153       "{\"app\": {\"background\": {\"scripts\": [\"background.js\"]}},"
 154       "\"permissions\": [\"fileSystem\"]}";
 155   extension_ = nullptr;
 156   extension_ = env_.MakeExtension(base::test::ParseJsonDict(kManifest));
 157   service_->RegisterFileEntry(extension_->id(), GenerateId(1), path_, true);
 158   TRACE_CALL(CheckEntrySequenceNumber(1, 0));
 159   SavedFileEntry entry;
 160   service_->EnqueueFileEntry(extension_->id(), GenerateId(1));
 161   TRACE_CALL(CheckEntrySequenceNumber(1, 1));
 162   EXPECT_FALSE(service_->IsRegistered(extension_->id(), "another id"));
 163   EXPECT_FALSE(service_->GetFileEntry(extension_->id(), "another id"));
 164
 165   // ClearQueueIfNoRetainPermission should clear the queue, since the app does
 166   // not have the "retainEntries" permission.
 167   service_->ClearQueueIfNoRetainPermission(extension_);
 168   std::vector<SavedFileEntry> entries =
 169       service_->GetAllFileEntries(extension_->id());
 170   EXPECT_TRUE(entries.empty());
 171 }
 172
 173 TEST_F(SavedFilesServiceUnitTest, EvictionTest) {
 174   SavedFilesService::SetLruSizeForTest(10);
 175   for (int i = 0; i < 10; i++) {
 176     service_->RegisterFileEntry(extension_->id(), GenerateId(i), path_, true);
 177     service_->EnqueueFileEntry(extension_->id(), GenerateId(i));
 178   }
 179   service_->RegisterFileEntry(extension_->id(), GenerateId(10), path_, true);
 180
 181   // Expect that entries 0 to 9 are in the queue, but 10 is not.
 182   TRACE_CALL(CheckRangeEnqueuedInOrder(0, 10));
 183   TRACE_CALL(CheckEntrySequenceNumber(10, 0));
 184   service_->EnqueueFileEntry(extension_->id(), GenerateId(10));
 185
 186   // Expect that entries 1 to 10 are in the queue, but entry 0 is not.
 187   TRACE_CALL(CheckEntrySequenceNumber(0, 0));
 188   TRACE_CALL(CheckRangeEnqueuedInOrder(1, 11));
 189
 190   // Check that retained entries are unchanged after a clear.
 191   service_->Clear(extension_->id());
 192   SavedFileEntry entry;
 193   EXPECT_FALSE(service_->GetFileEntry(extension_->id(), GenerateId(0)));
 194   TRACE_CALL(CheckRangeEnqueuedInOrder(1, 11));
 195
 196   // Expect that entry 2 is now at the back of the queue, and no further entries
 197   // have been evicted.
 198   service_->EnqueueFileEntry(extension_->id(), GenerateId(2));
 199   TRACE_CALL(CheckEntrySequenceNumber(2, 12));
 200   TRACE_CALL(CheckRangeEnqueuedInOrder(1, 1));
 201   TRACE_CALL(CheckRangeEnqueuedInOrder(3, 11));
 202
 203   // Check that retained entries are unchanged after a clear.
 204   service_->Clear(extension_->id());
 205   TRACE_CALL(CheckEntrySequenceNumber(2, 12));
 206   TRACE_CALL(CheckRangeEnqueuedInOrder(1, 1));
 207   TRACE_CALL(CheckRangeEnqueuedInOrder(3, 11));
 208 }
 209
 210 TEST_F(SavedFilesServiceUnitTest, SequenceNumberCompactionTest) {
 211   SavedFilesService::SetMaxSequenceNumberForTest(8);
 212   SavedFilesService::SetLruSizeForTest(8);
 213   for (int i = 0; i < 4; i++) {
 214     service_->RegisterFileEntry(extension_->id(), GenerateId(i), path_, true);
 215     service_->EnqueueFileEntry(extension_->id(), GenerateId(i));
 216   }
 217   service_->EnqueueFileEntry(extension_->id(), GenerateId(2));
 218   service_->EnqueueFileEntry(extension_->id(), GenerateId(3));
 219   service_->EnqueueFileEntry(extension_->id(), GenerateId(2));
 220
 221   // The sequence numbers should be sparse, as they have not gone over the
 222   // limit.
 223   TRACE_CALL(CheckEntrySequenceNumber(0, 1));
 224   TRACE_CALL(CheckEntrySequenceNumber(1, 2));
 225   TRACE_CALL(CheckEntrySequenceNumber(2, 7));
 226   TRACE_CALL(CheckEntrySequenceNumber(3, 6));
 227   service_->Clear(extension_->id());
 228   TRACE_CALL(CheckEntrySequenceNumber(0, 1));
 229   TRACE_CALL(CheckEntrySequenceNumber(1, 2));
 230   TRACE_CALL(CheckEntrySequenceNumber(2, 7));
 231   TRACE_CALL(CheckEntrySequenceNumber(3, 6));
 232
 233   // This should push the sequence number to the limit of 8, and trigger a
 234   // sequence number compaction. Expect that the sequence numbers are
 235   // contiguous from 1 to 4.
 236   service_->EnqueueFileEntry(extension_->id(), GenerateId(3));
 237   TRACE_CALL(CheckRangeEnqueuedInOrder(0, 4));
 238   service_->Clear(extension_->id());
 239   TRACE_CALL(CheckRangeEnqueuedInOrder(0, 4));
 240 }