TestFileSystemOriginInitialization.cpp (22402B)
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */ 3 /* This Source Code Form is subject to the terms of the Mozilla Public 4 * License, v. 2.0. If a copy of the MPL was not distributed with this file, 5 * You can obtain one at http://mozilla.org/MPL/2.0/. */ 6 7 #include "FileSystemParentTest.h" 8 #include "FileSystemParentTestHelpers.h" 9 #include "FileSystemParentTypes.h" 10 #include "gmock/gmock.h" 11 #include "gtest/gtest.h" 12 #include "mozilla/dom/FileSystemQuotaClient.h" 13 #include "mozilla/dom/FileSystemQuotaClientFactory.h" 14 #include "mozilla/dom/quota/UsageInfo.h" 15 #include "nsIPrefBranch.h" 16 #include "nsIPrefService.h" 17 18 // This file is intended for integration tests which verify origin 19 // initialization. 20 21 namespace mozilla::dom::fs::test { 22 23 using ::testing::_; 24 using ::testing::Expectation; 25 using ::testing::Sequence; 26 27 namespace { 28 29 class MockFileSystemQuotaClient : public FileSystemQuotaClient { 30 public: 31 MOCK_METHOD((Result<quota::UsageInfo, nsresult>), InitOrigin, 32 (quota::PersistenceType aPersistenceType, 33 const quota::OriginMetadata& aOriginMetadata, 34 const AtomicBool& aCanceled), 35 (override)); 36 37 MOCK_METHOD((Result<quota::UsageInfo, nsresult>), GetUsageForOrigin, 38 (quota::PersistenceType aPersistenceType, 39 const quota::OriginMetadata& aOriginMetadata, 40 const AtomicBool& aCanceled), 41 (override)); 42 43 void DelegateToBase() { 44 // This exists just to workaround the false positive: 45 // ERROR: Refcounted variable 'this' of type 'mozilla::dom::fs::test:: 46 // (anonymous namespace)::MockFileSystemQuotaClient' cannot be captured by 47 // a lambda 48 bool dummy; 49 50 ON_CALL(*this, InitOrigin) 51 .WillByDefault( 52 [&dummy, this](quota::PersistenceType aPersistenceType, 53 const quota::OriginMetadata& aOriginMetadata, 54 const Atomic<bool>& aCanceled) { 55 (void)dummy; 56 return FileSystemQuotaClient::InitOrigin( 57 aPersistenceType, aOriginMetadata, aCanceled); 58 }); 59 60 ON_CALL(*this, GetUsageForOrigin) 61 .WillByDefault( 62 [&dummy, this](quota::PersistenceType aPersistenceType, 63 const quota::OriginMetadata& aOriginMetadata, 64 const Atomic<bool>& aCanceled) { 65 (void)dummy; 66 return FileSystemQuotaClient::GetUsageForOrigin( 67 aPersistenceType, aOriginMetadata, aCanceled); 68 }); 69 } 70 }; 71 72 class TestFileSystemQuotaClientFactory final 73 : public FileSystemQuotaClientFactory { 74 public: 75 already_AddRefed<MockFileSystemQuotaClient> GetQuotaClient() { 76 return do_AddRef(mQuotaClient); 77 } 78 79 protected: 80 already_AddRefed<quota::Client> AllocQuotaClient() override { 81 mQuotaClient = MakeRefPtr<MockFileSystemQuotaClient>(); 82 mQuotaClient->DelegateToBase(); 83 return do_AddRef(mQuotaClient); 84 } 85 86 RefPtr<MockFileSystemQuotaClient> mQuotaClient; 87 }; 88 89 } // namespace 90 91 class TestFileSystemOriginInitialization : public FileSystemParentTest { 92 protected: 93 static void SetUpTestCase() { 94 nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID); 95 prefs->SetBoolPref("dom.quotaManager.loadQuotaFromCache", false); 96 97 auto factory = MakeRefPtr<TestFileSystemQuotaClientFactory>(); 98 99 FileSystemQuotaClientFactory::SetCustomFactory(factory); 100 101 ASSERT_NO_FATAL_FAILURE(FileSystemParentTest::SetUpTestCase()); 102 103 sQuotaClient = factory->GetQuotaClient(); 104 } 105 106 static void TearDownTestCase() { 107 sQuotaClient = nullptr; 108 109 ASSERT_NO_FATAL_FAILURE(FileSystemParentTest::TearDownTestCase()); 110 111 FileSystemQuotaClientFactory::SetCustomFactory(nullptr); 112 } 113 114 static RefPtr<MockFileSystemQuotaClient> sQuotaClient; 115 }; 116 117 constinit RefPtr<MockFileSystemQuotaClient> 118 TestFileSystemOriginInitialization::sQuotaClient; 119 120 TEST_F(TestFileSystemOriginInitialization, EmptyOriginDirectory) { 121 ASSERT_NO_FATAL_FAILURE(ShutdownStorage()); 122 123 // Set expectations 124 { 125 Sequence s; 126 127 EXPECT_CALL(*sQuotaClient, InitOrigin(_, _, _)).Times(0).InSequence(s); 128 129 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)) 130 .Times(0) 131 .InSequence(s); 132 } 133 134 // Initialize origin 135 ASSERT_NO_FATAL_FAILURE(InitializeStorage()); 136 ASSERT_NO_FATAL_FAILURE(InitializeTemporaryStorage()); 137 ASSERT_NO_FATAL_FAILURE( 138 InitializeTemporaryOrigin(/* aCreateIfNonExistent */ true)); 139 140 // After initialization, 141 // * origin usage is nothing 142 // * cached origin usage is zero 143 quota::UsageInfo usageNow; 144 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 145 ASSERT_NO_FATAL_FAILURE(CheckUsageIsNothing(usageNow)); 146 147 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 148 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, 0u)); 149 150 // Shutdown temporary storage 151 ASSERT_NO_FATAL_FAILURE(ShutdownTemporaryStorage()); 152 153 // After temporary storage shutdown, 154 // * origin usage is still nothing 155 // * cached origin is still zero 156 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 157 ASSERT_NO_FATAL_FAILURE(CheckUsageIsNothing(usageNow)); 158 159 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 160 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, 0u)); 161 162 // Initialize temporary storage again. 163 ASSERT_NO_FATAL_FAILURE(AssertTemporaryStorageNotInitialized()); 164 ASSERT_NO_FATAL_FAILURE(InitializeTemporaryStorage()); 165 166 // After repeated temporary storage initialization, 167 // * origin usage is still nothing 168 // * cached origin is still zero 169 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 170 ASSERT_NO_FATAL_FAILURE(CheckUsageIsNothing(usageNow)); 171 172 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 173 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, 0u)); 174 } 175 176 TEST_F(TestFileSystemOriginInitialization, EmptyFileSystemDirectory) { 177 ASSERT_NO_FATAL_FAILURE(ShutdownStorage()); 178 179 // Set expectations 180 { 181 Sequence s; 182 183 EXPECT_CALL(*sQuotaClient, InitOrigin(_, _, _)).Times(0).InSequence(s); 184 185 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)) 186 .Times(0) 187 .InSequence(s); 188 } 189 190 // Initialize client 191 ASSERT_NO_FATAL_FAILURE(InitializeStorage()); 192 ASSERT_NO_FATAL_FAILURE(InitializeTemporaryStorage()); 193 ASSERT_NO_FATAL_FAILURE(InitializeTemporaryOrigin()); 194 ASSERT_NO_FATAL_FAILURE(InitializeTemporaryClient()); 195 196 // After initialization, 197 // * origin usage is nothing 198 // * cached origin usage is zero 199 quota::UsageInfo usageNow; 200 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 201 ASSERT_NO_FATAL_FAILURE(CheckUsageIsNothing(usageNow)); 202 203 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 204 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, 0u)); 205 206 // Shutdown temporary storage. 207 ASSERT_NO_FATAL_FAILURE(ShutdownTemporaryStorage()); 208 209 // After temporary storage shutdown, 210 // * origin usage is still nothing 211 // * cached origin usage is still zero 212 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 213 ASSERT_NO_FATAL_FAILURE(CheckUsageIsNothing(usageNow)); 214 215 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 216 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, 0u)); 217 218 // Initialize temporary storage again. 219 ASSERT_NO_FATAL_FAILURE(InitializeTemporaryStorage()); 220 221 // After repeated temporary storage initialization, 222 // * origin usage is still nothing 223 // * cached origin usage is still zero 224 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 225 ASSERT_NO_FATAL_FAILURE(CheckUsageIsNothing(usageNow)); 226 227 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 228 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, 0u)); 229 } 230 231 TEST_F(TestFileSystemOriginInitialization, EmptyFileSystemDatabase) { 232 ASSERT_NO_FATAL_FAILURE(ShutdownStorage()); 233 234 // Set expectations 235 { 236 Sequence s; 237 238 // GetOriginUsage check after database initialization. 239 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)).InSequence(s); 240 241 // GetOriginUsage check when temporary storage is not initialized. 242 EXPECT_CALL(*sQuotaClient, InitOrigin(_, _, _)).InSequence(s); 243 244 // Repeated temporary storage initialization. 245 EXPECT_CALL(*sQuotaClient, InitOrigin(_, _, _)).InSequence(s); 246 247 // Final GetOriginUsage check. 248 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)).InSequence(s); 249 } 250 251 // Initialize database 252 ASSERT_NO_FATAL_FAILURE(EnsureDataManager()); 253 254 // After initialization, 255 // * origin usage is not zero 256 // * GetOriginUsage and GetCachedOriginUsage should agree 257 quota::UsageInfo usageNow; 258 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 259 ASSERT_NO_FATAL_FAILURE(CheckUsageGreaterThan(usageNow, 0u)); 260 261 uint64_t beforeShutdownUsage; 262 ASSERT_NO_FATAL_FAILURE(GetUsageValue(usageNow, beforeShutdownUsage)); 263 264 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 265 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 266 267 // Shutdown temporary storage. 268 ASSERT_NO_FATAL_FAILURE(ReleaseDataManager()); 269 ASSERT_NO_FATAL_FAILURE(ShutdownTemporaryStorage()); 270 271 // After temporary storage shutdown, 272 // * origin usage is still the same as before shutdown 273 // * cached origin usage is zero 274 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 275 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 276 277 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 278 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, 0u)); 279 280 // Initialize temporary storage again. 281 ASSERT_NO_FATAL_FAILURE(InitializeTemporaryStorage()); 282 283 // After repeated temporary storage initialization, 284 // * origin usage is still the same as before shutdown 285 // * GetOriginUsage and GetCachedOriginUsage should agree again 286 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 287 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 288 289 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 290 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 291 } 292 293 TEST_F(TestFileSystemOriginInitialization, EmptyFileSystemFile) { 294 ASSERT_NO_FATAL_FAILURE(ShutdownStorage()); 295 296 // Set expectations 297 { 298 Sequence s; 299 300 // GetOriginUsage check after file creation. 301 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)).InSequence(s); 302 303 // GetOriginUsage check when temporary storage is not initialized. 304 EXPECT_CALL(*sQuotaClient, InitOrigin(_, _, _)).InSequence(s); 305 306 // Repeated temporary storage initialization. 307 EXPECT_CALL(*sQuotaClient, InitOrigin(_, _, _)).InSequence(s); 308 309 // Final GetOriginUsage check. 310 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)).InSequence(s); 311 } 312 313 // Initialize database 314 ASSERT_NO_FATAL_FAILURE(EnsureDataManager()); 315 316 // Create a new empty file 317 EntryId testFileId; 318 ASSERT_NO_FATAL_FAILURE(CreateNewEmptyFile(testFileId)); 319 320 // After a new file has been created (only in the database), 321 // * origin usage is not zero 322 // * GetOriginUsage and GetCachedOriginUsage should agree 323 quota::UsageInfo usageNow; 324 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 325 ASSERT_NO_FATAL_FAILURE(CheckUsageGreaterThan(usageNow, 0u)); 326 327 uint64_t beforeShutdownUsage; 328 ASSERT_NO_FATAL_FAILURE(GetUsageValue(usageNow, beforeShutdownUsage)); 329 330 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 331 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 332 333 // Shutdown temporary storage. 334 ASSERT_NO_FATAL_FAILURE(ReleaseDataManager()); 335 ASSERT_NO_FATAL_FAILURE(ShutdownTemporaryStorage()); 336 337 // After temporary storage shutdown, 338 // * origin usage is still the same as before shutdown 339 // * cached origin usage is zero 340 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 341 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 342 343 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 344 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, 0u)); 345 346 // Initialize temporary storage again. 347 ASSERT_NO_FATAL_FAILURE(InitializeTemporaryStorage()); 348 349 // After repeated temporary storage initialization, 350 // * origin usage is still the same as before shutdown 351 // * GetOriginUsage and GetCachedOriginUsage should agree 352 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 353 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 354 355 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 356 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 357 } 358 359 TEST_F(TestFileSystemOriginInitialization, NonEmptyFileSystemFile) { 360 ASSERT_NO_FATAL_FAILURE(ShutdownStorage()); 361 362 // Set expectations 363 { 364 Sequence s; 365 366 // GetOriginUsage check after filling the file with content. 367 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)).InSequence(s); 368 369 // GetOriginUsage check after unlocking the file.. 370 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)).InSequence(s); 371 372 // GetOriginUsage check when temporary storage is not initialized. 373 EXPECT_CALL(*sQuotaClient, InitOrigin(_, _, _)).InSequence(s); 374 375 // Repeated temporary storage initialization. 376 EXPECT_CALL(*sQuotaClient, InitOrigin(_, _, _)).InSequence(s); 377 378 // Final GetOriginUsage check. 379 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)).InSequence(s); 380 } 381 382 // Initialize database 383 ASSERT_NO_FATAL_FAILURE(EnsureDataManager()); 384 385 // Create a new empty file 386 EntryId testFileId; 387 ASSERT_NO_FATAL_FAILURE(CreateNewEmptyFile(testFileId)); 388 389 // Fill the file with some content 390 ASSERT_NO_FATAL_FAILURE(LockExclusive(testFileId)); 391 392 const nsCString& testData = GetTestData(); 393 394 ASSERT_NO_FATAL_FAILURE(WriteDataToFile(testFileId, testData)); 395 396 // After the content has been written to the file, 397 // * origin usage is not zero 398 // * GetOriginUsage and GetCachedOriginUsage should agree 399 quota::UsageInfo usageNow; 400 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 401 ASSERT_NO_FATAL_FAILURE(CheckUsageGreaterThan(usageNow, 0u)); 402 403 uint64_t beforeShutdownUsage; 404 ASSERT_NO_FATAL_FAILURE(GetUsageValue(usageNow, beforeShutdownUsage)); 405 406 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 407 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 408 409 ASSERT_NO_FATAL_FAILURE(UnlockExclusive(testFileId)); 410 411 // After the file has been unlocked, 412 // * origin usage is still the same as before unlocking 413 // * GetOriginUsage and GetCachedOriginUsage should still agree 414 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 415 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 416 417 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 418 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 419 420 // Shutdown temporary storage. 421 ASSERT_NO_FATAL_FAILURE(ReleaseDataManager()); 422 ASSERT_NO_FATAL_FAILURE(ShutdownTemporaryStorage()); 423 424 // After temporary storage shutdown, 425 // * origin usage is still the same as before shutdown 426 // * cached origin usage is zero 427 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 428 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 429 430 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 431 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, 0u)); 432 433 // Initialize temporary storage again. 434 ASSERT_NO_FATAL_FAILURE(InitializeTemporaryStorage()); 435 436 // After repeated temporary storage initialization, 437 // * origin usage is still the same as before shutdown 438 // * GetOriginUsage and GetCachedOriginUsage should agree again 439 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 440 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 441 442 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 443 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 444 } 445 446 TEST_F(TestFileSystemOriginInitialization, 447 NonEmptyFileSystemFile_UncleanShutdown) { 448 ASSERT_NO_FATAL_FAILURE(ShutdownStorage()); 449 450 // Set expectations 451 { 452 Sequence s; 453 454 // GetOriginUsage check after file creation. 455 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)).InSequence(s); 456 457 // GetOriginUsage check after filling the file with content. 458 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)).InSequence(s); 459 460 // GetOriginUsage check when temporary storage is not initialized. 461 EXPECT_CALL(*sQuotaClient, InitOrigin(_, _, _)).InSequence(s); 462 463 // Repeated temporary storage initialization. 464 EXPECT_CALL(*sQuotaClient, InitOrigin(_, _, _)).InSequence(s); 465 466 // Final GetOriginUsage check. 467 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)).InSequence(s); 468 } 469 470 // Initialize database 471 ASSERT_NO_FATAL_FAILURE(EnsureDataManager()); 472 473 // Create a new empty file 474 EntryId testFileId; 475 ASSERT_NO_FATAL_FAILURE(CreateNewEmptyFile(testFileId)); 476 477 // After a new file has been created (only in the database), 478 // * origin usage is not zero 479 // * GetOriginUsage and GetCachedOriginUsage should agree 480 quota::UsageInfo usageNow; 481 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 482 ASSERT_NO_FATAL_FAILURE(CheckUsageGreaterThan(usageNow, 0u)); 483 484 uint64_t beforeWriteUsage; 485 ASSERT_NO_FATAL_FAILURE(GetUsageValue(usageNow, beforeWriteUsage)); 486 487 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 488 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeWriteUsage)); 489 490 // Fill the file with some content 491 ASSERT_NO_FATAL_FAILURE(LockExclusive(testFileId)); 492 493 const nsCString& testData = GetTestData(); 494 495 ASSERT_NO_FATAL_FAILURE(WriteDataToFile(testFileId, testData)); 496 497 // After the content has been written to the file, 498 // * origin usage is not the same as before writing 499 // * GetOriginUsage and GetCachedOriginUsage should still agree 500 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 501 ASSERT_NO_FATAL_FAILURE(CheckUsageGreaterThan(usageNow, beforeWriteUsage)); 502 503 uint64_t beforeShutdownUsage; 504 ASSERT_NO_FATAL_FAILURE(GetUsageValue(usageNow, beforeShutdownUsage)); 505 506 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 507 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 508 509 // UnlockExclusive is not called here on purpose to simmulate unclean 510 // shutdown. 511 512 // Shutdown temporary storage. 513 ASSERT_NO_FATAL_FAILURE(ReleaseDataManager()); 514 ASSERT_NO_FATAL_FAILURE(ShutdownTemporaryStorage()); 515 516 // After temporary storage shutdown, 517 // * static database usage is the same as before writing 518 // * origin usage is still the same as before shutdown 519 // * cached origin usage is zero 520 ASSERT_NO_FATAL_FAILURE(GetStaticDatabaseUsage(usageNow)); 521 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeWriteUsage)); 522 523 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 524 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 525 526 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 527 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, 0u)); 528 529 // Initialize temporary storage again. 530 ASSERT_NO_FATAL_FAILURE(InitializeTemporaryStorage()); 531 532 // After repeated temporary storage initialization, 533 // * static database usage is the same as before shutdown 534 // * GetStaticDatabaseUsage, GetOriginUsage and GetCachedOriginUsage should 535 // all agree again 536 ASSERT_NO_FATAL_FAILURE(GetStaticDatabaseUsage(usageNow)); 537 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 538 539 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 540 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 541 542 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 543 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 544 } 545 546 TEST_F(TestFileSystemOriginInitialization, RemovedFileSystemFile) { 547 ASSERT_NO_FATAL_FAILURE(ShutdownStorage()); 548 549 // Set expectations 550 { 551 Sequence s; 552 553 // GetOriginUsage check after removing the file.. 554 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)).InSequence(s); 555 556 // GetOriginUsage check when temporary storage is not initialized. 557 EXPECT_CALL(*sQuotaClient, InitOrigin(_, _, _)).InSequence(s); 558 559 // Repeated temporary storage initialization. 560 EXPECT_CALL(*sQuotaClient, InitOrigin(_, _, _)).InSequence(s); 561 562 // Final GetOriginUsage check. 563 EXPECT_CALL(*sQuotaClient, GetUsageForOrigin(_, _, _)).InSequence(s); 564 } 565 566 // Initialize database 567 ASSERT_NO_FATAL_FAILURE(EnsureDataManager()); 568 569 // Create a new empty file 570 EntryId testFileId; 571 ASSERT_NO_FATAL_FAILURE(CreateNewEmptyFile(testFileId)); 572 573 // Fill the file with some content 574 ASSERT_NO_FATAL_FAILURE(LockExclusive(testFileId)); 575 576 const nsCString& testData = GetTestData(); 577 578 ASSERT_NO_FATAL_FAILURE(WriteDataToFile(testFileId, testData)); 579 580 ASSERT_NO_FATAL_FAILURE(UnlockExclusive(testFileId)); 581 582 // Remove the file 583 bool wasRemoved; 584 ASSERT_NO_FATAL_FAILURE(RemoveFile(wasRemoved)); 585 ASSERT_TRUE(wasRemoved); 586 587 // After the file has been removed, 588 // * origin usage is not zero 589 // * GetOriginUsage and GetCachedOriginUsage should agree 590 quota::UsageInfo usageNow; 591 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 592 ASSERT_NO_FATAL_FAILURE(CheckUsageGreaterThan(usageNow, 0u)); 593 594 uint64_t beforeShutdownUsage; 595 ASSERT_NO_FATAL_FAILURE(GetUsageValue(usageNow, beforeShutdownUsage)); 596 597 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 598 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 599 600 // Shutdown temporary storage. 601 ASSERT_NO_FATAL_FAILURE(ReleaseDataManager()); 602 ASSERT_NO_FATAL_FAILURE(ShutdownTemporaryStorage()); 603 604 // After temporary storage shutdown, 605 // * origin usage is still the same as before shutdown 606 // * cached origin usage is zero 607 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 608 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 609 610 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 611 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, 0u)); 612 613 // Initialize temporary storage again. 614 ASSERT_NO_FATAL_FAILURE(InitializeTemporaryStorage()); 615 616 // After repeated temporary storage initialization, 617 // * origin usage is still the same as before shutdown 618 // * GetOriginUsage and GetCachedOriginUsage should agree again 619 ASSERT_NO_FATAL_FAILURE(GetOriginUsage(usageNow)); 620 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 621 622 ASSERT_NO_FATAL_FAILURE(GetCachedOriginUsage(usageNow)); 623 ASSERT_NO_FATAL_FAILURE(CheckUsageEqualTo(usageNow, beforeShutdownUsage)); 624 } 625 626 } // namespace mozilla::dom::fs::test