mozilla-central/toolkit/components/places/tests/unit/test_keywords.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info:

"use strict";
ChromeUtils.defineESModuleGetters(this, {
});
async function check_keyword(aExpectExists, aHref, aKeyword, aPostData = null) {
// Check case-insensitivity.
aKeyword = aKeyword.toUpperCase();
let entry = await PlacesUtils.keywords.fetch(aKeyword);
Assert.deepEqual(
entry,
await PlacesUtils.keywords.fetch({ keyword: aKeyword })
);
if (aExpectExists) {
Assert.ok(!!entry, "A keyword should exist");
Assert.equal(entry.url.href, aHref);
Assert.equal(entry.postData, aPostData);
Assert.deepEqual(
entry,
await PlacesUtils.keywords.fetch({ keyword: aKeyword, url: aHref })
);
let entries = [];
await PlacesUtils.keywords.fetch({ url: aHref }, e => entries.push(e));
Assert.ok(
entries.some(
e => e.url.href == aHref && e.keyword == aKeyword.toLowerCase()
)
);
} else {
Assert.ok(
!entry || entry.url.href != aHref,
"The given keyword entry should not exist"
);
if (aHref) {
Assert.equal(
null,
await PlacesUtils.keywords.fetch({ keyword: aKeyword, url: aHref })
);
} else {
Assert.equal(
null,
await PlacesUtils.keywords.fetch({ keyword: aKeyword })
);
}
}
}
/**
* Polls the keywords cache waiting for the given keyword entry.
*/
async function promiseKeyword(keyword, expectedHref) {
let href = null;
do {
await new Promise(resolve => do_timeout(100, resolve));
let entry = await PlacesUtils.keywords.fetch(keyword);
if (entry) {
href = entry.url.href;
}
} while (href != expectedHref);
}
async function check_no_orphans() {
let db = await PlacesUtils.promiseDBConnection();
let rows = await db.executeCached(
`SELECT id FROM moz_keywords k
WHERE NOT EXISTS (SELECT 1 FROM moz_places WHERE id = k.place_id)
`
);
Assert.equal(rows.length, 0);
}
function expectBookmarkNotifications() {
const observer = {
notifications: [],
_start() {
this._handle = this._handle.bind(this);
PlacesUtils.observers.addListener(
["bookmark-keyword-changed"],
this._handle
);
},
_handle(events) {
for (const event of events) {
this.notifications.push({
type: event.type,
id: event.id,
itemType: event.itemType,
url: event.url,
guid: event.guid,
parentGuid: event.parentGuid,
keyword: event.keyword,
lastModified: new Date(event.lastModified),
source: event.source,
isTagging: event.isTagging,
});
}
},
check(expected) {
PlacesUtils.observers.removeListener(
["bookmark-keyword-changed"],
this._handle
);
Assert.deepEqual(this.notifications, expected);
},
};
observer._start();
return observer;
}
add_task(async function test_invalid_input() {
Assert.throws(() => PlacesUtils.keywords.fetch(null), /Invalid keyword/);
Assert.throws(() => PlacesUtils.keywords.fetch(5), /Invalid keyword/);
Assert.throws(() => PlacesUtils.keywords.fetch(undefined), /Invalid keyword/);
Assert.throws(
() => PlacesUtils.keywords.fetch({ keyword: null }),
/Invalid keyword/
);
Assert.throws(
() => PlacesUtils.keywords.fetch({ keyword: {} }),
/Invalid keyword/
);
Assert.throws(
() => PlacesUtils.keywords.fetch({ keyword: 5 }),
/Invalid keyword/
);
Assert.throws(
() => PlacesUtils.keywords.fetch({}),
/At least keyword or url must be provided/
);
Assert.throws(
() => PlacesUtils.keywords.fetch({ keyword: "test" }, "test"),
/onResult callback must be a valid function/
);
Assert.throws(
() => PlacesUtils.keywords.fetch({ url: "test" }),
/is not a valid URL/
);
Assert.throws(
() => PlacesUtils.keywords.fetch({ url: {} }),
/is not a valid URL/
);
Assert.throws(
() => PlacesUtils.keywords.fetch({ url: null }),
/is not a valid URL/
);
Assert.throws(
() => PlacesUtils.keywords.fetch({ url: "" }),
/is not a valid URL/
);
Assert.throws(
() => PlacesUtils.keywords.insert(null),
/Input should be a valid object/
);
Assert.throws(
() => PlacesUtils.keywords.insert("test"),
/Input should be a valid object/
);
Assert.throws(
() => PlacesUtils.keywords.insert(undefined),
/Input should be a valid object/
);
Assert.throws(() => PlacesUtils.keywords.insert({}), /Invalid keyword/);
Assert.throws(
() => PlacesUtils.keywords.insert({ keyword: null }),
/Invalid keyword/
);
Assert.throws(
() => PlacesUtils.keywords.insert({ keyword: 5 }),
/Invalid keyword/
);
Assert.throws(
() => PlacesUtils.keywords.insert({ keyword: "" }),
/Invalid keyword/
);
Assert.throws(
() => PlacesUtils.keywords.insert({ keyword: "test", postData: 5 }),
/Invalid POST data/
);
Assert.throws(
() => PlacesUtils.keywords.insert({ keyword: "test", postData: {} }),
/Invalid POST data/
);
Assert.throws(
() => PlacesUtils.keywords.insert({ keyword: "test" }),
/is not a valid URL/
);
Assert.throws(
() => PlacesUtils.keywords.insert({ keyword: "test", url: 5 }),
/is not a valid URL/
);
Assert.throws(
() => PlacesUtils.keywords.insert({ keyword: "test", url: "" }),
/is not a valid URL/
);
Assert.throws(
() => PlacesUtils.keywords.insert({ keyword: "test", url: null }),
/is not a valid URL/
);
Assert.throws(
() => PlacesUtils.keywords.insert({ keyword: "test", url: "mozilla" }),
/is not a valid URL/
);
Assert.throws(() => PlacesUtils.keywords.remove(null), /Invalid keyword/);
Assert.throws(() => PlacesUtils.keywords.remove(""), /Invalid keyword/);
Assert.throws(() => PlacesUtils.keywords.remove(5), /Invalid keyword/);
});
add_task(async function test_addKeyword() {
await check_keyword(false, "http://example.com/", "keyword");
let fc = await foreign_count("http://example.com/");
let observer = expectBookmarkNotifications();
await PlacesUtils.keywords.insert({
keyword: "keyword",
});
observer.check([]);
await check_keyword(true, "http://example.com/", "keyword");
Assert.equal(await foreign_count("http://example.com/"), fc + 1); // +1 keyword
// Now remove the keyword.
observer = expectBookmarkNotifications();
await PlacesUtils.keywords.remove("keyword");
observer.check([]);
await check_keyword(false, "http://example.com/", "keyword");
Assert.equal(await foreign_count("http://example.com/"), fc); // -1 keyword
// Check using URL.
await PlacesUtils.keywords.insert({
keyword: "keyword",
url: new URL("http://example.com/"),
});
await check_keyword(true, "http://example.com/", "keyword");
await PlacesUtils.keywords.remove("keyword");
await check_keyword(false, "http://example.com/", "keyword");
await check_no_orphans();
});
add_task(async function test_addBookmarkAndKeyword() {
let timerPrecision = Preferences.get("privacy.reduceTimerPrecision");
Preferences.set("privacy.reduceTimerPrecision", false);
registerCleanupFunction(function () {
Preferences.set("privacy.reduceTimerPrecision", timerPrecision);
});
await check_keyword(false, "http://example.com/", "keyword");
let fc = await foreign_count("http://example.com/");
let bookmark = await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
});
let observer = expectBookmarkNotifications();
await PlacesUtils.keywords.insert({
keyword: "keyword",
});
observer.check([
{
type: "bookmark-keyword-changed",
id: await PlacesTestUtils.promiseItemId(bookmark.guid),
itemType: bookmark.type,
url: bookmark.url,
guid: bookmark.guid,
parentGuid: bookmark.parentGuid,
keyword: "keyword",
lastModified: new Date(bookmark.lastModified),
source: Ci.nsINavBookmarksService.SOURCE_DEFAULT,
isTagging: false,
},
]);
await check_keyword(true, "http://example.com/", "keyword");
Assert.equal(await foreign_count("http://example.com/"), fc + 2); // +1 bookmark +1 keyword
// Now remove the keyword.
observer = expectBookmarkNotifications();
await PlacesUtils.keywords.remove("keyword");
observer.check([
{
type: "bookmark-keyword-changed",
id: await PlacesTestUtils.promiseItemId(bookmark.guid),
itemType: bookmark.type,
url: bookmark.url,
guid: bookmark.guid,
parentGuid: bookmark.parentGuid,
keyword: "",
lastModified: new Date(bookmark.lastModified),
source: Ci.nsINavBookmarksService.SOURCE_DEFAULT,
isTagging: false,
},
]);
await check_keyword(false, "http://example.com/", "keyword");
Assert.equal(await foreign_count("http://example.com/"), fc + 1); // -1 keyword
// Add again the keyword, then remove the bookmark.
await PlacesUtils.keywords.insert({
keyword: "keyword",
});
observer = expectBookmarkNotifications();
await PlacesUtils.bookmarks.remove(bookmark.guid);
// the notification is synchronous but the removal process is async.
// Unfortunately there's nothing explicit we can wait for.
// eslint-disable-next-line no-empty
while (await foreign_count("http://example.com/")) {}
// We don't get any itemChanged notification since the bookmark has been
// removed already.
observer.check([]);
await check_keyword(false, "http://example.com/", "keyword");
await check_no_orphans();
});
add_task(async function test_addKeywordToURIHavingKeyword() {
await check_keyword(false, "http://example.com/", "keyword");
let fc = await foreign_count("http://example.com/");
let observer = expectBookmarkNotifications();
await PlacesUtils.keywords.insert({
keyword: "keyword",
});
observer.check([]);
await check_keyword(true, "http://example.com/", "keyword");
Assert.equal(await foreign_count("http://example.com/"), fc + 1); // +1 keyword
await PlacesUtils.keywords.insert({
keyword: "keyword2",
postData: "test=1",
});
await check_keyword(true, "http://example.com/", "keyword");
await check_keyword(true, "http://example.com/", "keyword2", "test=1");
Assert.equal(await foreign_count("http://example.com/"), fc + 2); // +1 keyword
let entries = [];
let entry = await PlacesUtils.keywords.fetch(
{ url: "http://example.com/" },
e => entries.push(e)
);
Assert.equal(entries.length, 2);
Assert.deepEqual(entries[0], entry);
// Now remove the keywords.
observer = expectBookmarkNotifications();
await PlacesUtils.keywords.remove("keyword");
await PlacesUtils.keywords.remove("keyword2");
observer.check([]);
await check_keyword(false, "http://example.com/", "keyword");
await check_keyword(false, "http://example.com/", "keyword2");
Assert.equal(await foreign_count("http://example.com/"), fc); // -1 keyword
await check_no_orphans();
});
add_task(async function test_addBookmarkToURIHavingKeyword() {
await check_keyword(false, "http://example.com/", "keyword");
let fc = await foreign_count("http://example.com/");
let observer = expectBookmarkNotifications();
await PlacesUtils.keywords.insert({
keyword: "keyword",
});
observer.check([]);
await check_keyword(true, "http://example.com/", "keyword");
Assert.equal(await foreign_count("http://example.com/"), fc + 1); // +1 keyword
observer = expectBookmarkNotifications();
let bookmark = await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
});
Assert.equal(await foreign_count("http://example.com/"), fc + 2); // +1 bookmark
observer.check([]);
observer = expectBookmarkNotifications();
await PlacesUtils.bookmarks.remove(bookmark.guid);
// the notification is synchronous but the removal process is async.
// Unfortunately there's nothing explicit we can wait for.
// eslint-disable-next-line no-empty
while (await foreign_count("http://example.com/")) {}
// We don't get any itemChanged notification since the bookmark has been
// removed already.
observer.check([]);
await check_keyword(false, "http://example.com/", "keyword");
await check_no_orphans();
});
add_task(async function test_sameKeywordDifferentURL() {
let fc1 = await foreign_count("http://example1.com/");
let bookmark1 = await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
});
let fc2 = await foreign_count("http://example2.com/");
let bookmark2 = await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
});
await PlacesUtils.keywords.insert({
keyword: "keyword",
});
await check_keyword(true, "http://example1.com/", "keyword");
Assert.equal(await foreign_count("http://example1.com/"), fc1 + 2); // +1 bookmark +1 keyword
await check_keyword(false, "http://example2.com/", "keyword");
Assert.equal(await foreign_count("http://example2.com/"), fc2 + 1); // +1 bookmark
// Assign the same keyword to another url.
let observer = expectBookmarkNotifications();
await PlacesUtils.keywords.insert({
keyword: "keyword",
});
observer.check([
{
type: "bookmark-keyword-changed",
id: await PlacesTestUtils.promiseItemId(bookmark1.guid),
itemType: bookmark1.type,
url: bookmark1.url,
guid: bookmark1.guid,
parentGuid: bookmark1.parentGuid,
keyword: "",
lastModified: new Date(bookmark1.lastModified),
source: Ci.nsINavBookmarksService.SOURCE_DEFAULT,
isTagging: false,
},
{
type: "bookmark-keyword-changed",
id: await PlacesTestUtils.promiseItemId(bookmark2.guid),
itemType: bookmark2.type,
url: bookmark2.url,
guid: bookmark2.guid,
parentGuid: bookmark2.parentGuid,
keyword: "keyword",
lastModified: new Date(bookmark2.lastModified),
source: Ci.nsINavBookmarksService.SOURCE_DEFAULT,
isTagging: false,
},
]);
await check_keyword(false, "http://example1.com/", "keyword");
Assert.equal(await foreign_count("http://example1.com/"), fc1 + 1); // -1 keyword
await check_keyword(true, "http://example2.com/", "keyword");
Assert.equal(await foreign_count("http://example2.com/"), fc2 + 2); // +1 keyword
// Now remove the keyword.
observer = expectBookmarkNotifications();
await PlacesUtils.keywords.remove("keyword");
observer.check([
{
type: "bookmark-keyword-changed",
id: await PlacesTestUtils.promiseItemId(bookmark2.guid),
itemType: bookmark2.type,
url: bookmark2.url,
guid: bookmark2.guid,
parentGuid: bookmark2.parentGuid,
keyword: "",
lastModified: new Date(bookmark2.lastModified),
source: Ci.nsINavBookmarksService.SOURCE_DEFAULT,
isTagging: false,
},
]);
await check_keyword(false, "http://example1.com/", "keyword");
await check_keyword(false, "http://example2.com/", "keyword");
Assert.equal(await foreign_count("http://example1.com/"), fc1 + 1);
Assert.equal(await foreign_count("http://example2.com/"), fc2 + 1); // -1 keyword
await PlacesUtils.bookmarks.remove(bookmark1);
await PlacesUtils.bookmarks.remove(bookmark2);
Assert.equal(await foreign_count("http://example1.com/"), fc1); // -1 bookmark
// eslint-disable-next-line no-empty
while (await foreign_count("http://example2.com/")) {} // -1 keyword
await check_no_orphans();
});
add_task(async function test_sameURIDifferentKeyword() {
let fc = await foreign_count("http://example.com/");
let observer = expectBookmarkNotifications();
let bookmark = await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
});
await PlacesUtils.keywords.insert({
keyword: "keyword",
});
await check_keyword(true, "http://example.com/", "keyword");
Assert.equal(await foreign_count("http://example.com/"), fc + 2); // +1 bookmark +1 keyword
observer.check([
{
type: "bookmark-keyword-changed",
id: await PlacesTestUtils.promiseItemId(bookmark.guid),
itemType: bookmark.type,
url: bookmark.url,
guid: bookmark.guid,
parentGuid: bookmark.parentGuid,
keyword: "keyword",
lastModified: new Date(bookmark.lastModified),
source: Ci.nsINavBookmarksService.SOURCE_DEFAULT,
isTagging: false,
},
]);
observer = expectBookmarkNotifications();
await PlacesUtils.keywords.insert({
keyword: "keyword2",
});
await check_keyword(false, "http://example.com/", "keyword");
await check_keyword(true, "http://example.com/", "keyword2");
Assert.equal(await foreign_count("http://example.com/"), fc + 2); // -1 keyword +1 keyword
observer.check([
{
type: "bookmark-keyword-changed",
id: await PlacesTestUtils.promiseItemId(bookmark.guid),
itemType: bookmark.type,
url: bookmark.url,
guid: bookmark.guid,
parentGuid: bookmark.parentGuid,
keyword: "keyword2",
lastModified: new Date(bookmark.lastModified),
source: Ci.nsINavBookmarksService.SOURCE_DEFAULT,
isTagging: false,
},
]);
// Now remove the bookmark.
await PlacesUtils.bookmarks.remove(bookmark);
// eslint-disable-next-line no-empty
while (await foreign_count("http://example.com/")) {}
await check_keyword(false, "http://example.com/", "keyword");
await check_keyword(false, "http://example.com/", "keyword2");
await check_no_orphans();
});
add_task(async function test_deleteKeywordMultipleBookmarks() {
let fc = await foreign_count("http://example.com/");
let observer = expectBookmarkNotifications();
let bookmark1 = await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
});
let bookmark2 = await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
});
await PlacesUtils.keywords.insert({
keyword: "keyword",
});
await check_keyword(true, "http://example.com/", "keyword");
Assert.equal(await foreign_count("http://example.com/"), fc + 3); // +2 bookmark +1 keyword
observer.check([
{
type: "bookmark-keyword-changed",
id: await PlacesTestUtils.promiseItemId(bookmark2.guid),
itemType: bookmark2.type,
url: bookmark2.url,
guid: bookmark2.guid,
parentGuid: bookmark2.parentGuid,
keyword: "keyword",
lastModified: new Date(bookmark2.lastModified),
source: Ci.nsINavBookmarksService.SOURCE_DEFAULT,
isTagging: false,
},
{
type: "bookmark-keyword-changed",
id: await PlacesTestUtils.promiseItemId(bookmark1.guid),
itemType: bookmark1.type,
url: bookmark1.url,
guid: bookmark1.guid,
parentGuid: bookmark1.parentGuid,
keyword: "keyword",
lastModified: new Date(bookmark1.lastModified),
source: Ci.nsINavBookmarksService.SOURCE_DEFAULT,
isTagging: false,
},
]);
observer = expectBookmarkNotifications();
await PlacesUtils.keywords.remove("keyword");
await check_keyword(false, "http://example.com/", "keyword");
Assert.equal(await foreign_count("http://example.com/"), fc + 2); // -1 keyword
observer.check([
{
type: "bookmark-keyword-changed",
id: await PlacesTestUtils.promiseItemId(bookmark2.guid),
itemType: bookmark2.type,
url: bookmark2.url,
guid: bookmark2.guid,
parentGuid: bookmark2.parentGuid,
keyword: "",
lastModified: new Date(bookmark2.lastModified),
source: Ci.nsINavBookmarksService.SOURCE_DEFAULT,
isTagging: false,
},
{
type: "bookmark-keyword-changed",
id: await PlacesTestUtils.promiseItemId(bookmark1.guid),
itemType: bookmark1.type,
url: bookmark1.url,
guid: bookmark1.guid,
parentGuid: bookmark1.parentGuid,
keyword: "",
lastModified: new Date(bookmark1.lastModified),
source: Ci.nsINavBookmarksService.SOURCE_DEFAULT,
isTagging: false,
},
]);
// Now remove the bookmarks.
await PlacesUtils.bookmarks.remove(bookmark1);
await PlacesUtils.bookmarks.remove(bookmark2);
Assert.equal(await foreign_count("http://example.com/"), fc); // -2 bookmarks
await check_no_orphans();
});
add_task(async function test_multipleKeywordsSamePostData() {
await PlacesUtils.keywords.insert({
keyword: "keyword",
postData: "postData1",
});
await check_keyword(true, "http://example.com/", "keyword", "postData1");
// Add another keyword with same postData, should fail.
await PlacesUtils.keywords.insert({
keyword: "keyword2",
postData: "postData1",
});
await check_keyword(false, "http://example.com/", "keyword", "postData1");
await check_keyword(true, "http://example.com/", "keyword2", "postData1");
await PlacesUtils.keywords.remove("keyword2");
await check_no_orphans();
});
add_task(async function test_bookmarkURLChange() {
let fc1 = await foreign_count("http://example1.com/");
let fc2 = await foreign_count("http://example2.com/");
let bookmark = await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
});
await PlacesUtils.keywords.insert({
keyword: "keyword",
});
await check_keyword(true, "http://example1.com/", "keyword");
Assert.equal(await foreign_count("http://example1.com/"), fc1 + 2); // +1 bookmark +1 keyword
await PlacesUtils.bookmarks.update({
guid: bookmark.guid,
});
await promiseKeyword("keyword", "http://example2.com/");
await check_keyword(false, "http://example1.com/", "keyword");
await check_keyword(true, "http://example2.com/", "keyword");
Assert.equal(await foreign_count("http://example1.com/"), fc1); // -1 bookmark -1 keyword
Assert.equal(await foreign_count("http://example2.com/"), fc2 + 2); // +1 bookmark +1 keyword
});
add_task(async function test_tagDoesntPreventKeywordRemoval() {
await check_keyword(false, "http://example.com/", "example");
let fc = await foreign_count("http://example.com/");
let httpBookmark = await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
});
Assert.equal(await foreign_count("http://example.com/"), fc + 1); // +1 bookmark
PlacesUtils.tagging.tagURI(uri("http://example.com/"), ["example_tag"]);
Assert.equal(await foreign_count("http://example.com/"), fc + 2); // +1 bookmark +1 tag
await PlacesUtils.keywords.insert({
keyword: "example",
});
Assert.equal(await foreign_count("http://example.com/"), fc + 3); // +1 bookmark +1 tag +1 keyword
await check_keyword(true, "http://example.com/", "example");
await PlacesUtils.bookmarks.remove(httpBookmark);
await TestUtils.waitForCondition(
async () =>
!(await PlacesUtils.bookmarks.fetch({ url: "http://example.com/" })),
"Wait for bookmark to be removed"
);
await check_keyword(false, "http://example.com/", "example");
Assert.equal(await foreign_count("http://example.com/"), fc); // bookmark, keyword, and tag should all have been removed
await check_no_orphans();
});