tor-browser

commit 1eebaa043bbf324327092641e2a4cdb68f6d0836
parent 20269361dbeadcb7d0e9ee833aa06b18740c6dec
Author: anushamuley <anushamuley@google.com>
Date:   Fri, 14 Nov 2025 10:22:44 +0000

Bug 1999776 [wpt PR 56004] - Add WPTs for CookieStore subscribe() with optional or empty arguments, a=testonly

Automatic update from web-platform-tests
Add WPTs for CookieStore subscribe() with optional or empty arguments

This change also cleans up some setup code and ensures we are waiting
for a service worker's activation event only if there isn't currently an
active registration.

Change-Id: Iebf9b3f750d5180869b9743772415bf405d5ca01
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/7142639
Reviewed-by: Aaron Selya <selya@google.com>
Commit-Queue: Anusha Muley <anushamuley@google.com>
Reviewed-by: Dylan Cutler <dylancutler@google.com>
Cr-Commit-Position: refs/heads/main@{#1543808}

--

wpt-commits: 875b9bea90a1c433ec6e14bb94445fec2119184b
wpt-pr: 56004

Diffstat:
M
testing/web-platform/tests/cookiestore/cookieStore_subscribe_arguments.https.any.js
 | 
121
+++++++++++++++++++++++++++++++++++++++++++++----------------------------------

1 file changed, 69 insertions(+), 52 deletions(-)
diff --git a/testing/web-platform/tests/cookiestore/cookieStore_subscribe_arguments.https.any.js b/testing/web-platform/tests/cookiestore/cookieStore_subscribe_arguments.https.any.js
@@ -16,26 +16,54 @@ promise_test(async testCase => {
     await wait_for_state(testCase, registration.installing, 'activated');
 
     self.registration = registration;
-  } else {
+  } else if (!self.registration.active) {
+    // If service worker is not active yet, it must wait for it to enter the
+    // 'activated' state before subscribing to cookiechange events.
+    await new Promise(resolve => self.addEventListener('activate', resolve));
+  }
+
+  let subscriptions =
+      [{name: 'cookie-name'}, {url: self.registration.scope + '/subdir'}];
+  await self.registration.cookies.subscribe(subscriptions);
+  testCase.add_cleanup(
+      () => self.registration.cookies.unsubscribe(subscriptions));
+
+  subscriptions = await self.registration.cookies.getSubscriptions();
+  assert_equals(subscriptions.length, 2);
+  assert_equals(subscriptions[0].name, 'cookie-name');
+  assert_equals(subscriptions[0].url, self.registration.scope);
+  assert_equals(subscriptions[1].name, undefined)
+  assert_equals(subscriptions[1].url, self.registration.scope + '/subdir')
+}, 'cookieStore.subscribe without name or url in options');
+
+promise_test(async testCase => {
+  if (self.GLOBAL.isWindow()) {
+    const registration = await service_worker_unregister_and_register(
+        testCase, 'resources/empty_sw.js',
+        '/cookiestore/resources/does/not/exist');
+
     // Must wait for the service worker to enter the 'activated' state before
     // subscribing to cookiechange events.
-    await new Promise(resolve => {
-      self.addEventListener('activate', event => { resolve(); });
-    });
-  }
+    await wait_for_state(testCase, registration.installing, 'activated');
+    testCase.add_cleanup(() => self.registration.unregister());
 
-  {
-    const subscriptions = [{ name: 'cookie-name' }];
-    await self.registration.cookies.subscribe(subscriptions);
-    testCase.add_cleanup(() => registration.cookies.unsubscribe(subscriptions));
+    self.registration = registration;
+  } else if (!self.registration.active) {
+    // If service worker is not active yet, it must wait for it to enter the
+    // 'activated' state before subscribing to cookiechange events.
+    await new Promise(resolve => self.addEventListener('activate', resolve));
   }
 
-  const subscriptions = await registration.cookies.getSubscriptions();
-  assert_equals(subscriptions.length, 1);
+  let subscriptions = [{}];
+  await self.registration.cookies.subscribe(subscriptions);
+  testCase.add_cleanup(
+      () => self.registration.cookies.unsubscribe(subscriptions));
 
-  assert_equals(subscriptions[0].name, 'cookie-name');
-  assert_equals(subscriptions[0].url, registration.scope);
-}, 'cookieStore.subscribe without url in option');
+  subscriptions = await self.registration.cookies.getSubscriptions();
+  assert_equals(subscriptions.length, 1);
+  assert_equals(subscriptions[0].name, undefined);
+  assert_equals(subscriptions[0].url, self.registration.scope);
+}, 'cookieStore.subscribe with empty option');
 
 promise_test(async testCase => {
   if (self.GLOBAL.isWindow()) {
@@ -52,14 +80,13 @@ promise_test(async testCase => {
   } else if (!self.registration.active) {
     // If service worker is not active yet, it must wait for it to enter the
     // 'activated' state before subscribing to cookiechange events.
-    await new Promise(resolve => {
-      self.addEventListener('activate', event => { resolve(); });
-    });
+    await new Promise(resolve => self.addEventListener('activate', resolve));
   }
 
-  await promise_rejects_js(testCase, TypeError,
+  await promise_rejects_js(
+      testCase, TypeError,
       registration.cookies.subscribe(
-          { name: 'cookie-name', url: '/wrong/path' }));
+          {name: 'cookie-name', url: '/wrong/path'}));
 }, 'cookieStore.subscribe with invalid url path in option');
 
 promise_test(async testCase => {
@@ -77,24 +104,19 @@ promise_test(async testCase => {
   } else if (!self.registration.active) {
     // Must wait for the service worker to enter the 'activated' state before
     // subscribing to cookiechange events.
-    await new Promise(resolve => {
-      self.addEventListener('activate', event => { resolve(); });
-    });
+    await new Promise(resolve => self.addEventListener('activate', resolve));
   }
 
-  {
-    const subscriptions = [{ name: 'cookie-name' }];
-    // Call subscribe for same subscription multiple times to verify that it is
-    // idempotent.
-    await self.registration.cookies.subscribe(subscriptions);
-    await self.registration.cookies.subscribe(subscriptions);
-    await self.registration.cookies.subscribe(subscriptions);
-    testCase.add_cleanup(() => registration.cookies.unsubscribe(subscriptions));
-  }
+  let subscriptions = [{name: 'cookie-name'}];
+  // Call subscribe for same subscription multiple times to verify that it is
+  // idempotent.
+  await self.registration.cookies.subscribe(subscriptions);
+  await self.registration.cookies.subscribe(subscriptions);
+  await self.registration.cookies.subscribe(subscriptions);
+  testCase.add_cleanup(() => registration.cookies.unsubscribe(subscriptions));
 
-  const subscriptions = await registration.cookies.getSubscriptions();
+  subscriptions = await registration.cookies.getSubscriptions();
   assert_equals(subscriptions.length, 1);
-
   assert_equals(subscriptions[0].name, 'cookie-name');
   assert_equals(subscriptions[0].url, registration.scope);
 }, 'cookieStore.subscribe is idempotent');
@@ -114,29 +136,24 @@ promise_test(async testCase => {
   } else if (!self.registration.active) {
     // Must wait for the service worker to enter the 'activated' state before
     // subscribing to cookiechange events.
-    await new Promise(resolve => {
-      self.addEventListener('activate', event => { resolve(); });
-    });
+    await new Promise(resolve => self.addEventListener('activate', resolve));
   }
 
-  {
-    const subscriptions = [
-      { name: 'cookie-name1' },
-      { name: 'cookie-name2' },
-    ];
-    await self.registration.cookies.subscribe(subscriptions);
-    testCase.add_cleanup(() => registration.cookies.unsubscribe(subscriptions));
-
-    // Call unsubscribe for same subscription multiple times to verify that it
-    // is idempotent.
-    await registration.cookies.unsubscribe([subscriptions[0]]);
-    await registration.cookies.unsubscribe([subscriptions[0]]);
-    await registration.cookies.unsubscribe([subscriptions[0]]);
-  }
+  let subscriptions = [
+    {name: 'cookie-name1'},
+    {name: 'cookie-name2'},
+  ];
+  await self.registration.cookies.subscribe(subscriptions);
+  testCase.add_cleanup(() => registration.cookies.unsubscribe(subscriptions));
 
-  const subscriptions = await registration.cookies.getSubscriptions();
-  assert_equals(subscriptions.length, 1);
+  // Call unsubscribe for same subscription multiple times to verify that it
+  // is idempotent.
+  await registration.cookies.unsubscribe([subscriptions[0]]);
+  await registration.cookies.unsubscribe([subscriptions[0]]);
+  await registration.cookies.unsubscribe([subscriptions[0]]);
 
+  subscriptions = await registration.cookies.getSubscriptions();
+  assert_equals(subscriptions.length, 1);
   assert_equals(subscriptions[0].name, 'cookie-name2');
   assert_equals(subscriptions[0].url, registration.scope);
 }, 'CookieStore.unsubscribe is idempotent');