Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

25 files changed, 1435 insertions, 0 deletions

diff --git a/toolkit/components/places/tests/migration/favicons_v41.sqlite b/toolkit/components/places/tests/migration/favicons_v41.sqlite
new file mode 100644
index 0000000000..a59d9d286f
--- /dev/null
+++ b/toolkit/components/places/tests/migration/favicons_v41.sqlite
diff --git a/toolkit/components/places/tests/migration/head_migration.js b/toolkit/components/places/tests/migration/head_migration.js
new file mode 100644
index 0000000000..9dce9b34b9
--- /dev/null
+++ b/toolkit/components/places/tests/migration/head_migration.js
@@ -0,0 +1,47 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+// Import common head.
+{
+  /* import-globals-from ../head_common.js */
+  let commonFile = do_get_file("../head_common.js", false);
+  let uri = Services.io.newFileURI(commonFile);
+  Services.scriptloader.loadSubScript(uri.spec, this);
+}
+
+// Put any other stuff relative to this test folder below.
+
+const CURRENT_SCHEMA_VERSION = 71;
+const FIRST_UPGRADABLE_SCHEMA_VERSION = 43;
+
+async function assertAnnotationsRemoved(db, expectedAnnos) {
+  for (let anno of expectedAnnos) {
+    let rows = await db.execute(
+      `
+      SELECT id FROM moz_anno_attributes
+      WHERE name = :anno
+    `,
+      { anno }
+    );
+
+    Assert.equal(rows.length, 0, `${anno} should not exist in the database`);
+  }
+}
+
+async function assertNoOrphanAnnotations(db) {
+  let rows = await db.execute(`
+    SELECT item_id FROM moz_items_annos
+    WHERE item_id NOT IN (SELECT id from moz_bookmarks)
+  `);
+
+  Assert.equal(rows.length, 0, `Should have no orphan annotations.`);
+
+  rows = await db.execute(`
+    SELECT id FROM moz_anno_attributes
+    WHERE id NOT IN (SELECT id from moz_items_annos)
+  `);
+
+  Assert.equal(rows.length, 0, `Should have no orphan annotation attributes.`);
+}
diff --git a/toolkit/components/places/tests/migration/places_outdated.sqlite b/toolkit/components/places/tests/migration/places_outdated.sqlite
new file mode 100644
index 0000000000..2852a4cf97
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_outdated.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v43.sqlite b/toolkit/components/places/tests/migration/places_v43.sqlite
new file mode 100644
index 0000000000..9210f215fa
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v43.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v54.sqlite b/toolkit/components/places/tests/migration/places_v54.sqlite
new file mode 100644
index 0000000000..a203b28c10
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v54.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v66.sqlite b/toolkit/components/places/tests/migration/places_v66.sqlite
new file mode 100644
index 0000000000..9578ee11e6
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v66.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v68.sqlite b/toolkit/components/places/tests/migration/places_v68.sqlite
new file mode 100644
index 0000000000..414fa170ec
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v68.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v69.sqlite b/toolkit/components/places/tests/migration/places_v69.sqlite
new file mode 100644
index 0000000000..bc3053c18e
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v69.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v70.sqlite b/toolkit/components/places/tests/migration/places_v70.sqlite
new file mode 100644
index 0000000000..907e7f5046
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v70.sqlite
diff --git a/toolkit/components/places/tests/migration/places_v71.sqlite b/toolkit/components/places/tests/migration/places_v71.sqlite
new file mode 100644
index 0000000000..8039b1dd6a
--- /dev/null
+++ b/toolkit/components/places/tests/migration/places_v71.sqlite
diff --git a/toolkit/components/places/tests/migration/test_current_from_downgraded.js b/toolkit/components/places/tests/migration/test_current_from_downgraded.js
new file mode 100644
index 0000000000..5daec14e2f
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_downgraded.js
@@ -0,0 +1,29 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// This test ensures we can pass twice through migration methods without
+// failing, that is what happens in case of a downgrade followed by an upgrade.
+
+add_task(async function setup() {
+  let dbFile = PathUtils.join(
+    do_get_cwd().path,
+    `places_v${CURRENT_SCHEMA_VERSION}.sqlite`
+  );
+  Assert.ok(await IOUtils.exists(dbFile));
+  await setupPlacesDatabase(`places_v${CURRENT_SCHEMA_VERSION}.sqlite`);
+  // Downgrade the schema version to the first supported one.
+  let path = PathUtils.join(PathUtils.profileDir, DB_FILENAME);
+  let db = await Sqlite.openConnection({ path });
+  await db.setSchemaVersion(FIRST_UPGRADABLE_SCHEMA_VERSION);
+  await db.close();
+});
+
+add_task(async function database_is_valid() {
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_UPGRADED
+  );
+
+  let db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), CURRENT_SCHEMA_VERSION);
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_outdated.js b/toolkit/components/places/tests/migration/test_current_from_outdated.js
new file mode 100644
index 0000000000..e7fad5b3a4
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_outdated.js
@@ -0,0 +1,47 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * This file tests migration from a preliminary schema version 6 that
+ * lacks frecency column and moz_inputhistory table.
+ */
+
+add_task(async function setup() {
+  await setupPlacesDatabase("places_outdated.sqlite");
+});
+
+add_task(async function corrupt_database_not_exists() {
+  let corruptPath = PathUtils.join(
+    PathUtils.profileDir,
+    "places.sqlite.corrupt"
+  );
+  Assert.ok(
+    !(await IOUtils.exists(corruptPath)),
+    "Corrupt file should not exist"
+  );
+});
+
+add_task(async function database_is_valid() {
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_CORRUPT
+  );
+
+  let db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(async function check_columns() {
+  // Check the database has been replaced, these would throw otherwise.
+  let db = await PlacesUtils.promiseDBConnection();
+  await db.execute("SELECT frecency from moz_places");
+  await db.execute("SELECT 1 from moz_inputhistory");
+});
+
+add_task(async function corrupt_database_exists() {
+  let corruptPath = PathUtils.join(
+    PathUtils.profileDir,
+    "places.sqlite.corrupt"
+  );
+  Assert.ok(await IOUtils.exists(corruptPath), "Corrupt file should exist");
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v43.js b/toolkit/components/places/tests/migration/test_current_from_v43.js
new file mode 100644
index 0000000000..70a383bb2e
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v43.js
@@ -0,0 +1,253 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const EXPECTED_REMAINING_ROOTS = [
+  ...PlacesUtils.bookmarks.userContentRoots,
+  PlacesUtils.bookmarks.tagsGuid,
+];
+
+const EXPECTED_REMOVED_BOOKMARK_GUIDS = [
+  // These first ones are the old left-pane folder queries
+  "SNLmwJH6GtW9", // Root Query
+  "r0dY_2_y4mlx", // History
+  "xGGhZK3b6GnW", // Downloads
+  "EJG6I1nKkQFQ", // Tags
+  "gSyHo5oNSUJV", // All Bookmarks
+  // These are simulated add-on injections that we expect to be removed.
+  "exaddon_____",
+  "exaddon1____",
+  "exaddon2____",
+  "exaddon3____",
+  "test________",
+];
+
+const EXPECTED_REMOVED_ANNOTATIONS = [
+  "PlacesOrganizer/OrganizerFolder",
+  "PlacesOrganizer/OrganizerQuery",
+];
+
+const EXPECTED_REMOVED_PLACES_ENTRIES = ["exaddonh____", "exaddonh3___"];
+const EXPECTED_KEPT_PLACES_ENTRY = "exaddonh2___";
+const EXPECTED_REMOVED_KEYWORDS = ["exaddon", "exaddon2"];
+
+async function assertItemIn(db, table, field, expectedItems) {
+  let rows = await db.execute(`SELECT ${field} from ${table}`);
+
+  Assert.ok(
+    rows.length >= expectedItems.length,
+    "Should be at least the number of annotations we expect to be removed."
+  );
+
+  let fieldValues = rows.map(row => row.getResultByName(field));
+
+  for (let item of expectedItems) {
+    Assert.ok(
+      fieldValues.includes(item),
+      `${table} should have ${expectedItems}`
+    );
+  }
+}
+
+add_task(async function setup() {
+  await setupPlacesDatabase("places_v43.sqlite");
+
+  // Setup database contents to be migrated.
+  let path = PathUtils.join(PathUtils.profileDir, DB_FILENAME);
+  let db = await Sqlite.openConnection({ path });
+
+  let rows = await db.execute(`SELECT * FROM moz_bookmarks_deleted`);
+  Assert.equal(rows.length, 0, "Should be nothing in moz_bookmarks_deleted");
+
+  // Break roots parenting, to test for Bug 1472127.
+  await db.execute(`INSERT INTO moz_bookmarks (title, parent, position, guid)
+                    VALUES ("test", 1, 0, "test________")`);
+  await db.execute(`UPDATE moz_bookmarks
+                    SET parent = (SELECT id FROM moz_bookmarks WHERE guid = "test________")
+                    WHERE guid = "menu________"`);
+
+  await assertItemIn(
+    db,
+    "moz_anno_attributes",
+    "name",
+    EXPECTED_REMOVED_ANNOTATIONS
+  );
+  await assertItemIn(
+    db,
+    "moz_bookmarks",
+    "guid",
+    EXPECTED_REMOVED_BOOKMARK_GUIDS
+  );
+  await assertItemIn(db, "moz_keywords", "keyword", EXPECTED_REMOVED_KEYWORDS);
+  await assertItemIn(db, "moz_places", "guid", EXPECTED_REMOVED_PLACES_ENTRIES);
+
+  await db.close();
+});
+
+add_task(async function database_is_valid() {
+  // Accessing the database for the first time triggers migration.
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_UPGRADED
+  );
+
+  let db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(async function test_roots_removed() {
+  let db = await PlacesUtils.promiseDBConnection();
+  let rows = await db.execute(
+    `
+    SELECT id FROM moz_bookmarks
+    WHERE guid = :guid
+  `,
+    { guid: PlacesUtils.bookmarks.rootGuid }
+  );
+  Assert.equal(rows.length, 1, "Should have exactly one root row.");
+  let rootId = rows[0].getResultByName("id");
+
+  rows = await db.execute(
+    `
+    SELECT guid FROM moz_bookmarks
+    WHERE parent = :rootId`,
+    { rootId }
+  );
+
+  Assert.equal(
+    rows.length,
+    EXPECTED_REMAINING_ROOTS.length,
+    "Should only have the built-in folder roots."
+  );
+
+  for (let row of rows) {
+    let guid = row.getResultByName("guid");
+    Assert.ok(
+      EXPECTED_REMAINING_ROOTS.includes(guid),
+      `Should have only the expected guids remaining, unexpected guid: ${guid}`
+    );
+  }
+
+  // Check the reparented menu now.
+  rows = await db.execute(
+    `
+    SELECT id, parent FROM moz_bookmarks
+    WHERE guid = :guid
+  `,
+    { guid: PlacesUtils.bookmarks.menuGuid }
+  );
+  Assert.equal(rows.length, 1, "Should have found the menu root.");
+  Assert.equal(
+    rows[0].getResultByName("parent"),
+    await PlacesUtils.promiseItemId(PlacesUtils.bookmarks.rootGuid),
+    "Should have moved the menu back to the Places root."
+  );
+});
+
+add_task(async function test_tombstones_added() {
+  let db = await PlacesUtils.promiseDBConnection();
+
+  let rows = await db.execute(`
+    SELECT guid FROM moz_bookmarks_deleted
+  `);
+
+  for (let row of rows) {
+    let guid = row.getResultByName("guid");
+    Assert.ok(
+      EXPECTED_REMOVED_BOOKMARK_GUIDS.includes(guid),
+      `Should have tombstoned the expected guids, unexpected guid: ${guid}`
+    );
+  }
+
+  Assert.equal(
+    rows.length,
+    EXPECTED_REMOVED_BOOKMARK_GUIDS.length,
+    "Should have removed all the expected bookmarks."
+  );
+});
+
+add_task(async function test_annotations_removed() {
+  let db = await PlacesUtils.promiseDBConnection();
+
+  await assertAnnotationsRemoved(db, EXPECTED_REMOVED_ANNOTATIONS);
+});
+
+add_task(async function test_check_history_entries() {
+  let db = await PlacesUtils.promiseDBConnection();
+
+  for (let entry of EXPECTED_REMOVED_PLACES_ENTRIES) {
+    let rows = await db.execute(`
+      SELECT id FROM moz_places
+      WHERE guid = '${entry}'`);
+
+    Assert.equal(
+      rows.length,
+      0,
+      `Should have removed an orphaned history entry ${EXPECTED_REMOVED_PLACES_ENTRIES}.`
+    );
+  }
+
+  let rows = await db.execute(
+    `
+    SELECT foreign_count FROM moz_places
+    WHERE guid = :guid
+  `,
+    { guid: EXPECTED_KEPT_PLACES_ENTRY }
+  );
+
+  Assert.equal(
+    rows.length,
+    1,
+    `Should have kept visited history entry ${EXPECTED_KEPT_PLACES_ENTRY}`
+  );
+
+  let foreignCount = rows[0].getResultByName("foreign_count");
+  Assert.equal(
+    foreignCount,
+    0,
+    `Should have updated the foreign_count for ${EXPECTED_KEPT_PLACES_ENTRY}`
+  );
+});
+
+add_task(async function test_check_keyword_removed() {
+  let db = await PlacesUtils.promiseDBConnection();
+
+  for (let keyword of EXPECTED_REMOVED_KEYWORDS) {
+    let rows = await db.execute(
+      `
+      SELECT keyword FROM moz_keywords
+      WHERE keyword = :keyword
+    `,
+      { keyword }
+    );
+
+    Assert.equal(
+      rows.length,
+      0,
+      `Should have removed the expected keyword: ${keyword}.`
+    );
+  }
+});
+
+add_task(async function test_no_orphan_annotations() {
+  let db = await PlacesUtils.promiseDBConnection();
+
+  await assertNoOrphanAnnotations(db);
+});
+
+add_task(async function test_no_orphan_keywords() {
+  let db = await PlacesUtils.promiseDBConnection();
+
+  let rows = await db.execute(`
+    SELECT place_id FROM moz_keywords
+    WHERE place_id NOT IN (SELECT id from moz_places)
+  `);
+
+  Assert.equal(rows.length, 0, `Should have no orphan keywords.`);
+});
+
+add_task(async function test_meta_exists() {
+  let db = await PlacesUtils.promiseDBConnection();
+  await db.execute(`SELECT 1 FROM moz_meta`);
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v45.js b/toolkit/components/places/tests/migration/test_current_from_v45.js
new file mode 100644
index 0000000000..af940d75d4
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v45.js
@@ -0,0 +1,100 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+let gTags = [
+  {
+    folder: 123456,
+    url: "place:folder=123456&type=7&queryType=1",
+    title: "tag1",
+    hash: "268505532566465",
+  },
+  {
+    folder: 234567,
+    url: "place:folder=234567&type=7&queryType=1&somethingelse",
+    title: "tag2",
+    hash: "268506675127932",
+  },
+  {
+    folder: 345678,
+    url: "place:type=7&folder=345678&queryType=1",
+    title: "tag3",
+    hash: "268506471927988",
+  },
+  // This will point to an invalid folder id.
+  {
+    folder: 456789,
+    url: "place:type=7&folder=456789&queryType=1",
+    expectedUrl:
+      "place:type=7&invalidOldParentId=456789&queryType=1&excludeItems=1",
+    title: "invalid",
+    hash: "268505972797836",
+  },
+];
+gTags.forEach(t => (t.guid = t.title.padEnd(12, "_")));
+
+add_task(async function setup() {
+  await setupPlacesDatabase("places_v43.sqlite");
+
+  // Setup database contents to be migrated.
+  let path = PathUtils.join(PathUtils.profileDir, DB_FILENAME);
+  let db = await Sqlite.openConnection({ path });
+
+  for (let tag of gTags) {
+    // We can reuse the same guid, it doesn't matter for this test.
+    await db.execute(
+      `INSERT INTO moz_places (url, guid, url_hash)
+                      VALUES (:url, :guid, :hash)
+                     `,
+      { url: tag.url, guid: tag.guid, hash: tag.hash }
+    );
+    if (tag.title != "invalid") {
+      await db.execute(
+        `INSERT INTO moz_bookmarks (id, fk, guid, title)
+                      VALUES (:id, (SELECT id FROM moz_places WHERE guid = :guid), :guid, :title)
+                      `,
+        { id: tag.folder, guid: tag.guid, title: tag.title }
+      );
+    }
+  }
+
+  await db.close();
+});
+
+add_task(async function database_is_valid() {
+  // Accessing the database for the first time triggers migration.
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_UPGRADED
+  );
+
+  let db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(async function test_queries_converted() {
+  for (let tag of gTags) {
+    let url =
+      tag.title == "invalid" ? tag.expectedUrl : "place:tag=" + tag.title;
+    let page = await PlacesUtils.history.fetch(tag.guid);
+    Assert.equal(page.url.href, url);
+  }
+});
+
+add_task(async function test_sync_fields() {
+  let db = await PlacesUtils.promiseDBConnection();
+  for (let tag of gTags) {
+    if (tag.title != "invalid") {
+      let rows = await db.execute(
+        `
+        SELECT syncChangeCounter
+        FROM moz_bookmarks
+        WHERE guid = :guid
+      `,
+        { guid: tag.guid }
+      );
+      Assert.equal(rows[0].getResultByIndex(0), 2);
+    }
+  }
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v46.js b/toolkit/components/places/tests/migration/test_current_from_v46.js
new file mode 100644
index 0000000000..a613a3027e
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v46.js
@@ -0,0 +1,52 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+let guid = "null".padEnd(12, "_");
+
+add_task(async function setup() {
+  await setupPlacesDatabase("places_v43.sqlite");
+
+  // Setup database contents to be migrated.
+  let path = PathUtils.join(PathUtils.profileDir, DB_FILENAME);
+  let db = await Sqlite.openConnection({ path });
+  // We can reuse the same guid, it doesn't matter for this test.
+
+  await db.execute(
+    `INSERT INTO moz_places (url, guid, url_hash)
+                    VALUES (NULL, :guid, "123456")`,
+    { guid }
+  );
+  await db.execute(
+    `INSERT INTO moz_bookmarks (fk, guid)
+                    VALUES ((SELECT id FROM moz_places WHERE guid = :guid), :guid)
+                    `,
+    { guid }
+  );
+  await db.close();
+});
+
+add_task(async function database_is_valid() {
+  // Accessing the database for the first time triggers migration.
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_UPGRADED
+  );
+
+  let db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), CURRENT_SCHEMA_VERSION);
+
+  let page = await PlacesUtils.history.fetch(guid);
+  Assert.equal(page.url.href, "place:excludeItems=1");
+
+  let rows = await db.execute(
+    `
+    SELECT syncChangeCounter
+    FROM moz_bookmarks
+    WHERE guid = :guid
+  `,
+    { guid }
+  );
+  Assert.equal(rows[0].getResultByIndex(0), 2);
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v47.js b/toolkit/components/places/tests/migration/test_current_from_v47.js
new file mode 100644
index 0000000000..b3d5f47211
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v47.js
@@ -0,0 +1,128 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function setup() {
+  await setupPlacesDatabase("places_v43.sqlite");
+});
+
+// Accessing the database for the first time should trigger migration, and the
+// schema version should be updated.
+add_task(async function database_is_valid() {
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_UPGRADED
+  );
+
+  let db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), CURRENT_SCHEMA_VERSION);
+
+  // Now wait for moz_origins.frecency to be populated before continuing with
+  // other test tasks.
+  await TestUtils.waitForCondition(
+    () => {
+      return !Services.prefs.getBoolPref(
+        "places.database.migrateV52OriginFrecencies",
+        false
+      );
+    },
+    "Waiting for v52 origin frecencies to be migrated",
+    100,
+    3000
+  );
+});
+
+// moz_origins should be populated.
+add_task(async function test_origins() {
+  let db = await PlacesUtils.promiseDBConnection();
+
+  // Collect origins.
+  let rows = await db.execute(`
+    SELECT id, prefix, host, frecency
+    FROM moz_origins
+    ORDER BY id ASC;
+  `);
+  Assert.notEqual(rows.length, 0);
+  let origins = rows.map(r => ({
+    id: r.getResultByName("id"),
+    prefix: r.getResultByName("prefix"),
+    host: r.getResultByName("host"),
+    frecency: r.getResultByName("frecency"),
+  }));
+
+  // Get moz_places.
+  rows = await db.execute(`
+    SELECT get_prefix(url) AS prefix, get_host_and_port(url) AS host,
+           origin_id, frecency
+    FROM moz_places;
+  `);
+  Assert.notEqual(rows.length, 0);
+
+  let seenOriginIDs = [];
+  let frecenciesByOriginID = {};
+
+  // Make sure moz_places.origin_id refers to the right origins.
+  for (let row of rows) {
+    let originID = row.getResultByName("origin_id");
+    let origin = origins.find(o => o.id == originID);
+    Assert.ok(origin);
+    Assert.equal(origin.prefix, row.getResultByName("prefix"));
+    Assert.equal(origin.host, row.getResultByName("host"));
+
+    seenOriginIDs.push(originID);
+
+    let frecency = row.getResultByName("frecency");
+    frecenciesByOriginID[originID] = frecenciesByOriginID[originID] || 0;
+    frecenciesByOriginID[originID] += frecency;
+  }
+
+  for (let origin of origins) {
+    // Make sure each origin corresponds to at least one moz_place.
+    Assert.ok(seenOriginIDs.includes(origin.id));
+
+    // moz_origins.frecency should be the sum of frecencies of all moz_places
+    // with the origin.
+    Assert.equal(origin.frecency, frecenciesByOriginID[origin.id]);
+  }
+
+  // Make sure moz_hosts was emptied.
+  rows = await db.execute(`
+    SELECT *
+    FROM moz_hosts;
+  `);
+  Assert.equal(rows.length, 0);
+});
+
+// Frecency stats should have been collected.
+add_task(async function test_frecency_stats() {
+  let db = await PlacesUtils.promiseDBConnection();
+
+  // Collect positive frecencies from moz_origins.
+  let rows = await db.execute(`
+    SELECT frecency FROM moz_origins WHERE frecency > 0
+  `);
+  Assert.notEqual(rows.length, 0);
+  let frecencies = rows.map(r => r.getResultByName("frecency"));
+
+  // Collect stats.
+  rows = await db.execute(`
+    SELECT
+      (SELECT value FROM moz_meta WHERE key = "origin_frecency_count"),
+      (SELECT value FROM moz_meta WHERE key = "origin_frecency_sum"),
+      (SELECT value FROM moz_meta WHERE key = "origin_frecency_sum_of_squares")
+  `);
+  let count = rows[0].getResultByIndex(0);
+  let sum = rows[0].getResultByIndex(1);
+  let squares = rows[0].getResultByIndex(2);
+
+  Assert.equal(count, frecencies.length);
+  Assert.equal(
+    sum,
+    frecencies.reduce((memo, f) => memo + f, 0)
+  );
+  Assert.equal(
+    squares,
+    frecencies.reduce((memo, f) => memo + f * f, 0)
+  );
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v48.js b/toolkit/components/places/tests/migration/test_current_from_v48.js
new file mode 100644
index 0000000000..f2c7c683ed
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v48.js
@@ -0,0 +1,190 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const gCreatedParentGuid = "m47___FOLDER";
+
+const gTestItems = [
+  {
+    // Folder shortcuts to built-in folders.
+    guid: "m47_____ROOT",
+    url: "place:folder=PLACES_ROOT",
+    targetParentGuid: "rootGuid",
+  },
+  {
+    guid: "m47_____MENU",
+    url: "place:folder=BOOKMARKS_MENU",
+    targetParentGuid: "menuGuid",
+  },
+  {
+    guid: "m47_____TAGS",
+    url: "place:folder=TAGS",
+    targetParentGuid: "tagsGuid",
+  },
+  {
+    guid: "m47____OTHER",
+    url: "place:folder=UNFILED_BOOKMARKS",
+    targetParentGuid: "unfiledGuid",
+  },
+  {
+    guid: "m47__TOOLBAR",
+    url: "place:folder=TOOLBAR",
+    targetParentGuid: "toolbarGuid",
+  },
+  {
+    guid: "m47___MOBILE",
+    url: "place:folder=MOBILE_BOOKMARKS",
+    targetParentGuid: "mobileGuid",
+  },
+  {
+    // Folder shortcut to using id.
+    guid: "m47_______ID",
+    url: "place:folder=%id%",
+    expectedUrl: "place:parent=%guid%",
+  },
+  {
+    // Folder shortcut to multiple folders.
+    guid: "m47____MULTI",
+    url: "place:folder=TOOLBAR&folder=%id%&sort=1",
+    expectedUrl: "place:parent=%toolbarGuid%&parent=%guid%&sort=1",
+  },
+  {
+    // Folder shortcut to non-existent folder.
+    guid: "m47______NON",
+    url: "place:folder=454554545",
+    expectedUrl: "place:invalidOldParentId=454554545&excludeItems=1",
+  },
+];
+
+add_task(async function setup() {
+  await setupPlacesDatabase("places_v43.sqlite");
+
+  // Setup database contents to be migrated.
+  let path = PathUtils.join(PathUtils.profileDir, DB_FILENAME);
+  let db = await Sqlite.openConnection({ path });
+
+  let rows = await db.execute(
+    `SELECT id FROM moz_bookmarks
+                               WHERE guid = :guid`,
+    { guid: PlacesUtils.bookmarks.unfiledGuid }
+  );
+
+  let unfiledId = rows[0].getResultByName("id");
+
+  // Insert a test folder.
+  await db.execute(
+    `INSERT INTO moz_bookmarks (guid, title, parent)
+                    VALUES (:guid, "Folder", :parent)`,
+    { guid: gCreatedParentGuid, parent: unfiledId }
+  );
+
+  rows = await db.execute(
+    `SELECT id FROM moz_bookmarks
+                           WHERE guid = :guid`,
+    { guid: gCreatedParentGuid }
+  );
+
+  let createdFolderId = rows[0].getResultByName("id");
+
+  for (let item of gTestItems) {
+    item.url = item.url.replace("%id%", createdFolderId);
+
+    // We can reuse the same guid, it doesn't matter for this test.
+    await db.execute(
+      `INSERT INTO moz_places (url, guid, url_hash)
+                      VALUES (:url, :guid, :hash)
+                     `,
+      {
+        url: item.url,
+        guid: item.guid,
+        hash: PlacesUtils.history.hashURL(item.url),
+      }
+    );
+    await db.execute(
+      `INSERT INTO moz_bookmarks (id, fk, guid, title, parent)
+                      VALUES (:id, (SELECT id FROM moz_places WHERE guid = :guid),
+                              :guid, :title,
+                              (SELECT id FROM moz_bookmarks WHERE guid = :parentGuid))
+                    `,
+      {
+        id: item.folder,
+        guid: item.guid,
+        parentGuid: PlacesUtils.bookmarks.unfiledGuid,
+        title: item.guid,
+      }
+    );
+  }
+
+  await db.close();
+});
+
+add_task(async function database_is_valid() {
+  // Accessing the database for the first time triggers migration.
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_UPGRADED
+  );
+
+  let db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(async function test_correct_folder_queries() {
+  for (let item of gTestItems) {
+    let bm = await PlacesUtils.bookmarks.fetch(item.guid);
+
+    if (item.targetParentGuid) {
+      Assert.equal(
+        bm.url,
+        `place:parent=${PlacesUtils.bookmarks[item.targetParentGuid]}`,
+        `Should have updated the URL for ${item.guid}`
+      );
+    } else {
+      let expected = item.expectedUrl
+        .replace("%guid%", gCreatedParentGuid)
+        .replace("%toolbarGuid%", PlacesUtils.bookmarks.toolbarGuid);
+
+      Assert.equal(
+        bm.url,
+        expected,
+        `Should have updated the URL for ${item.guid}`
+      );
+    }
+  }
+});
+
+add_task(async function test_hashes_valid() {
+  let db = await PlacesUtils.promiseDBConnection();
+  // Ensure all the hashes in moz_places are valid.
+  let rows = await db.execute(`SELECT url, url_hash FROM moz_places`);
+
+  for (let row of rows) {
+    let url = row.getResultByName("url");
+    let url_hash = row.getResultByName("url_hash");
+    Assert.equal(
+      url_hash,
+      PlacesUtils.history.hashURL(url),
+      `url hash should be correct for ${url}`
+    );
+  }
+});
+
+add_task(async function test_sync_counters_updated() {
+  let db = await PlacesUtils.promiseDBConnection();
+
+  for (let test of gTestItems) {
+    let rows = await db.execute(
+      `SELECT syncChangeCounter FROM moz_bookmarks
+                                 WHERE guid = :guid`,
+      { guid: test.guid }
+    );
+
+    Assert.equal(rows.length, 1, `Should only be one record for ${test.guid}`);
+    Assert.equal(
+      rows[0].getResultByName("syncChangeCounter"),
+      2,
+      `Should have bumped the syncChangeCounter for ${test.guid}`
+    );
+  }
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v50.js b/toolkit/components/places/tests/migration/test_current_from_v50.js
new file mode 100644
index 0000000000..af181091c0
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v50.js
@@ -0,0 +1,209 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const BASE_GUID = "null".padEnd(11, "_");
+const LAST_USED_ANNO = "bookmarkPropertiesDialog/folderLastUsed";
+const LAST_USED_META_DATA = "places/bookmarks/edit/lastusedfolder";
+
+let expectedGuids = [];
+
+async function adjustIndices(db, itemGuid) {
+  await db.execute(
+    `
+    UPDATE moz_bookmarks SET
+      position = position - 1
+    WHERE parent = (SELECT parent FROM moz_bookmarks
+                    WHERE guid = :itemGuid) AND
+          position >= (SELECT position FROM moz_bookmarks
+                       WHERE guid = :itemGuid)`,
+    { itemGuid }
+  );
+}
+
+async function fetchChildInfos(db, parentGuid) {
+  let rows = await db.execute(
+    `
+    SELECT b.guid, b.position, b.syncChangeCounter
+    FROM moz_bookmarks b
+    JOIN moz_bookmarks p ON p.id = b.parent
+    WHERE p.guid = :parentGuid
+    ORDER BY b.position`,
+    { parentGuid }
+  );
+  return rows.map(row => ({
+    guid: row.getResultByName("guid"),
+    position: row.getResultByName("position"),
+    syncChangeCounter: row.getResultByName("syncChangeCounter"),
+  }));
+}
+
+add_task(async function setup() {
+  await setupPlacesDatabase("places_v43.sqlite");
+
+  // Setup database contents to be migrated.
+  let path = PathUtils.join(PathUtils.profileDir, DB_FILENAME);
+  let db = await Sqlite.openConnection({ path });
+  // We can reuse the same guid, it doesn't matter for this test.
+  await db.execute(
+    `INSERT INTO moz_anno_attributes (name)
+                    VALUES (:last_used_anno)`,
+    { last_used_anno: LAST_USED_ANNO }
+  );
+
+  for (let i = 0; i < 3; i++) {
+    let guid = `${BASE_GUID}${i}`;
+    await db.execute(
+      `INSERT INTO moz_bookmarks (guid, type)
+                      VALUES (:guid, :type)
+                      `,
+      { guid, type: PlacesUtils.bookmarks.TYPE_FOLDER }
+    );
+    await db.execute(
+      `INSERT INTO moz_items_annos (item_id, anno_attribute_id, content)
+                      VALUES ((SELECT id FROM moz_bookmarks WHERE guid = :guid),
+                              (SELECT id FROM moz_anno_attributes WHERE name = :last_used_anno),
+                              :content)`,
+      {
+        guid,
+        content: new Date(1517318477569) - (3 - i) * 60 * 60 * 1000,
+        last_used_anno: LAST_USED_ANNO,
+      }
+    );
+    expectedGuids.unshift(guid);
+  }
+
+  info("Move menu into unfiled");
+  await adjustIndices(db, "menu________");
+  await db.execute(
+    `
+    UPDATE moz_bookmarks SET
+      parent = (SELECT id FROM moz_bookmarks WHERE guid = :newParentGuid),
+      position = IFNULL((SELECT MAX(position) + 1 FROM moz_bookmarks
+                         WHERE guid = :newParentGuid), 0)
+    WHERE guid = :itemGuid`,
+    { newParentGuid: "unfiled_____", itemGuid: "menu________" }
+  );
+
+  info("Move toolbar into mobile");
+  let mobileChildren = [
+    "bookmarkAAAA",
+    "bookmarkBBBB",
+    "toolbar_____",
+    "bookmarkCCCC",
+    "bookmarkDDDD",
+  ];
+  await adjustIndices(db, "toolbar_____");
+  for (let position = 0; position < mobileChildren.length; position++) {
+    await db.execute(
+      `
+      INSERT INTO moz_bookmarks(guid, parent, position)
+      VALUES(:guid, (SELECT id FROM moz_bookmarks WHERE guid = 'mobile______'),
+             :position)
+      ON CONFLICT(guid) DO UPDATE SET
+        parent = excluded.parent,
+        position = excluded.position`,
+      { guid: mobileChildren[position], position }
+    );
+  }
+
+  info("Reset Sync change counters");
+  await db.execute(`UPDATE moz_bookmarks SET syncChangeCounter = 0`);
+
+  await db.close();
+});
+
+add_task(async function database_is_valid() {
+  // Accessing the database for the first time triggers migration.
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_UPGRADED
+  );
+
+  let db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(async function test_folders_migrated() {
+  let metaData = await PlacesUtils.metadata.get(LAST_USED_META_DATA);
+
+  Assert.deepEqual(JSON.parse(metaData), expectedGuids);
+});
+
+add_task(async function test_annotations_removed() {
+  let db = await PlacesUtils.promiseDBConnection();
+
+  await assertAnnotationsRemoved(db, [LAST_USED_ANNO]);
+});
+
+add_task(async function test_no_orphan_annotations() {
+  let db = await PlacesUtils.promiseDBConnection();
+
+  await assertNoOrphanAnnotations(db);
+});
+
+add_task(async function test_roots_fixed() {
+  let db = await PlacesUtils.promiseDBConnection();
+
+  let expectedRootInfos = [
+    {
+      guid: PlacesUtils.bookmarks.tagsGuid,
+      position: 0,
+      syncChangeCounter: 0,
+    },
+    {
+      guid: PlacesUtils.bookmarks.unfiledGuid,
+      position: 1,
+      syncChangeCounter: 1,
+    },
+    {
+      guid: PlacesUtils.bookmarks.mobileGuid,
+      position: 2,
+      syncChangeCounter: 1,
+    },
+    {
+      guid: PlacesUtils.bookmarks.menuGuid,
+      position: 3,
+      syncChangeCounter: 1,
+    },
+    {
+      guid: PlacesUtils.bookmarks.toolbarGuid,
+      position: 4,
+      syncChangeCounter: 1,
+    },
+  ];
+  Assert.deepEqual(
+    expectedRootInfos,
+    await fetchChildInfos(db, PlacesUtils.bookmarks.rootGuid),
+    "All roots should be reparented to the Places root"
+  );
+
+  let expectedMobileInfos = [
+    {
+      guid: "bookmarkAAAA",
+      position: 0,
+      syncChangeCounter: 0,
+    },
+    {
+      guid: "bookmarkBBBB",
+      position: 1,
+      syncChangeCounter: 0,
+    },
+    {
+      guid: "bookmarkCCCC",
+      position: 2,
+      syncChangeCounter: 0,
+    },
+    {
+      guid: "bookmarkDDDD",
+      position: 3,
+      syncChangeCounter: 0,
+    },
+  ];
+  Assert.deepEqual(
+    expectedMobileInfos,
+    await fetchChildInfos(db, PlacesUtils.bookmarks.mobileGuid),
+    "Should fix misparented root sibling positions"
+  );
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v53.js b/toolkit/components/places/tests/migration/test_current_from_v53.js
new file mode 100644
index 0000000000..f872dea5d5
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v53.js
@@ -0,0 +1,23 @@
+add_task(async function setup() {
+  // Since this migration doesn't affect places.sqlite, we can reuse v43.
+  await setupPlacesDatabase("places_v43.sqlite");
+  await setupPlacesDatabase("favicons_v41.sqlite", "favicons.sqlite");
+});
+
+add_task(async function database_is_valid() {
+  // Accessing the database for the first time triggers migration.
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_UPGRADED
+  );
+
+  let db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), CURRENT_SCHEMA_VERSION);
+
+  let count = (
+    await db.execute(
+      `SELECT count(*) FROM moz_icons_to_pages WHERE expire_ms = 0`
+    )
+  )[0].getResultByIndex(0);
+  Assert.equal(count, 0, "All the expirations should be set");
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v54.js b/toolkit/components/places/tests/migration/test_current_from_v54.js
new file mode 100644
index 0000000000..94c8a26474
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v54.js
@@ -0,0 +1,58 @@
+add_task(async function setup() {
+  // Since this migration doesn't affect places.sqlite, we can reuse v43.
+  await setupPlacesDatabase("places_v54.sqlite");
+  await setupPlacesDatabase("favicons_v41.sqlite", "favicons.sqlite");
+});
+
+add_task(async function database_is_valid() {
+  // Accessing the database for the first time triggers migration.
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_UPGRADED
+  );
+
+  let db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), CURRENT_SCHEMA_VERSION);
+
+  for (let table of [
+    "moz_places_metadata",
+    "moz_places_metadata_search_queries",
+  ]) {
+    let count = (
+      await db.execute(`SELECT count(*) FROM ${table}`)
+    )[0].getResultByIndex(0);
+    Assert.equal(count, 0, `Empty table ${table}`);
+  }
+
+  for (let table of [
+    "moz_places_metadata_snapshots",
+    "moz_places_metadata_snapshots_extra",
+    "moz_places_metadata_snapshots_groups",
+    "moz_places_metadata_groups_to_snapshots",
+    "moz_session_metadata",
+    "moz_session_to_places",
+  ]) {
+    await Assert.rejects(
+      db.execute(`SELECT count(*) FROM ${table}`),
+      /no such table/,
+      `Table ${table} should not exist`
+    );
+  }
+});
+
+add_task(async function scrolling_fields_in_database() {
+  let db = await PlacesUtils.promiseDBConnection();
+  await db.execute(
+    `SELECT scrolling_time,scrolling_distance FROM moz_places_metadata`
+  );
+});
+
+add_task(async function site_name_field_in_database() {
+  let db = await PlacesUtils.promiseDBConnection();
+  await db.execute(`SELECT site_name FROM moz_places`);
+});
+
+add_task(async function previews_tombstones_in_database() {
+  let db = await PlacesUtils.promiseDBConnection();
+  await db.execute(`SELECT hash FROM moz_previews_tombstones`);
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v66.js b/toolkit/components/places/tests/migration/test_current_from_v66.js
new file mode 100644
index 0000000000..5ea14f3b9d
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v66.js
@@ -0,0 +1,53 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function setup() {
+  const path = await setupPlacesDatabase("places_v66.sqlite");
+
+  const db = await Sqlite.openConnection({ path });
+  await db.execute(`
+    INSERT INTO moz_inputhistory (input, use_count, place_id)
+    VALUES
+      ('abc', 1, 1),
+      ('aBc', 0.9, 1),
+      ('ABC', 5, 1),
+      ('ABC', 1, 2),
+      ('DEF', 1, 3)
+  `);
+  await db.close();
+});
+
+add_task(async function database_is_valid() {
+  // Accessing the database for the first time triggers migration.
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_UPGRADED
+  );
+
+  let db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(async function moz_inputhistory() {
+  await PlacesUtils.withConnectionWrapper("test_sqlite_migration", async db => {
+    const rows = await db.execute(
+      "SELECT * FROM moz_inputhistory ORDER BY place_id"
+    );
+
+    Assert.equal(rows.length, 3);
+
+    Assert.equal(rows[0].getResultByName("place_id"), 1);
+    Assert.equal(rows[0].getResultByName("input"), "abc");
+    Assert.equal(rows[0].getResultByName("use_count"), 5);
+
+    Assert.equal(rows[1].getResultByName("place_id"), 2);
+    Assert.equal(rows[1].getResultByName("input"), "abc");
+    Assert.equal(rows[1].getResultByName("use_count"), 1);
+
+    Assert.equal(rows[2].getResultByName("place_id"), 3);
+    Assert.equal(rows[2].getResultByName("input"), "def");
+    Assert.equal(rows[2].getResultByName("use_count"), 1);
+  });
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v68.js b/toolkit/components/places/tests/migration/test_current_from_v68.js
new file mode 100644
index 0000000000..689fcbfd40
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v68.js
@@ -0,0 +1,35 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function setup() {
+  const path = await setupPlacesDatabase("places_v68.sqlite");
+
+  const db = await Sqlite.openConnection({ path });
+  await db.execute("INSERT INTO moz_historyvisits (from_visit) VALUES (-1)");
+  await db.close();
+});
+
+add_task(async function database_is_valid() {
+  // Accessing the database for the first time triggers migration.
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_UPGRADED
+  );
+
+  const db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(async function moz_historyvisits() {
+  await PlacesUtils.withConnectionWrapper("test_sqlite_migration", async db => {
+    const rows = await db.execute(
+      "SELECT * FROM moz_historyvisits WHERE from_visit=-1"
+    );
+
+    Assert.equal(rows.length, 1);
+    Assert.equal(rows[0].getResultByName("source"), 0);
+    Assert.equal(rows[0].getResultByName("triggeringPlaceId"), null);
+  });
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v69.js b/toolkit/components/places/tests/migration/test_current_from_v69.js
new file mode 100644
index 0000000000..09c66fb66e
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v69.js
@@ -0,0 +1,84 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function setup() {
+  const path = await setupPlacesDatabase("places_v69.sqlite");
+
+  const db = await Sqlite.openConnection({ path });
+  await db.execute(`
+    INSERT INTO moz_places (url, guid, url_hash, origin_id, frecency)
+    VALUES
+      ('https://test1.com', '___________1', '123456', 100, 0),
+      ('https://test2.com', '___________2', '123456', 101, -1),
+      ('https://test3.com', '___________3', '123456', 102, -1234)
+    `);
+  await db.execute(`
+    INSERT INTO moz_origins (id, prefix, host, frecency)
+    VALUES
+      (100, 'https://', 'test1.com', 0),
+      (101, 'https://', 'test2.com', 0),
+      (102, 'https://', 'test3.com', 0)
+    `);
+  await db.close();
+});
+
+add_task(async function database_is_valid() {
+  // Accessing the database for the first time triggers migration.
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_UPGRADED
+  );
+
+  const db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(async function moz_historyvisits() {
+  await PlacesUtils.withConnectionWrapper("test_sqlite_migration", async db => {
+    function expectedFrecency(guid) {
+      switch (guid) {
+        case "___________1":
+          return 0;
+        case "___________2":
+          return -1;
+        case "___________3":
+          return 1234;
+        default:
+          throw new Error("Unknown guid");
+      }
+    }
+    const rows = await db.execute(
+      "SELECT guid, frecency FROM moz_places WHERE url_hash = '123456'"
+    );
+    for (let row of rows) {
+      Assert.equal(
+        row.getResultByName("frecency"),
+        expectedFrecency(row.getResultByName("guid")),
+        "Check expected frecency"
+      );
+    }
+    const origins = new Map(
+      (await db.execute("SELECT host, frecency FROM moz_origins")).map(r => [
+        r.getResultByName("host"),
+        r.getResultByName("frecency"),
+      ])
+    );
+    Assert.equal(origins.get("test1.com"), 0);
+    Assert.equal(origins.get("test2.com"), 0);
+    Assert.equal(origins.get("test3.com"), 1234);
+
+    const statSum = (
+      await db.execute(
+        "SELECT value FROM moz_meta WHERE key = 'origin_frecency_sum'"
+      )
+    )[0].getResultByName("value");
+    const sum = (
+      await db.execute(
+        "SELECT SUM(frecency) AS sum from moz_origins WHERE frecency > 0"
+      )
+    )[0].getResultByName("sum");
+    Assert.equal(sum, statSum, "Check stats were updated");
+  });
+});
diff --git a/toolkit/components/places/tests/migration/test_current_from_v70.js b/toolkit/components/places/tests/migration/test_current_from_v70.js
new file mode 100644
index 0000000000..f17439070a
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v70.js
@@ -0,0 +1,96 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function setup() {
+  let path = await setupPlacesDatabase("places_v70.sqlite");
+
+  let db = await Sqlite.openConnection({ path });
+  await db.execute(`
+    INSERT INTO moz_places (url, guid, url_hash, origin_id, frecency, foreign_count)
+    VALUES
+      ('https://test1.com', '___________1', '123456', 100, 0, 2),
+      ('https://test2.com', '___________2', '123456', 101, -1, 2),
+      ('https://test3.com', '___________3', '123456', 102, -1234, 1)
+    `);
+  await db.execute(`
+    INSERT INTO moz_origins (id, prefix, host, frecency)
+    VALUES
+      (100, 'https://', 'test1.com', 0),
+      (101, 'https://', 'test2.com', 0),
+      (102, 'https://', 'test3.com', 0)
+    `);
+  await db.execute(
+    `INSERT INTO moz_session_metadata
+      (id, guid)
+      VALUES (0, "0")
+    `
+  );
+
+  await db.execute(
+    `INSERT INTO moz_places_metadata_snapshots
+      (place_id, created_at, first_interaction_at, last_interaction_at)
+      VALUES ((SELECT id FROM moz_places WHERE guid = :guid), 0, 0, 0)
+    `,
+    { guid: "___________1" }
+  );
+  await db.execute(
+    `INSERT INTO moz_bookmarks
+      (fk, guid)
+      VALUES ((SELECT id FROM moz_places WHERE guid = :guid), :guid)
+    `,
+    { guid: "___________1" }
+  );
+
+  await db.execute(
+    `INSERT INTO moz_places_metadata_snapshots
+      (place_id, created_at, first_interaction_at, last_interaction_at)
+      VALUES ((SELECT id FROM moz_places WHERE guid = :guid), 0, 0, 0)
+    `,
+    { guid: "___________2" }
+  );
+  await db.execute(
+    `INSERT INTO moz_session_to_places
+      (session_id, place_id)
+      VALUES (0, (SELECT id FROM moz_places WHERE guid = :guid))
+    `,
+    { guid: "___________2" }
+  );
+
+  await db.execute(
+    `INSERT INTO moz_session_to_places
+      (session_id, place_id)
+      VALUES (0, (SELECT id FROM moz_places WHERE guid = :guid))
+    `,
+    { guid: "___________3" }
+  );
+
+  await db.close();
+});
+
+add_task(async function database_is_valid() {
+  // Accessing the database for the first time triggers migration.
+  Assert.equal(
+    PlacesUtils.history.databaseStatus,
+    PlacesUtils.history.DATABASE_STATUS_UPGRADED
+  );
+
+  const db = await PlacesUtils.promiseDBConnection();
+  Assert.equal(await db.getSchemaVersion(), 71);
+
+  let rows = await db.execute("SELECT guid, foreign_count FROM moz_places");
+  for (let row of rows) {
+    let guid = row.getResultByName("guid");
+    let count = row.getResultByName("foreign_count");
+    if (guid == "___________1") {
+      Assert.equal(count, 1, "test1 should have the correct foreign_count");
+    }
+    if (guid == "___________2") {
+      Assert.equal(count, 0, "test2 should have the correct foreign_count");
+    }
+    if (guid == "___________3") {
+      Assert.equal(count, 0, "test3 should have the correct foreign_count");
+    }
+  }
+});
diff --git a/toolkit/components/places/tests/migration/xpcshell.ini b/toolkit/components/places/tests/migration/xpcshell.ini
new file mode 100644
index 0000000000..1a2d52a3de
--- /dev/null
+++ b/toolkit/components/places/tests/migration/xpcshell.ini
@@ -0,0 +1,31 @@
+[DEFAULT]
+head = head_migration.js
+tags = condprof
+
+support-files =
+  favicons_v41.sqlite
+  places_outdated.sqlite
+  places_v43.sqlite
+  places_v54.sqlite
+  places_v66.sqlite
+  places_v68.sqlite
+  places_v69.sqlite
+  places_v70.sqlite
+  places_v71.sqlite
+
+[test_current_from_downgraded.js]
+[test_current_from_outdated.js]
+[test_current_from_v43.js]
+[test_current_from_v45.js]
+[test_current_from_v46.js]
+[test_current_from_v47.js]
+[test_current_from_v48.js]
+[test_current_from_v50.js]
+[test_current_from_v53.js]
+skip-if = condprof  # Bug 1769154 - not supported
+[test_current_from_v54.js]
+skip-if = condprof  # Bug 1769154 - not supported
+[test_current_from_v66.js]
+[test_current_from_v68.js]
+[test_current_from_v69.js]
+[test_current_from_v70.js]