312 lines
8.3 KiB
JavaScript
312 lines
8.3 KiB
JavaScript
/* Any copyright is dedicated to the Public Domain.
|
|
* http://creativecommons.org/publicdomain/zero/1.0/ */
|
|
|
|
add_task(async function test_queries() {
|
|
let buf = await openMirror("queries");
|
|
|
|
info("Set up places");
|
|
|
|
// create a tag and grab the local folder ID.
|
|
let tag = await PlacesUtils.bookmarks.insert({
|
|
type: PlacesUtils.bookmarks.TYPE_FOLDER,
|
|
parentGuid: PlacesUtils.bookmarks.tagsGuid,
|
|
title: "a-tag",
|
|
});
|
|
|
|
await PlacesTestUtils.markBookmarksAsSynced();
|
|
|
|
await PlacesUtils.bookmarks.insertTree({
|
|
guid: PlacesUtils.bookmarks.menuGuid,
|
|
children: [
|
|
{
|
|
// this entry has a tag= query param for a tag that exists.
|
|
guid: "queryAAAAAAA",
|
|
type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
|
|
title: "TAG_QUERY query",
|
|
url: `place:tag=a-tag&&sort=14&maxResults=10`,
|
|
},
|
|
{
|
|
// this entry has a tag= query param for a tag that doesn't exist.
|
|
guid: "queryBBBBBBB",
|
|
type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
|
|
title: "TAG_QUERY query but invalid folder id",
|
|
url: `place:tag=b-tag&sort=14&maxResults=10`,
|
|
},
|
|
{
|
|
// this entry has no tag= query param.
|
|
guid: "queryCCCCCCC",
|
|
type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
|
|
title: "TAG_QUERY without a folder at all",
|
|
url: "place:sort=14&maxResults=10",
|
|
},
|
|
{
|
|
// this entry has only a tag= query.
|
|
guid: "queryDDDDDDD",
|
|
type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
|
|
title: "TAG_QUERY without a folder at all",
|
|
url: "place:tag=a-tag",
|
|
},
|
|
],
|
|
});
|
|
|
|
info("Make remote changes");
|
|
await storeRecords(
|
|
buf,
|
|
shuffle([
|
|
{
|
|
id: "toolbar",
|
|
parentid: "places",
|
|
type: "folder",
|
|
children: [
|
|
"queryEEEEEEE",
|
|
"queryFFFFFFF",
|
|
"queryGGGGGGG",
|
|
"queryHHHHHHH",
|
|
"queryIIIIIII",
|
|
],
|
|
},
|
|
{
|
|
// Legacy tag query.
|
|
id: "queryEEEEEEE",
|
|
parentid: "toolbar",
|
|
type: "query",
|
|
title: "E",
|
|
bmkUri: "place:type=7&folder=999",
|
|
folderName: "taggy",
|
|
},
|
|
{
|
|
// New tag query.
|
|
id: "queryFFFFFFF",
|
|
parentid: "toolbar",
|
|
type: "query",
|
|
title: "F",
|
|
bmkUri: "place:tag=a-tag",
|
|
folderName: "a-tag",
|
|
},
|
|
{
|
|
// Legacy tag query referencing the same tag as the new query.
|
|
id: "queryGGGGGGG",
|
|
parentid: "toolbar",
|
|
type: "query",
|
|
title: "G",
|
|
bmkUri: "place:type=7&folder=111&something=else",
|
|
folderName: "a-tag",
|
|
},
|
|
{
|
|
// Legacy folder lookup query.
|
|
id: "queryHHHHHHH",
|
|
parentid: "toolbar",
|
|
type: "query",
|
|
title: "H",
|
|
bmkUri: "place:folder=1",
|
|
},
|
|
{
|
|
// Legacy tag query with invalid tag folder name.
|
|
id: "queryIIIIIII",
|
|
parentid: "toolbar",
|
|
type: "query",
|
|
title: "I",
|
|
bmkUri: "place:type=7&folder=222",
|
|
folderName: " ",
|
|
},
|
|
])
|
|
);
|
|
|
|
info("Create records to upload");
|
|
let changes = await buf.apply();
|
|
deepEqual(
|
|
Object.keys(changes),
|
|
[
|
|
"menu",
|
|
"toolbar",
|
|
"queryAAAAAAA",
|
|
"queryBBBBBBB",
|
|
"queryCCCCCCC",
|
|
"queryDDDDDDD",
|
|
"queryEEEEEEE",
|
|
"queryGGGGGGG",
|
|
"queryHHHHHHH",
|
|
"queryIIIIIII",
|
|
],
|
|
"Should upload roots, new queries, and rewritten queries"
|
|
);
|
|
Assert.strictEqual(changes.queryAAAAAAA.cleartext.folderName, tag.title);
|
|
Assert.strictEqual(changes.queryBBBBBBB.cleartext.folderName, "b-tag");
|
|
Assert.strictEqual(changes.queryCCCCCCC.cleartext.folderName, undefined);
|
|
Assert.strictEqual(changes.queryDDDDDDD.cleartext.folderName, tag.title);
|
|
Assert.strictEqual(changes.queryIIIIIII.tombstone, true);
|
|
|
|
await assertLocalTree(
|
|
PlacesUtils.bookmarks.toolbarGuid,
|
|
{
|
|
guid: PlacesUtils.bookmarks.toolbarGuid,
|
|
type: PlacesUtils.bookmarks.TYPE_FOLDER,
|
|
index: 1,
|
|
title: BookmarksToolbarTitle,
|
|
children: [
|
|
{
|
|
guid: "queryEEEEEEE",
|
|
type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
|
|
index: 0,
|
|
title: "E",
|
|
url: "place:tag=taggy",
|
|
},
|
|
{
|
|
guid: "queryFFFFFFF",
|
|
type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
|
|
index: 1,
|
|
title: "F",
|
|
url: "place:tag=a-tag",
|
|
},
|
|
{
|
|
guid: "queryGGGGGGG",
|
|
type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
|
|
index: 2,
|
|
title: "G",
|
|
url: "place:tag=a-tag",
|
|
},
|
|
{
|
|
guid: "queryHHHHHHH",
|
|
type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
|
|
index: 3,
|
|
title: "H",
|
|
url: "place:folder=1&excludeItems=1",
|
|
},
|
|
],
|
|
},
|
|
"Should rewrite legacy remote queries"
|
|
);
|
|
|
|
await buf.finalize();
|
|
await PlacesUtils.bookmarks.eraseEverything();
|
|
await PlacesSyncUtils.bookmarks.reset();
|
|
});
|
|
|
|
add_task(async function test_different_but_compatible_bookmark_types() {
|
|
let buf = await openMirror("partial_queries");
|
|
try {
|
|
await PlacesUtils.bookmarks.insertTree({
|
|
guid: PlacesUtils.bookmarks.menuGuid,
|
|
children: [
|
|
{
|
|
guid: "bookmarkAAAA",
|
|
type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
|
|
title: "not yet a query",
|
|
url: "about:blank",
|
|
},
|
|
{
|
|
guid: "bookmarkBBBB",
|
|
type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
|
|
title: "a query",
|
|
url: "place:foo",
|
|
},
|
|
],
|
|
});
|
|
|
|
let changes = await buf.apply();
|
|
// We should have an outgoing record for bookmarkA with type=bookmark
|
|
// and bookmarkB with type=query.
|
|
Assert.equal(changes.bookmarkAAAA.cleartext.type, "bookmark");
|
|
Assert.equal(changes.bookmarkBBBB.cleartext.type, "query");
|
|
|
|
// Now pretend that same records are already on the server.
|
|
await storeRecords(
|
|
buf,
|
|
[
|
|
{
|
|
id: "menu",
|
|
parentid: "places",
|
|
type: "folder",
|
|
children: ["bookmarkAAAA", "bookmarkBBBB"],
|
|
},
|
|
{
|
|
id: "bookmarkAAAA",
|
|
parentid: "menu",
|
|
type: "bookmark",
|
|
title: "not yet a query",
|
|
bmkUri: "about:blank",
|
|
},
|
|
{
|
|
id: "bookmarkBBBB",
|
|
parentid: "menu",
|
|
type: "query",
|
|
title: "a query",
|
|
bmkUri: "place:foo",
|
|
},
|
|
],
|
|
{ needsMerge: false }
|
|
);
|
|
await PlacesTestUtils.markBookmarksAsSynced();
|
|
|
|
// change the url of bookmarkA to be a "real" query and of bookmarkB to
|
|
// no longer be a query.
|
|
await PlacesUtils.bookmarks.update({
|
|
guid: "bookmarkAAAA",
|
|
url: "place:type=6&sort=14&maxResults=10",
|
|
});
|
|
await PlacesUtils.bookmarks.update({
|
|
guid: "bookmarkBBBB",
|
|
url: "about:robots",
|
|
});
|
|
|
|
changes = await buf.apply();
|
|
// We should have an outgoing record for bookmarkA with type=query and
|
|
// for bookmarkB with type=bookmark
|
|
Assert.equal(changes.bookmarkAAAA.cleartext.type, "query");
|
|
Assert.equal(changes.bookmarkBBBB.cleartext.type, "bookmark");
|
|
} finally {
|
|
await buf.finalize();
|
|
await PlacesUtils.bookmarks.eraseEverything();
|
|
await PlacesSyncUtils.bookmarks.reset();
|
|
}
|
|
});
|
|
|
|
add_task(async function test_incompatible_types() {
|
|
try {
|
|
let buf = await openMirror("incompatible_types");
|
|
|
|
await PlacesUtils.bookmarks.insertTree({
|
|
guid: PlacesUtils.bookmarks.menuGuid,
|
|
children: [
|
|
{
|
|
guid: "AAAAAAAAAAAA",
|
|
type: PlacesUtils.bookmarks.TYPE_BOOKMARK,
|
|
title: "a bookmark",
|
|
url: "about:blank",
|
|
},
|
|
],
|
|
});
|
|
|
|
await buf.apply();
|
|
|
|
// Now pretend that same records are already on the server with incompatible
|
|
// types.
|
|
await storeRecords(
|
|
buf,
|
|
[
|
|
{
|
|
id: "menu",
|
|
parentid: "places",
|
|
type: "folder",
|
|
children: ["AAAAAAAAAAAA"],
|
|
},
|
|
{
|
|
id: "AAAAAAAAAAAA",
|
|
parentid: "menu",
|
|
type: "folder",
|
|
title: "conflicting folder",
|
|
},
|
|
],
|
|
{ needsMerge: true }
|
|
);
|
|
await PlacesTestUtils.markBookmarksAsSynced();
|
|
|
|
await Assert.rejects(
|
|
buf.apply(),
|
|
/Can't merge local Bookmark <guid: AAAAAAAAAAAA> and remote Folder <guid: AAAAAAAAAAAA>/
|
|
);
|
|
} finally {
|
|
await PlacesUtils.bookmarks.eraseEverything();
|
|
await PlacesSyncUtils.bookmarks.reset();
|
|
}
|
|
});
|