tor-browser

FileSystemObserver.js (13122B)

---

'use strict';

// This script depends on the following scripts:
//    resources/test-helpers.js
//    resources/collecting-file-system-observer.js
//    resources/change-observer-scope-test.js
//    script-tests/FileSystemObserver-writable-file-stream.js

promise_test(async t => {
 try {
   const observer = new FileSystemObserver(() => {});
 } catch {
   assert_unreached();
 }
}, 'Creating a FileSystemObserver from a supported global succeeds');

directory_test(async (t, root_dir) => {
 const observer = new FileSystemObserver(() => {});
 try {
   observer.unobserve(root_dir);
 } catch {
   assert_unreached();
 }
}, 'Calling unobserve() without a corresponding observe() shouldn\'t throw');

directory_test(async (t, root_dir) => {
 const observer = new FileSystemObserver(() => {});
 try {
   observer.unobserve(root_dir);
   observer.unobserve(root_dir);
 } catch {
   assert_unreached();
 }
}, 'unobserve() is idempotent');

promise_test(async t => {
 const observer = new FileSystemObserver(() => {});
 try {
   observer.disconnect();
 } catch {
   assert_unreached();
 }
}, 'Calling disconnect() without observing shouldn\'t throw');

promise_test(async t => {
 const observer = new FileSystemObserver(() => {});
 try {
   observer.disconnect();
   observer.disconnect();
 } catch {
   assert_unreached();
 }
}, 'disconnect() is idempotent');

directory_test(async (t, root_dir) => {
 const observer = new FileSystemObserver(() => {});

 // Create a `FileSystemFileHandle` and delete its underlying file entry.
 const file = await root_dir.getFileHandle(getUniqueName(), {create: true});
 await file.remove();

 await promise_rejects_dom(t, 'NotFoundError', observer.observe(file));
}, 'observe() fails when file does not exist');

directory_test(async (t, root_dir) => {
 const observer = new FileSystemObserver(() => {});

 // Create a `FileSystemDirectoryHandle` and delete its underlying file entry.
 const dir =
     await root_dir.getDirectoryHandle(getUniqueName(), {create: true});
 await dir.remove();

 await promise_rejects_dom(t, 'NotFoundError', observer.observe(dir));
}, 'observe() fails when directory does not exist');

directory_test(async (t, root_dir) => {
 const dir =
     await root_dir.getDirectoryHandle(getUniqueName(), {create: true});

 const scope_test = new ScopeTest(t, dir);
 const watched_handle = await scope_test.watched_handle();

 for (const recursive of [false, true]) {
   for await (const path of scope_test.in_scope_paths(recursive)) {
     const observer = new CollectingFileSystemObserver(t, root_dir);
     await observer.observe([watched_handle], {recursive});

     // Create `file`.
     const file = await path.createHandle();

     // Expect one "appeared" event to happen on `file`.
     const records = await observer.getRecords();
     await assert_records_equal(
         watched_handle, records,
         [appearedEvent(file, path.relativePathComponents())]);

     observer.disconnect();
   }
 }
}, 'Creating a file through FileSystemDirectoryHandle.getFileHandle is reported as an "appeared" event if in scope');

directory_test(async (t, root_dir) => {
 const dir =
     await root_dir.getDirectoryHandle(getUniqueName(), {create: true});

 const scope_test = new ScopeTest(t, dir);
 const watched_handle = await scope_test.watched_handle();

 for (const recursive of [false, true]) {
   for await (const path of scope_test.in_scope_paths(recursive)) {
     const file = await path.createHandle();

     const observer = new CollectingFileSystemObserver(t, root_dir);
     await observer.observe([watched_handle], {recursive});

     // Remove `file`.
     await file.remove();

     // Expect one "disappeared" event to happen on `file`.
     const records = await observer.getRecords();
     await assert_records_equal(
         watched_handle, records,
         [disappearedEvent(path.relativePathComponents())]);

     observer.disconnect();
   }
 }
}, 'Removing a file through FileSystemFileHandle.remove is reported as an "disappeared" event if in scope');

directory_test(async (t, root_dir) => {
 const dir =
     await root_dir.getDirectoryHandle(getUniqueName(), {create: true});

 const scope_test = new ScopeTest(t, dir);
 const watched_handle = await scope_test.watched_handle();

 for (const recursive of [false, true]) {
   for await (const path of scope_test.out_of_scope_paths(recursive)) {
     const observer = new CollectingFileSystemObserver(t, root_dir);
     await observer.observe([watched_handle], {recursive});

     // Create and remove `file`.
     const file = await path.createHandle();
     await file.remove();

     // Expect the observer to receive no events.
     const records = await observer.getRecords();
     await assert_records_equal(watched_handle, records, []);

     observer.disconnect();
   }
 }
}, 'Events outside the watch scope are not sent to the observer\'s callback');

directory_test(async (t, root_dir) => {
 const dir =
     await root_dir.getDirectoryHandle(getUniqueName(), {create: true});

 const scope_test = new ScopeTest(t, dir);
 const watched_handle = await scope_test.watched_handle();

 for (const recursive of [false, true]) {
   for await (const src of scope_test.in_scope_paths(recursive)) {
     for await (const dest of scope_test.in_scope_paths(recursive)) {
       const file = await src.createHandle();

       const observer = new CollectingFileSystemObserver(t, root_dir);
       await observer.observe([watched_handle], {recursive});

       // Move `file`.
       await file.move(dest.parentHandle(), dest.fileName());

       // Expect one "moved" event to happen on `file`.
       const records = await observer.getRecords();
       await assert_records_equal(
           watched_handle, records, [movedEvent(
                                        file, dest.relativePathComponents(),
                                        src.relativePathComponents())]);

       observer.disconnect();
     }
   }
 }
}, 'Moving a file through FileSystemFileHandle.move is reported as a "moved" event if destination and source are in scope');

directory_test(async (t, root_dir) => {
 const dir =
     await root_dir.getDirectoryHandle(getUniqueName(), {create: true});

 const scope_test = new ScopeTest(t, dir);
 const watched_handle = await scope_test.watched_handle();

 for (const recursive of [false, true]) {
   for await (const src of scope_test.out_of_scope_paths(recursive)) {
     for await (const dest of scope_test.out_of_scope_paths(recursive)) {
       const file = await src.createHandle();

       const observer = new CollectingFileSystemObserver(t, root_dir);
       await observer.observe([watched_handle], {recursive});

       // Move `file`.
       await file.move(dest.parentHandle(), dest.fileName());

       // Expect the observer to not receive any events.
       const records = await observer.getRecords();
       await assert_records_equal(watched_handle, records, []);
     }
   }
 }
}, 'Moving a file through FileSystemFileHandle.move is not reported if destination and source are not in scope');

directory_test(async (t, root_dir) => {
 const dir =
     await root_dir.getDirectoryHandle(getUniqueName(), {create: true});

 const scope_test = new ScopeTest(t, dir);
 const watched_handle = await scope_test.watched_handle();

 for (const recursive of [false, true]) {
   for await (const src of scope_test.out_of_scope_paths(recursive)) {
     for await (const dest of scope_test.in_scope_paths(recursive)) {
       const file = await src.createHandle();

       const observer = new CollectingFileSystemObserver(t, root_dir);
       await observer.observe([watched_handle], {recursive});

       // Move `file`.
       await file.move(dest.parentHandle(), dest.fileName());

       // Expect one "appeared" event to happen on `file`.
       const records = await observer.getRecords();
       await assert_records_equal(
           watched_handle, records,
           [appearedEvent(file, dest.relativePathComponents())]);
     }
   }
 }
}, 'Moving a file through FileSystemFileHandle.move is reported as a "appeared" event if only destination is in scope');

directory_test(async (t, root_dir) => {
 const dir =
     await root_dir.getDirectoryHandle(getUniqueName(), {create: true});

 const scope_test = new ScopeTest(t, dir);
 const watched_handle = await scope_test.watched_handle();

 for (const recursive of [false, true]) {
   for await (const src of scope_test.in_scope_paths(recursive)) {
     for await (const dest of scope_test.out_of_scope_paths(recursive)) {
       // These both point to the same underlying file entry initially until
       // move is called on `fileToMove`. `file` is kept so that we have a
       // handle that still points at the source file entry.
       const file = await src.createHandle();
       const fileToMove = await src.createHandle();

       const observer = new CollectingFileSystemObserver(t, root_dir);
       await observer.observe([watched_handle], {recursive});

       // Move `fileToMove`.
       await fileToMove.move(dest.parentHandle(), dest.fileName());

       // Expect one "disappeared" event to happen on `file`.
       const records = await observer.getRecords();
       await assert_records_equal(
           watched_handle, records,
           [disappearedEvent(src.relativePathComponents())]);
     }
   }
 }
}, 'Moving a file through FileSystemFileHandle.move is reported as a "disappeared" event if only source is in scope');

// Wraps a `CollectingFileSystemObserver` and disconnects the observer after it's
// received `num_of_records_to_observe`.
class DisconnectingFileSystemObserver {
 #collectingObserver;

 #num_of_records_to_observe;

 #called_disconnect = false;
 #records_observed_count = 0;

 constructor(test, root_dir, num_of_records_to_observe) {
   this.#collectingObserver = new CollectingFileSystemObserver(
       test, root_dir, this.#callback.bind(this));
   this.#num_of_records_to_observe = num_of_records_to_observe;
 }

 #callback(records, observer) {
   this.#records_observed_count += records.length;

   const called_disconnect = this.#called_disconnect;

   // Call `disconnect` once after we've received `num_of_records_to_observe`.
   if (!called_disconnect &&
       this.#records_observed_count >= this.#num_of_records_to_observe) {
     observer.disconnect();
     this.#called_disconnect = true;
   }

   return {called_disconnect};
 }

 getRecordsWithCallbackInfo() {
   return this.#collectingObserver.getRecordsWithCallbackInfo();
 }

 observe(handles) {
   return this.#collectingObserver.observe(handles);
 }
}


directory_test(async (t, root_dir) => {
 const total_files_to_create = 100;

 const child_dir =
     await root_dir.getDirectoryHandle(getUniqueName(), {create: true});

 // Create a `FileSystemObserver` that will disconnect after its
 // received half of the total files we're going to create.
 const observer = new DisconnectingFileSystemObserver(
     t, root_dir, total_files_to_create / 2);

 // Observe the child directory and create files in it.
 await observer.observe([child_dir]);
 for (let i = 0; i < total_files_to_create; i++) {
   child_dir.getFileHandle(`file${i}`, {create: true});
 }

 // Wait for `disconnect` to be called.
 const records_with_disconnect_state =
     await observer.getRecordsWithCallbackInfo();

 // No observations should have been received after disconnected has been
 // called.
 assert_false(
     records_with_disconnect_state.some(
         ({called_disconnect}) => called_disconnect),
     'Received records after disconnect.');
}, 'Observations stop after disconnect()');

directory_test(async (t, root_dir) => {
 const num_of_child_dirs = 5;
 const num_files_to_create_per_directory = 100;
 const total_files_to_create =
     num_files_to_create_per_directory * num_of_child_dirs;

 const child_dirs = await createDirectoryHandles(
     root_dir, getUniqueName(), getUniqueName(), getUniqueName());

 // Create a `FileSystemObserver` that will disconnect after its received half
 // of the total files we're going to create.
 const observer = new DisconnectingFileSystemObserver(
     t, root_dir, total_files_to_create / 2);

 // Observe the child directories and create files in them.
 await observer.observe(child_dirs);
 for (let i = 0; i < num_files_to_create_per_directory; i++) {
   child_dirs.forEach(
       child_dir => child_dir.getFileHandle(`file${i}`, {create: true}));
 }

 // Wait for `disconnect` to be called.
 const records_with_disconnect_state =
     await observer.getRecordsWithCallbackInfo();

 // No observations should have been received after disconnected has been
 // called.
 assert_false(
     records_with_disconnect_state.some(
         ({called_disconnect}) => called_disconnect),
     'Received records after disconnect.');
}, 'Observations stop for all observed handles after disconnect()');