Update web-platform-tests to revision 332b7c4e711d75ead4c0dfbf7f6f0b683206756d

tests/wpt/web-platform-tests/native-file-system/resources/native-fs-test-helpers.js

@@ -0,0 +1,49 @@
+// This file defines a directory_test() function that can be used to define
+// tests that require a FileSystemDirectoryHandle. The implementation of that
+// function in this file will ask the user to select an empty directory and
+// uses that directory.
+//
+// Another implementation of this function exists in
+// sandboxed-fs-test-helpers.js, where that version uses the sandboxed file
+// system instead.
+
+const directory_promise = (async () => {
+  await new Promise(resolve => {
+    window.addEventListener('DOMContentLoaded', resolve);
+  });
+
+  await window.test_driver.bless(
+      'show a file picker.<br />Please select an empty directory');
+  const entries = await self.chooseFileSystemEntries({type: 'openDirectory'});
+  assert_true(entries instanceof FileSystemHandle);
+  assert_true(entries instanceof FileSystemDirectoryHandle);
+  for await (const entry of entries.getEntries()) {
+    assert_unreached('Selected directory is not empty');
+  }
+  return entries;
+})();
+
+function directory_test(func, description) {
+  promise_test(async t => {
+    const directory = await directory_promise;
+    // To be resilient against tests not cleaning up properly, cleanup before
+    // every test.
+    for await (let entry of directory.getEntries()) {
+      await directory.removeEntry(entry.name, {recursive: entry.isDirectory});
+    }
+    await func(t, directory);
+  }, description);
+}
+
+directory_test(async (t, dir) => {
+  assert_equals(await dir.queryPermission({writable: false}), 'granted');
+}, 'User succesfully selected an empty directory.');
+
+directory_test(async (t, dir) => {
+  const status = await dir.queryPermission({writable: true});
+  if (status == 'granted')
+    return;
+
+  await window.test_driver.bless('ask for write permission');
+  assert_equals(await dir.requestPermission({writable: true}), 'granted');
+}, 'User granted write access.');

tests/wpt/web-platform-tests/native-file-system/resources/sandboxed-fs-test-helpers.js

@@ -0,0 +1,25 @@
+// This file defines a directory_test() function that can be used to define
+// tests that require a FileSystemDirectoryHandle. The implementation of that
+// function in this file will return an empty directory in the sandboxed file
+// system.
+//
+// Another implementation of this function exists in native-fs-test-helpers.js,
+// where that version uses the native file system instead.
+
+async function cleanupSandboxedFileSystem() {
+  const dir =
+      await FileSystemDirectoryHandle.getSystemDirectory({type: 'sandbox'});
+  for await (let entry of dir.getEntries())
+    await dir.removeEntry(entry.name, {recursive: entry.isDirectory});
+}
+
+function directory_test(func, description) {
+  promise_test(async t => {
+    // To be extra resilient against bad tests, cleanup before every test.
+    await cleanupSandboxedFileSystem();
+
+    const dir =
+        await FileSystemDirectoryHandle.getSystemDirectory({type: 'sandbox'});
+    await func(t, dir);
+  }, description);
+}

tests/wpt/web-platform-tests/native-file-system/resources/test-helpers.js

@@ -1,95 +1,87 @@
 // A special path component meaning "this directory."
-const kCurrentDirectory = ".";
+const kCurrentDirectory = '.';
 
 // A special path component meaning "the parent directory."
-const kParentDirectory = "..";
+const kParentDirectory = '..';
 
 // Array of separators used to separate components in hierarchical paths.
 let kPathSeparators;
-if (navigator.userAgent.includes("Windows NT")) {
-    // Windows uses both '/' and '\' as path separators.
-    kPathSeparators = ['/', '\\' ];
+if (navigator.userAgent.includes('Windows NT')) {
+  // Windows uses both '/' and '\' as path separators.
+  kPathSeparators = ['/', '\\'];
 } else {
-    kPathSeparators = [ '/' ];
-}
-
-async function cleanupSandboxedFileSystem() {
-    const dir = await FileSystemDirectoryHandle.getSystemDirectory({ type: 'sandbox' });
-    for await (let entry of dir.getEntries())
-        dir.removeEntry(entry.name, { recursive: entry.isDirectory });
+  kPathSeparators = ['/'];
 }
 
 async function getFileSize(handle) {
-    const file = await handle.getFile();
-    return file.size;
+  const file = await handle.getFile();
+  return file.size;
 }
 
 async function getFileContents(handle) {
-    const file = await handle.getFile();
-    return new Response(file).text();
+  const file = await handle.getFile();
+  return new Response(file).text();
 }
 
 async function getDirectoryEntryCount(handle) {
-    let result = 0;
-    for await (let entry of handle.getEntries()) {
-        result++;
-    }
-    return result;
+  let result = 0;
+  for await (let entry of handle.getEntries()) {
+    result++;
+  }
+  return result;
 }
 
 async function getSortedDirectoryEntries(handle) {
-    let result = [];
-    for await (let entry of handle.getEntries()) {
-        if (entry.isDirectory)
-            result.push(entry.name + '/');
-        else
-            result.push(entry.name);
-    }
-    result.sort();
-    return result;
+  let result = [];
+  for await (let entry of handle.getEntries()) {
+    if (entry.isDirectory)
+      result.push(entry.name + '/');
+    else
+      result.push(entry.name);
+  }
+  result.sort();
+  return result;
 }
 
 async function createDirectory(test, name, parent) {
-  const parent_dir_handle = parent ? parent :
-      await FileSystemDirectoryHandle.getSystemDirectory({ type: 'sandbox' });
-
-  const new_dir_handle = await parent_dir_handle.getDirectory(name, { create: true });
+  const new_dir_handle = await parent.getDirectory(name, {create: true});
   test.add_cleanup(async () => {
-        try {
-            await parent_dir_handle.removeEntry(name, { recursive: true });
-        } catch (e) {
-            // Ignore any errors when removing directories, as tests might
-            // have already removed the directory.
-        }
+    try {
+      await parent.removeEntry(name, {recursive: true});
+    } catch (e) {
+      // Ignore any errors when removing directories, as tests might
+      // have already removed the directory.
+    }
   });
   return new_dir_handle;
 }
 
 async function createEmptyFile(test, name, parent) {
-    const dir = parent ? parent : await FileSystemDirectoryHandle.getSystemDirectory({ type: 'sandbox' });
-    const handle = await dir.getFile(name, { create: true });
-    test.add_cleanup(async () => {
-        try {
-            await dir.removeEntry(name);
-        } catch (e) {
-            // Ignore any errors when removing files, as tests might already remove the file.
-        }
-    });
-    // Make sure the file is empty.
-    assert_equals(await getFileSize(handle), 0);
-    return handle;
+  const handle = await parent.getFile(name, {create: true});
+  test.add_cleanup(async () => {
+    try {
+      await parent.removeEntry(name);
+    } catch (e) {
+      // Ignore any errors when removing files, as tests might already remove
+      // the file.
+    }
+  });
+  // Make sure the file is empty.
+  assert_equals(await getFileSize(handle), 0);
+  return handle;
 }
 
 async function createFileWithContents(test, name, contents, parent) {
-    const handle = await createEmptyFile(test, name, parent);
-    const writer = await handle.createWriter();
-    await writer.write(0, new Blob([contents]));
-    await writer.close();
-    return handle;
+  const handle = await createEmptyFile(test, name, parent);
+  const writer = await handle.createWriter();
+  await writer.write(0, new Blob([contents]));
+  await writer.close();
+  return handle;
 }
 
 function garbageCollect() {
-    // TODO(https://github.com/web-platform-tests/wpt/issues/7899): Change to
-    // some sort of cross-browser GC trigger.
-    if (self.gc) self.gc();
+  // TODO(https://github.com/web-platform-tests/wpt/issues/7899): Change to
+  // some sort of cross-browser GC trigger.
+  if (self.gc)
+    self.gc();
 };