tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

TestFileSystemDataManager.cpp (6114B)

      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 "FileSystemDataManager.h"
      8 #include "TestHelpers.h"
      9 #include "mozilla/MozPromise.h"
     10 #include "mozilla/SpinEventLoopUntil.h"
     11 #include "mozilla/dom/quota/ForwardDecls.h"
     12 #include "mozilla/dom/quota/test/QuotaManagerDependencyFixture.h"
     13 
     14 namespace mozilla::dom::fs::test {
     15 
     16 class TestFileSystemDataManager
     17    : public quota::test::QuotaManagerDependencyFixture {
     18 public:
     19  static void SetUpTestCase() { ASSERT_NO_FATAL_FAILURE(InitializeFixture()); }
     20 
     21  static void TearDownTestCase() {
     22    EXPECT_NO_FATAL_FAILURE(ClearStoragesForOrigin(GetTestOriginMetadata()));
     23    ASSERT_NO_FATAL_FAILURE(ShutdownFixture());
     24  }
     25 };
     26 
     27 TEST_F(TestFileSystemDataManager, GetOrCreateFileSystemDataManager) {
     28  auto backgroundTask = []() {
     29    bool done = false;
     30 
     31    data::FileSystemDataManager::GetOrCreateFileSystemDataManager(
     32        GetTestOriginMetadata())
     33        ->Then(
     34            GetCurrentSerialEventTarget(), __func__,
     35            [](Registered<data::FileSystemDataManager> registeredDataManager) {
     36              RefPtr<data::FileSystemDataManager> dataManager =
     37                  registeredDataManager.get();
     38 
     39              registeredDataManager = nullptr;
     40 
     41              return dataManager->OnClose();
     42            },
     43            [](nsresult rejectValue) {
     44              return BoolPromise::CreateAndReject(rejectValue, __func__);
     45            })
     46        ->Then(
     47            GetCurrentSerialEventTarget(), __func__,
     48            [&done](const BoolPromise::ResolveOrRejectValue&) { done = true; });
     49 
     50    SpinEventLoopUntil("Promise is fulfilled"_ns, [&done]() { return done; });
     51  };
     52 
     53  PerformOnBackgroundThread(std::move(backgroundTask));
     54 }
     55 
     56 TEST_F(TestFileSystemDataManager,
     57       GetOrCreateFileSystemDataManager_PendingOpen) {
     58  auto backgroundTask = []() {
     59    Registered<data::FileSystemDataManager> rdm1;
     60 
     61    Registered<data::FileSystemDataManager> rdm2;
     62 
     63    {
     64      bool done1 = false;
     65 
     66      data::FileSystemDataManager::GetOrCreateFileSystemDataManager(
     67          GetTestOriginMetadata())
     68          ->Then(
     69              GetCurrentSerialEventTarget(), __func__,
     70              [&rdm1, &done1](Registered<data::FileSystemDataManager>
     71                                  registeredDataManager) {
     72                ASSERT_TRUE(registeredDataManager->IsOpen());
     73 
     74                rdm1 = std::move(registeredDataManager);
     75 
     76                done1 = true;
     77              },
     78              [&done1](nsresult rejectValue) { done1 = true; });
     79 
     80      bool done2 = false;
     81 
     82      data::FileSystemDataManager::GetOrCreateFileSystemDataManager(
     83          GetTestOriginMetadata())
     84          ->Then(
     85              GetCurrentSerialEventTarget(), __func__,
     86              [&rdm2, &done2](Registered<data::FileSystemDataManager>
     87                                  registeredDataManager) {
     88                ASSERT_TRUE(registeredDataManager->IsOpen());
     89 
     90                rdm2 = std::move(registeredDataManager);
     91 
     92                done2 = true;
     93              },
     94              [&done2](nsresult rejectValue) { done2 = true; });
     95 
     96      SpinEventLoopUntil("Promise is fulfilled"_ns,
     97                         [&done1, &done2]() { return done1 && done2; });
     98    }
     99 
    100    RefPtr<data::FileSystemDataManager> dm1 = rdm1.unwrap();
    101 
    102    RefPtr<data::FileSystemDataManager> dm2 = rdm2.unwrap();
    103 
    104    {
    105      bool done1 = false;
    106 
    107      dm1->OnClose()->Then(
    108          GetCurrentSerialEventTarget(), __func__,
    109          [&done1](const BoolPromise::ResolveOrRejectValue&) { done1 = true; });
    110 
    111      bool done2 = false;
    112 
    113      dm2->OnClose()->Then(
    114          GetCurrentSerialEventTarget(), __func__,
    115          [&done2](const BoolPromise::ResolveOrRejectValue&) { done2 = true; });
    116 
    117      SpinEventLoopUntil("Promise is fulfilled"_ns,
    118                         [&done1, &done2]() { return done1 && done2; });
    119    }
    120  };
    121 
    122  PerformOnBackgroundThread(std::move(backgroundTask));
    123 }
    124 
    125 TEST_F(TestFileSystemDataManager,
    126       GetOrCreateFileSystemDataManager_PendingClose) {
    127  auto backgroundTask = []() {
    128    Registered<data::FileSystemDataManager> rdm;
    129 
    130    {
    131      bool done = false;
    132 
    133      data::FileSystemDataManager::GetOrCreateFileSystemDataManager(
    134          GetTestOriginMetadata())
    135          ->Then(
    136              GetCurrentSerialEventTarget(), __func__,
    137              [&rdm, &done](Registered<data::FileSystemDataManager>
    138                                registeredDataManager) {
    139                ASSERT_TRUE(registeredDataManager->IsOpen());
    140 
    141                rdm = std::move(registeredDataManager);
    142 
    143                done = true;
    144              },
    145              [&done](nsresult rejectValue) { done = true; });
    146 
    147      SpinEventLoopUntil("Promise is fulfilled"_ns, [&done]() { return done; });
    148    }
    149 
    150    RefPtr<data::FileSystemDataManager> dm = rdm.unwrap();
    151 
    152    (void)dm;
    153 
    154    {
    155      bool done = false;
    156 
    157      data::FileSystemDataManager::GetOrCreateFileSystemDataManager(
    158          GetTestOriginMetadata())
    159          ->Then(
    160              GetCurrentSerialEventTarget(), __func__,
    161              [](Registered<data::FileSystemDataManager>
    162                     registeredDataManager) {
    163                RefPtr<data::FileSystemDataManager> dataManager =
    164                    registeredDataManager.get();
    165 
    166                registeredDataManager = nullptr;
    167 
    168                return dataManager->OnClose();
    169              },
    170              [](nsresult rejectValue) {
    171                return BoolPromise::CreateAndReject(rejectValue, __func__);
    172              })
    173          ->Then(GetCurrentSerialEventTarget(), __func__,
    174                 [&done](const BoolPromise::ResolveOrRejectValue&) {
    175                   done = true;
    176                 });
    177 
    178      SpinEventLoopUntil("Promise is fulfilled"_ns, [&done]() { return done; });
    179    }
    180  };
    181 
    182  PerformOnBackgroundThread(std::move(backgroundTask));
    183 }
    184 
    185 }  // namespace mozilla::dom::fs::test