tor-browser

browser_storage_updates.js (7337B)

---

/* Any copyright is dedicated to the Public Domain.
  http://creativecommons.org/publicdomain/zero/1.0/ */

// Ensure that storage updates are detected and that the correct information is
// contained inside the storage actors.

"use strict";

Services.scriptloader.loadSubScript(
 "chrome://mochitests/content/browser/devtools/server/tests/browser/storage-helpers.js",
 this
);

const l10n = new Localization(["devtools/client/storage.ftl"], true);
const sessionString = l10n.formatValueSync("storage-expires-session");

const TESTS = [
 // index 0
 {
   async action() {
     await addCookie("c1", "foobar1");
     await addCookie("c2", "foobar2");
     await localStorageSetItem("l1", "foobar1");
   },
   snapshot: {
     cookies: [
       {
         name: "c1",
         value: "foobar1",
       },
       {
         name: "c2",
         value: "foobar2",
       },
     ],
     "local-storage": [
       {
         name: "l1",
         value: "foobar1",
       },
     ],
   },
 },

 // index 1
 {
   async action() {
     await addCookie("c1", "new_foobar1");
     await localStorageSetItem("l2", "foobar2");
   },
   snapshot: {
     cookies: [
       {
         name: "c1",
         value: "new_foobar1",
       },
       {
         name: "c2",
         value: "foobar2",
       },
     ],
     "local-storage": [
       {
         name: "l1",
         value: "foobar1",
       },
       {
         name: "l2",
         value: "foobar2",
       },
     ],
   },
 },

 // index 2
 {
   async action() {
     await removeCookie("c2");
     await localStorageRemoveItem("l1");
     await localStorageSetItem("l3", "foobar3");
   },
   snapshot: {
     cookies: [
       {
         name: "c1",
         value: "new_foobar1",
       },
     ],
     "local-storage": [
       {
         name: "l2",
         value: "foobar2",
       },
       {
         name: "l3",
         value: "foobar3",
       },
     ],
   },
 },

 // index 3
 {
   async action() {
     await removeCookie("c1");
     await addCookie("c3", "foobar3");
     await localStorageRemoveItem("l2");
     await sessionStorageSetItem("s1", "foobar1");
     await sessionStorageSetItem("s2", "foobar2");
     await localStorageSetItem("l3", "new_foobar3");
   },
   snapshot: {
     cookies: [
       {
         name: "c3",
         value: "foobar3",
       },
     ],
     "local-storage": [
       {
         name: "l3",
         value: "new_foobar3",
       },
     ],
     "session-storage": [
       {
         name: "s1",
         value: "foobar1",
       },
       {
         name: "s2",
         value: "foobar2",
       },
     ],
   },
 },

 // index 4
 {
   async action() {
     await sessionStorageRemoveItem("s1");
   },
   snapshot: {
     cookies: [
       {
         name: "c3",
         value: "foobar3",
       },
     ],
     "local-storage": [
       {
         name: "l3",
         value: "new_foobar3",
       },
     ],
     "session-storage": [
       {
         name: "s2",
         value: "foobar2",
       },
     ],
   },
 },

 // index 5
 {
   async action() {
     await clearCookies();
   },
   snapshot: {
     cookies: [],
     "local-storage": [
       {
         name: "l3",
         value: "new_foobar3",
       },
     ],
     "session-storage": [
       {
         name: "s2",
         value: "foobar2",
       },
     ],
   },
 },

 // index 6
 {
   async action() {
     await clearLocalAndSessionStores();
   },
   snapshot: {
     cookies: [],
     "local-storage": [],
     "session-storage": [],
   },
 },
];

add_task(async function () {
 const { commands } = await openTabAndSetupStorage(
   MAIN_DOMAIN + "storage-updates.html"
 );

 for (let i = 0; i < TESTS.length; i++) {
   const test = TESTS[i];
   await runTest(test, commands, i);
 }

 await commands.destroy();
});

async function runTest({ action, snapshot }, commands, index) {
 info("Running test at index " + index);
 await action();
 await checkStores(commands, snapshot);
}

async function checkStores(commands, snapshot) {
 const { resourceCommand } = commands;
 const { TYPES } = resourceCommand;
 const actual = {};
 await resourceCommand.watchResources(
   [TYPES.COOKIE, TYPES.LOCAL_STORAGE, TYPES.SESSION_STORAGE],
   {
     async onAvailable(resources) {
       for (const resource of resources) {
         actual[resource.resourceType] = await resource.getStoreObjects(
           TEST_DOMAIN,
           null,
           {
             sessionString,
           }
         );
       }
     },
   }
 );

 for (const [type, entries] of Object.entries(snapshot)) {
   const store = actual[type].data;

   is(
     store.length,
     entries.length,
     `The number of entries in ${type} is correct`
   );

   for (const entry of entries) {
     checkStoreValue(entry.name, entry.value, store);
   }
 }
}

function checkStoreValue(name, value, store) {
 for (const entry of store) {
   if (entry.name === name) {
     ok(true, `There is an entry for "${name}"`);

     // entry.value is a longStringActor so we need to read it's value using
     // entry.value.str.
     is(entry.value.str, value, `Value for ${name} is correct`);
     return;
   }
 }
 ok(false, `There is an entry for "${name}"`);
}

async function addCookie(name, value) {
 info(`addCookie("${name}", "${value}")`);

 await SpecialPowers.spawn(
   gBrowser.selectedBrowser,
   [[name, value]],
   ([iName, iValue]) => {
     content.wrappedJSObject.window.addCookie(iName, iValue);
   }
 );
}

async function removeCookie(name) {
 info(`removeCookie("${name}")`);

 await SpecialPowers.spawn(gBrowser.selectedBrowser, [name], iName => {
   content.wrappedJSObject.window.removeCookie(iName);
 });
}

async function localStorageSetItem(name, value) {
 info(`localStorageSetItem("${name}", "${value}")`);

 await SpecialPowers.spawn(
   gBrowser.selectedBrowser,
   [[name, value]],
   ([iName, iValue]) => {
     content.window.localStorage.setItem(iName, iValue);
   }
 );
}

async function localStorageRemoveItem(name) {
 info(`localStorageRemoveItem("${name}")`);

 await SpecialPowers.spawn(gBrowser.selectedBrowser, [name], iName => {
   content.window.localStorage.removeItem(iName);
 });
}

async function sessionStorageSetItem(name, value) {
 info(`sessionStorageSetItem("${name}", "${value}")`);

 await SpecialPowers.spawn(
   gBrowser.selectedBrowser,
   [[name, value]],
   ([iName, iValue]) => {
     content.window.sessionStorage.setItem(iName, iValue);
   }
 );
}

async function sessionStorageRemoveItem(name) {
 info(`sessionStorageRemoveItem("${name}")`);

 await SpecialPowers.spawn(gBrowser.selectedBrowser, [name], iName => {
   content.window.sessionStorage.removeItem(iName);
 });
}

async function clearCookies() {
 info(`clearCookies()`);

 await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => {
   content.wrappedJSObject.window.clearCookies();
 });
}

async function clearLocalAndSessionStores() {
 info(`clearLocalAndSessionStores()`);

 await SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => {
   content.wrappedJSObject.window.clearLocalAndSessionStores();
 });
}