tor-browser

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

test_tab_notes.js (4668B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this
      3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 add_setup(async () => {
      6  await TabNotes.init({ basePath: PathUtils.tempDir });
      7 });
      8 
      9 registerCleanupFunction(async () => {
     10  await TabNotes.reset();
     11  await TabNotes.deinit();
     12  IOUtils.remove(
     13    PathUtils.join(PathUtils.tempDir, TabNotes.DATABASE_FILE_NAME),
     14    {
     15      ignoreAbsent: true,
     16    }
     17  );
     18 });
     19 
     20 /**
     21 * Fake for MozTabbrowserTab.
     22 */
     23 class FakeTab extends EventTarget {
     24  /**
     25   * @param {string} canonicalUrl
     26   */
     27  constructor(canonicalUrl) {
     28    super();
     29    /** @type {string} */
     30    this.canonicalUrl = canonicalUrl;
     31  }
     32 }
     33 
     34 add_task(async function tabNotesBasicStorageTests() {
     35  let tab = new FakeTab("https://example.com/abc");
     36  let value = "some note";
     37  let updatedValue = "some other note";
     38 
     39  let tabNoteCreated = BrowserTestUtils.waitForEvent(tab, "TabNote:Created");
     40  let firstSavedNote = await TabNotes.set(tab, value);
     41  Assert.ok(firstSavedNote, "TabNotes.set returns the saved tab note");
     42  Assert.ok(await tabNoteCreated, "observers were notified of TabNote:Created");
     43  Assert.equal(
     44    firstSavedNote.canonicalUrl,
     45    tab.canonicalUrl,
     46    "TabNotes.set stores the right URL"
     47  );
     48  Assert.equal(
     49    firstSavedNote.text,
     50    value,
     51    "TabNotes.set stores the right note text"
     52  );
     53  Assert.ok(firstSavedNote.created, "TabNotes.set stores a creation timestamp");
     54 
     55  Assert.equal(
     56    await TabNotes.has(tab),
     57    true,
     58    "TabNotes.has indicates that the tab has a note"
     59  );
     60 
     61  Assert.deepEqual(
     62    await TabNotes.get(tab),
     63    firstSavedNote,
     64    "TabNotes.get returns previously set note"
     65  );
     66 
     67  let tabNoteEdited = BrowserTestUtils.waitForEvent(tab, "TabNote:Edited");
     68  let editedSavedNote = await TabNotes.set(tab, updatedValue);
     69 
     70  Assert.ok(editedSavedNote, "TabNotes.set returns the updated tab note");
     71  Assert.ok(await tabNoteEdited, "observers were notified of TabNote:Edited");
     72  Assert.equal(
     73    editedSavedNote.canonicalUrl,
     74    tab.canonicalUrl,
     75    "TabNotes.set should keep the same URL when updating"
     76  );
     77  Assert.equal(
     78    editedSavedNote.text,
     79    updatedValue,
     80    "TabNotes.set saved the new note text"
     81  );
     82  Assert.equal(
     83    Temporal.Instant.compare(editedSavedNote.created, firstSavedNote.created),
     84    0,
     85    "TabNotes.set should not change the creation timestamp when updating an existing note"
     86  );
     87 
     88  const tabWithoutCanonicalUrl = new FakeTab(undefined);
     89  let wasDeleted = await TabNotes.delete(tabWithoutCanonicalUrl);
     90  Assert.ok(
     91    !wasDeleted,
     92    "TabNotes.delete should return false if nothing was deleted"
     93  );
     94 
     95  let tabNoteRemoved = BrowserTestUtils.waitForEvent(tab, "TabNote:Removed");
     96  wasDeleted = await TabNotes.delete(tab);
     97  Assert.ok(await tabNoteRemoved, "listeners were notified of TabNote:Removed");
     98  Assert.ok(
     99    wasDeleted,
    100    "TabNotes.delete should return true if something was deleted"
    101  );
    102 
    103  Assert.equal(
    104    await TabNotes.has(tab),
    105    false,
    106    "TabNotes.has indicates that the deleted URL no longer has a note"
    107  );
    108 
    109  Assert.equal(
    110    await TabNotes.get(tab),
    111    undefined,
    112    "TabNotes.get returns undefined for URL that does not have a note"
    113  );
    114 
    115  await TabNotes.reset();
    116 });
    117 
    118 add_task(function tabNotesIsEligible() {
    119  Assert.ok(
    120    TabNotes.isEligible(new FakeTab("https://example.com/")),
    121    "tab with a valid canonical URL is eligible"
    122  );
    123  Assert.ok(
    124    !TabNotes.isEligible(new FakeTab(undefined)),
    125    "tab with no canonical URL is ineligible"
    126  );
    127  Assert.ok(
    128    !TabNotes.isEligible(new FakeTab("not a valid URL")),
    129    "tab with an unparseable canonical URL is ineligible"
    130  );
    131 });
    132 
    133 add_task(async function tabNotesSanitizationTests() {
    134  let tab = new FakeTab("https://example.com/");
    135  let tooLongValue = "x".repeat(1500);
    136  let correctValue = "x".repeat(1000);
    137 
    138  const savedNote = await TabNotes.set(tab, tooLongValue);
    139 
    140  Assert.equal(
    141    savedNote.text,
    142    correctValue,
    143    "TabNotes.set truncates note length"
    144  );
    145 
    146  await TabNotes.reset();
    147 });
    148 
    149 add_task(async function tabNotesErrors() {
    150  await Assert.rejects(
    151    TabNotes.set(new FakeTab(undefined), "valid note text"),
    152    /RangeError/,
    153    "tabs without canonical URLs are not eligible for tab notes"
    154  );
    155 
    156  await Assert.rejects(
    157    TabNotes.set(new FakeTab("not a valid URL"), "valid note text"),
    158    /RangeError/,
    159    "invalid URLs should not be allowed in TabNotes.set"
    160  );
    161 
    162  await Assert.rejects(
    163    TabNotes.set(new FakeTab("https://example.com"), ""),
    164    /RangeError/,
    165    "empty note text should not be allowed in TabNotes.set"
    166  );
    167 });