tor-browser

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

TestFileSystemDirectoryHandle.cpp (8232B)

      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 "FileSystemMocks.h"
      8 #include "gtest/gtest.h"
      9 #include "mozilla/UniquePtr.h"
     10 #include "mozilla/dom/FileSystemDirectoryHandle.h"
     11 #include "mozilla/dom/FileSystemDirectoryHandleBinding.h"
     12 #include "mozilla/dom/FileSystemHandle.h"
     13 #include "mozilla/dom/FileSystemHandleBinding.h"
     14 #include "mozilla/dom/FileSystemManager.h"
     15 #include "mozilla/dom/StorageManager.h"
     16 #include "nsIGlobalObject.h"
     17 
     18 using ::testing::_;
     19 
     20 namespace mozilla::dom::fs::test {
     21 
     22 class TestFileSystemDirectoryHandle : public ::testing::Test {
     23 protected:
     24  void SetUp() override {
     25    // TODO: Fix the test to not depend on CreateFileSystemManagerParent
     26    // failure because of the pref set to false.
     27    nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
     28    prefs->SetBoolPref("dom.fs.enabled", false);
     29 
     30    mRequestHandler = MakeUnique<MockFileSystemRequestHandler>();
     31    mMetadata = FileSystemEntryMetadata("dir"_ns, u"Directory"_ns,
     32                                        /* directory */ true);
     33    mName = u"testDir"_ns;
     34    mManager = MakeAndAddRef<FileSystemManager>(mGlobal, nullptr);
     35  }
     36 
     37  void TearDown() override {
     38    nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
     39    prefs->SetBoolPref("dom.fs.enabled", true);
     40 
     41    if (!mManager->IsShutdown()) {
     42      mManager->Shutdown();
     43    }
     44  }
     45 
     46  nsIGlobalObject* mGlobal = GetGlobal();
     47  const IterableIteratorBase::IteratorType mIteratorType =
     48      IterableIteratorBase::IteratorType::Keys;
     49  UniquePtr<MockFileSystemRequestHandler> mRequestHandler;
     50  FileSystemEntryMetadata mMetadata;
     51  nsString mName;
     52  RefPtr<FileSystemManager> mManager;
     53 };
     54 
     55 TEST_F(TestFileSystemDirectoryHandle, constructDirectoryHandleRefPointer) {
     56  RefPtr<FileSystemDirectoryHandle> dirHandle =
     57      MakeAndAddRef<FileSystemDirectoryHandle>(mGlobal, mManager, mMetadata);
     58 
     59  ASSERT_TRUE(dirHandle);
     60 }
     61 
     62 TEST_F(TestFileSystemDirectoryHandle, initIterator) {
     63  RefPtr<FileSystemDirectoryHandle> dirHandle =
     64      MakeAndAddRef<FileSystemDirectoryHandle>(mGlobal, mManager, mMetadata,
     65                                               mRequestHandler.release());
     66 
     67  ASSERT_TRUE(dirHandle);
     68 
     69  RefPtr<FileSystemDirectoryHandle::iterator_t> iterator =
     70      new FileSystemDirectoryHandle::iterator_t(dirHandle.get(), mIteratorType);
     71  IgnoredErrorResult rv;
     72  dirHandle->InitAsyncIteratorData(iterator->Data(), mIteratorType, rv);
     73  ASSERT_TRUE(iterator->Data().mImpl);
     74 }
     75 
     76 class MockFileSystemDirectoryIteratorImpl final
     77    : public FileSystemDirectoryIterator::Impl {
     78 public:
     79  MOCK_METHOD(already_AddRefed<Promise>, Next,
     80              (nsIGlobalObject * aGlobal, RefPtr<FileSystemManager>& aManager,
     81               ErrorResult& aError),
     82              (override));
     83 };
     84 
     85 TEST_F(TestFileSystemDirectoryHandle, isNextPromiseReturned) {
     86  RefPtr<FileSystemDirectoryHandle> dirHandle =
     87      MakeAndAddRef<FileSystemDirectoryHandle>(mGlobal, mManager, mMetadata,
     88                                               mRequestHandler.release());
     89 
     90  ASSERT_TRUE(dirHandle);
     91 
     92  auto mockIter = MakeRefPtr<MockFileSystemDirectoryIteratorImpl>();
     93  IgnoredErrorResult error;
     94  EXPECT_CALL(*mockIter, Next(_, _, _))
     95      .WillOnce(::testing::Return(Promise::Create(mGlobal, error)));
     96 
     97  RefPtr<FileSystemDirectoryHandle::iterator_t> iterator =
     98      MakeAndAddRef<FileSystemDirectoryHandle::iterator_t>(dirHandle.get(),
     99                                                           mIteratorType);
    100  iterator->Data().mImpl = std::move(mockIter);
    101 
    102  IgnoredErrorResult rv;
    103  RefPtr<Promise> promise =
    104      dirHandle->GetNextIterationResult(iterator.get(), rv);
    105  ASSERT_TRUE(promise);
    106 }
    107 
    108 TEST_F(TestFileSystemDirectoryHandle, isHandleKindDirectory) {
    109  RefPtr<FileSystemDirectoryHandle> dirHandle =
    110      MakeAndAddRef<FileSystemDirectoryHandle>(mGlobal, mManager, mMetadata,
    111                                               mRequestHandler.release());
    112 
    113  ASSERT_TRUE(dirHandle);
    114 
    115  ASSERT_EQ(FileSystemHandleKind::Directory, dirHandle->Kind());
    116 }
    117 
    118 TEST_F(TestFileSystemDirectoryHandle, isFileHandleReturned) {
    119  EXPECT_CALL(*mRequestHandler, GetFileHandle(_, _, _, _, _))
    120      .WillOnce(::testing::ReturnArg<3>());
    121  RefPtr<FileSystemDirectoryHandle> dirHandle =
    122      MakeAndAddRef<FileSystemDirectoryHandle>(mGlobal, mManager, mMetadata,
    123                                               mRequestHandler.release());
    124 
    125  ASSERT_TRUE(dirHandle);
    126 
    127  FileSystemGetFileOptions options;
    128  IgnoredErrorResult rv;
    129  RefPtr<Promise> promise = dirHandle->GetFileHandle(mName, options, rv);
    130 
    131  ASSERT_TRUE(rv.ErrorCodeIs(NS_OK));
    132 }
    133 
    134 TEST_F(TestFileSystemDirectoryHandle, doesGetFileHandleFailOnNullGlobal) {
    135  mGlobal = nullptr;
    136  RefPtr<FileSystemDirectoryHandle> dirHandle =
    137      MakeAndAddRef<FileSystemDirectoryHandle>(mGlobal, mManager, mMetadata);
    138 
    139  ASSERT_TRUE(dirHandle);
    140 
    141  FileSystemGetFileOptions options;
    142  IgnoredErrorResult rv;
    143  RefPtr<Promise> promise = dirHandle->GetFileHandle(mName, options, rv);
    144 
    145  ASSERT_TRUE(rv.ErrorCodeIs(NS_ERROR_UNEXPECTED));
    146 }
    147 
    148 TEST_F(TestFileSystemDirectoryHandle, isDirectoryHandleReturned) {
    149  EXPECT_CALL(*mRequestHandler, GetDirectoryHandle(_, _, _, _, _))
    150      .WillOnce(::testing::ReturnArg<3>());
    151  RefPtr<FileSystemDirectoryHandle> dirHandle =
    152      MakeAndAddRef<FileSystemDirectoryHandle>(mGlobal, mManager, mMetadata,
    153                                               mRequestHandler.release());
    154 
    155  ASSERT_TRUE(dirHandle);
    156 
    157  FileSystemGetDirectoryOptions options;
    158  IgnoredErrorResult rv;
    159  RefPtr<Promise> promise = dirHandle->GetDirectoryHandle(mName, options, rv);
    160 
    161  ASSERT_TRUE(rv.ErrorCodeIs(NS_OK));
    162 }
    163 
    164 TEST_F(TestFileSystemDirectoryHandle, doesGetDirectoryHandleFailOnNullGlobal) {
    165  mGlobal = nullptr;
    166  RefPtr<FileSystemDirectoryHandle> dirHandle =
    167      MakeAndAddRef<FileSystemDirectoryHandle>(mGlobal, mManager, mMetadata);
    168 
    169  ASSERT_TRUE(dirHandle);
    170 
    171  FileSystemGetDirectoryOptions options;
    172  IgnoredErrorResult rv;
    173  RefPtr<Promise> promise = dirHandle->GetDirectoryHandle(mName, options, rv);
    174 
    175  ASSERT_TRUE(rv.ErrorCodeIs(NS_ERROR_UNEXPECTED));
    176 }
    177 
    178 TEST_F(TestFileSystemDirectoryHandle, isRemoveEntrySuccessful) {
    179  EXPECT_CALL(*mRequestHandler, RemoveEntry(_, _, _, _, _))
    180      .WillOnce(::testing::ReturnArg<3>());
    181  RefPtr<FileSystemDirectoryHandle> dirHandle =
    182      MakeAndAddRef<FileSystemDirectoryHandle>(mGlobal, mManager, mMetadata,
    183                                               mRequestHandler.release());
    184 
    185  ASSERT_TRUE(dirHandle);
    186 
    187  FileSystemRemoveOptions options;
    188  IgnoredErrorResult rv;
    189  RefPtr<Promise> promise = dirHandle->RemoveEntry(mName, options, rv);
    190 
    191  ASSERT_TRUE(rv.ErrorCodeIs(NS_OK));
    192 }
    193 
    194 TEST_F(TestFileSystemDirectoryHandle, doesRemoveEntryFailOnNullGlobal) {
    195  mGlobal = nullptr;
    196  RefPtr<FileSystemDirectoryHandle> dirHandle =
    197      MakeAndAddRef<FileSystemDirectoryHandle>(mGlobal, mManager, mMetadata);
    198 
    199  ASSERT_TRUE(dirHandle);
    200 
    201  FileSystemRemoveOptions options;
    202  IgnoredErrorResult rv;
    203  RefPtr<Promise> promise = dirHandle->RemoveEntry(mName, options, rv);
    204 
    205  ASSERT_TRUE(rv.ErrorCodeIs(NS_ERROR_UNEXPECTED));
    206 }
    207 
    208 TEST_F(TestFileSystemDirectoryHandle, isResolveSuccessful) {
    209  RefPtr<FileSystemDirectoryHandle> dirHandle =
    210      MakeAndAddRef<FileSystemDirectoryHandle>(mGlobal, mManager, mMetadata,
    211                                               mRequestHandler.release());
    212 
    213  ASSERT_TRUE(dirHandle);
    214 
    215  IgnoredErrorResult rv;
    216  RefPtr<Promise> promise = dirHandle->Resolve(*dirHandle, rv);
    217 
    218  ASSERT_TRUE(rv.ErrorCodeIs(NS_OK));
    219 }
    220 
    221 TEST_F(TestFileSystemDirectoryHandle, doesResolveFailOnNullGlobal) {
    222  mGlobal = nullptr;
    223  RefPtr<FileSystemDirectoryHandle> dirHandle =
    224      MakeAndAddRef<FileSystemDirectoryHandle>(mGlobal, mManager, mMetadata);
    225 
    226  ASSERT_TRUE(dirHandle);
    227 
    228  IgnoredErrorResult rv;
    229  RefPtr<Promise> promise = dirHandle->Resolve(*dirHandle, rv);
    230 
    231  ASSERT_TRUE(rv.ErrorCodeIs(NS_ERROR_UNEXPECTED));
    232 }
    233 
    234 }  // namespace mozilla::dom::fs::test