Adding upstream version 115.7.0esr.upstream/115.7.0esr

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

33 files changed, 4563 insertions, 0 deletions

diff --git a/services/common/tests/moz.build b/services/common/tests/moz.build
new file mode 100644
index 0000000000..edf7213b91
--- /dev/null
+++ b/services/common/tests/moz.build
@@ -0,0 +1,9 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+XPCSHELL_TESTS_MANIFESTS += ["unit/xpcshell.ini"]
+
+TEST_DIRS += ["unit"]
diff --git a/services/common/tests/unit/head_global.js b/services/common/tests/unit/head_global.js
new file mode 100644
index 0000000000..bcb1c063a4
--- /dev/null
+++ b/services/common/tests/unit/head_global.js
@@ -0,0 +1,35 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var Cm = Components.manager;
+
+// Required to avoid failures.
+do_get_profile();
+var { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+
+const { updateAppInfo } = ChromeUtils.importESModule(
+  "resource://testing-common/AppInfo.sys.mjs"
+);
+updateAppInfo({
+  name: "XPCShell",
+  ID: "xpcshell@tests.mozilla.org",
+  version: "1",
+  platformVersion: "",
+});
+
+function addResourceAlias() {
+  const handler = Services.io
+    .getProtocolHandler("resource")
+    .QueryInterface(Ci.nsIResProtocolHandler);
+
+  let modules = ["common", "crypto", "settings"];
+  for (let module of modules) {
+    let uri = Services.io.newURI(
+      "resource://gre/modules/services-" + module + "/"
+    );
+    handler.setSubstitution("services-" + module, uri);
+  }
+}
+addResourceAlias();
diff --git a/services/common/tests/unit/head_helpers.js b/services/common/tests/unit/head_helpers.js
new file mode 100644
index 0000000000..1947ece254
--- /dev/null
+++ b/services/common/tests/unit/head_helpers.js
@@ -0,0 +1,268 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* import-globals-from head_global.js */
+
+var { Log } = ChromeUtils.importESModule("resource://gre/modules/Log.sys.mjs");
+var { CommonUtils } = ChromeUtils.importESModule(
+  "resource://services-common/utils.sys.mjs"
+);
+var {
+  HTTP_400,
+  HTTP_401,
+  HTTP_402,
+  HTTP_403,
+  HTTP_404,
+  HTTP_405,
+  HTTP_406,
+  HTTP_407,
+  HTTP_408,
+  HTTP_409,
+  HTTP_410,
+  HTTP_411,
+  HTTP_412,
+  HTTP_413,
+  HTTP_414,
+  HTTP_415,
+  HTTP_417,
+  HTTP_500,
+  HTTP_501,
+  HTTP_502,
+  HTTP_503,
+  HTTP_504,
+  HTTP_505,
+  HttpError,
+  HttpServer,
+} = ChromeUtils.import("resource://testing-common/httpd.js");
+var { getTestLogger, initTestLogging } = ChromeUtils.importESModule(
+  "resource://testing-common/services/common/logging.sys.mjs"
+);
+var { MockRegistrar } = ChromeUtils.importESModule(
+  "resource://testing-common/MockRegistrar.sys.mjs"
+);
+var { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
+
+function do_check_empty(obj) {
+  do_check_attribute_count(obj, 0);
+}
+
+function do_check_attribute_count(obj, c) {
+  Assert.equal(c, Object.keys(obj).length);
+}
+
+function do_check_throws(aFunc, aResult) {
+  try {
+    aFunc();
+  } catch (e) {
+    Assert.equal(e.result, aResult);
+    return;
+  }
+  do_throw("Expected result " + aResult + ", none thrown.");
+}
+
+/**
+ * Test whether specified function throws exception with expected
+ * result.
+ *
+ * @param func
+ *        Function to be tested.
+ * @param message
+ *        Message of expected exception. <code>null</code> for no throws.
+ */
+function do_check_throws_message(aFunc, aResult) {
+  try {
+    aFunc();
+  } catch (e) {
+    Assert.equal(e.message, aResult);
+    return;
+  }
+  do_throw("Expected an error, none thrown.");
+}
+
+/**
+ * Print some debug message to the console. All arguments will be printed,
+ * separated by spaces.
+ *
+ * @param [arg0, arg1, arg2, ...]
+ *        Any number of arguments to print out
+ * @usage _("Hello World") -> prints "Hello World"
+ * @usage _(1, 2, 3) -> prints "1 2 3"
+ */
+var _ = function (some, debug, text, to) {
+  print(Array.from(arguments).join(" "));
+};
+
+function httpd_setup(handlers, port = -1) {
+  let server = new HttpServer();
+  for (let path in handlers) {
+    server.registerPathHandler(path, handlers[path]);
+  }
+  try {
+    server.start(port);
+  } catch (ex) {
+    _("==========================================");
+    _("Got exception starting HTTP server on port " + port);
+    _("Error: " + Log.exceptionStr(ex));
+    _("Is there a process already listening on port " + port + "?");
+    _("==========================================");
+    do_throw(ex);
+  }
+
+  // Set the base URI for convenience.
+  let i = server.identity;
+  server.baseURI =
+    i.primaryScheme + "://" + i.primaryHost + ":" + i.primaryPort;
+
+  return server;
+}
+
+function httpd_handler(statusCode, status, body) {
+  return function handler(request, response) {
+    _("Processing request");
+    // Allow test functions to inspect the request.
+    request.body = readBytesFromInputStream(request.bodyInputStream);
+    handler.request = request;
+
+    response.setStatusLine(request.httpVersion, statusCode, status);
+    if (body) {
+      response.bodyOutputStream.write(body, body.length);
+    }
+  };
+}
+
+function promiseStopServer(server) {
+  return new Promise(resolve => server.stop(resolve));
+}
+
+/*
+ * Read bytes string from an nsIInputStream.  If 'count' is omitted,
+ * all available input is read.
+ */
+function readBytesFromInputStream(inputStream, count) {
+  if (!count) {
+    count = inputStream.available();
+  }
+  if (!count) {
+    return "";
+  }
+  return NetUtil.readInputStreamToString(inputStream, count, {
+    charset: "UTF-8",
+  });
+}
+
+function writeBytesToOutputStream(outputStream, string) {
+  if (!string) {
+    return;
+  }
+  let converter = Cc[
+    "@mozilla.org/intl/converter-output-stream;1"
+  ].createInstance(Ci.nsIConverterOutputStream);
+  converter.init(outputStream, "UTF-8");
+  converter.writeString(string);
+  converter.close();
+}
+
+/*
+ * Ensure exceptions from inside callbacks leads to test failures.
+ */
+function ensureThrows(func) {
+  return function () {
+    try {
+      func.apply(this, arguments);
+    } catch (ex) {
+      do_throw(ex);
+    }
+  };
+}
+
+/**
+ * Proxy auth helpers.
+ */
+
+/**
+ * Fake a PAC to prompt a channel replacement.
+ */
+var PACSystemSettings = {
+  QueryInterface: ChromeUtils.generateQI(["nsISystemProxySettings"]),
+
+  // Replace this URI for each test to avoid caching. We want to ensure that
+  // each test gets a completely fresh setup.
+  mainThreadOnly: true,
+  PACURI: null,
+  getProxyForURI: function getProxyForURI(aURI) {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+};
+
+var fakePACCID;
+function installFakePAC() {
+  _("Installing fake PAC.");
+  fakePACCID = MockRegistrar.register(
+    "@mozilla.org/system-proxy-settings;1",
+    PACSystemSettings
+  );
+}
+
+function uninstallFakePAC() {
+  _("Uninstalling fake PAC.");
+  MockRegistrar.unregister(fakePACCID);
+}
+
+function getUptakeTelemetrySnapshot(component, source) {
+  const TELEMETRY_CATEGORY_ID = "uptake.remotecontent.result";
+  const snapshot = Services.telemetry.snapshotEvents(
+    Ci.nsITelemetry.DATASET_ALL_CHANNELS,
+    true
+  );
+  const parentEvents = snapshot.parent || [];
+  return (
+    parentEvents
+      // Transform raw event data to objects.
+      .map(([i, category, method, object, value, extras]) => {
+        return { category, method, object, value, extras };
+      })
+      // Keep only for the specified component and source.
+      .filter(
+        e =>
+          e.category == TELEMETRY_CATEGORY_ID &&
+          e.object == component &&
+          e.extras.source == source
+      )
+      // Return total number of events received by status, to mimic histograms snapshots.
+      .reduce((acc, e) => {
+        acc[e.value] = (acc[e.value] || 0) + 1;
+        return acc;
+      }, {})
+  );
+}
+
+function checkUptakeTelemetry(snapshot1, snapshot2, expectedIncrements) {
+  const { UptakeTelemetry } = ChromeUtils.importESModule(
+    "resource://services-common/uptake-telemetry.sys.mjs"
+  );
+  const STATUSES = Object.values(UptakeTelemetry.STATUS);
+  for (const status of STATUSES) {
+    const expected = expectedIncrements[status] || 0;
+    const previous = snapshot1[status] || 0;
+    const current = snapshot2[status] || previous;
+    Assert.equal(expected, current - previous, `check events for ${status}`);
+  }
+}
+
+async function withFakeChannel(channel, f) {
+  const { Policy } = ChromeUtils.importESModule(
+    "resource://services-common/uptake-telemetry.sys.mjs"
+  );
+  let oldGetChannel = Policy.getChannel;
+  Policy.getChannel = () => channel;
+  try {
+    return await f();
+  } finally {
+    Policy.getChannel = oldGetChannel;
+  }
+}
+
+function arrayEqual(a, b) {
+  return JSON.stringify(a) == JSON.stringify(b);
+}
diff --git a/services/common/tests/unit/head_http.js b/services/common/tests/unit/head_http.js
new file mode 100644
index 0000000000..6c2a0a3f0f
--- /dev/null
+++ b/services/common/tests/unit/head_http.js
@@ -0,0 +1,33 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/* import-globals-from head_global.js */
+
+var { CommonUtils } = ChromeUtils.importESModule(
+  "resource://services-common/utils.sys.mjs"
+);
+
+function basic_auth_header(user, password) {
+  return "Basic " + btoa(user + ":" + CommonUtils.encodeUTF8(password));
+}
+
+function basic_auth_matches(req, user, password) {
+  if (!req.hasHeader("Authorization")) {
+    return false;
+  }
+
+  let expected = basic_auth_header(user, CommonUtils.encodeUTF8(password));
+  return req.getHeader("Authorization") == expected;
+}
+
+function httpd_basic_auth_handler(body, metadata, response) {
+  if (basic_auth_matches(metadata, "guest", "guest")) {
+    response.setStatusLine(metadata.httpVersion, 200, "OK, authorized");
+    response.setHeader("WWW-Authenticate", 'Basic realm="secret"', false);
+  } else {
+    body = "This path exists and is protected - failed";
+    response.setStatusLine(metadata.httpVersion, 401, "Unauthorized");
+    response.setHeader("WWW-Authenticate", 'Basic realm="secret"', false);
+  }
+  response.bodyOutputStream.write(body, body.length);
+}
diff --git a/services/common/tests/unit/moz.build b/services/common/tests/unit/moz.build
new file mode 100644
index 0000000000..568f361a54
--- /dev/null
+++ b/services/common/tests/unit/moz.build
@@ -0,0 +1,5 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
diff --git a/services/common/tests/unit/test_async_chain.js b/services/common/tests/unit/test_async_chain.js
new file mode 100644
index 0000000000..3277c92f81
--- /dev/null
+++ b/services/common/tests/unit/test_async_chain.js
@@ -0,0 +1,40 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { Async } = ChromeUtils.importESModule(
+  "resource://services-common/async.sys.mjs"
+);
+
+function run_test() {
+  _("Chain a few async methods, making sure the 'this' object is correct.");
+
+  let methods = {
+    save(x, callback) {
+      this.x = x;
+      callback(x);
+    },
+    addX(x, callback) {
+      callback(x + this.x);
+    },
+    double(x, callback) {
+      callback(x * 2);
+    },
+    neg(x, callback) {
+      callback(-x);
+    },
+  };
+  methods.chain = Async.chain;
+
+  // ((1 + 1 + 1) * (-1) + 1) * 2 + 1 = -3
+  methods.chain(
+    methods.save,
+    methods.addX,
+    methods.addX,
+    methods.neg,
+    methods.addX,
+    methods.double,
+    methods.addX,
+    methods.save
+  )(1);
+  Assert.equal(methods.x, -3);
+}
diff --git a/services/common/tests/unit/test_async_foreach.js b/services/common/tests/unit/test_async_foreach.js
new file mode 100644
index 0000000000..14a23e7ff7
--- /dev/null
+++ b/services/common/tests/unit/test_async_foreach.js
@@ -0,0 +1,88 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { Async } = ChromeUtils.importESModule(
+  "resource://services-common/async.sys.mjs"
+);
+const { sinon } = ChromeUtils.importESModule(
+  "resource://testing-common/Sinon.sys.mjs"
+);
+
+function makeArray(length) {
+  // Start at 1 so that we can just divide by yieldEvery to get the expected
+  // call count. (we exp)
+  return Array.from({ length }, (v, i) => i + 1);
+}
+
+// Adjust if we ever change the default.
+const DEFAULT_YIELD_EVERY = 50;
+
+add_task(async function testYields() {
+  let spy = sinon.spy(Async, "promiseYield");
+  try {
+    await Async.yieldingForEach(makeArray(DEFAULT_YIELD_EVERY * 2), element => {
+      // The yield will happen *after* this function is ran.
+      Assert.equal(
+        spy.callCount,
+        Math.floor((element - 1) / DEFAULT_YIELD_EVERY)
+      );
+    });
+  } finally {
+    spy.restore();
+  }
+});
+
+add_task(async function testExistingYieldState() {
+  const yieldState = Async.yieldState(DEFAULT_YIELD_EVERY);
+
+  for (let i = 0; i < 15; i++) {
+    Assert.equal(yieldState.shouldYield(), false);
+  }
+
+  let spy = sinon.spy(Async, "promiseYield");
+
+  try {
+    await Async.yieldingForEach(
+      makeArray(DEFAULT_YIELD_EVERY * 2),
+      element => {
+        Assert.equal(
+          spy.callCount,
+          Math.floor((element + 15 - 1) / DEFAULT_YIELD_EVERY)
+        );
+      },
+      yieldState
+    );
+  } finally {
+    spy.restore();
+  }
+});
+
+add_task(async function testEarlyReturn() {
+  let lastElement = 0;
+  await Async.yieldingForEach(makeArray(DEFAULT_YIELD_EVERY), element => {
+    lastElement = element;
+    return element === 10;
+  });
+
+  Assert.equal(lastElement, 10);
+});
+
+add_task(async function testEaryReturnAsync() {
+  let lastElement = 0;
+  await Async.yieldingForEach(makeArray(DEFAULT_YIELD_EVERY), async element => {
+    lastElement = element;
+    return element === 10;
+  });
+
+  Assert.equal(lastElement, 10);
+});
+
+add_task(async function testEarlyReturnPromise() {
+  let lastElement = 0;
+  await Async.yieldingForEach(makeArray(DEFAULT_YIELD_EVERY), element => {
+    lastElement = element;
+    return new Promise(resolve => resolve(element === 10));
+  });
+
+  Assert.equal(lastElement, 10);
+});
diff --git a/services/common/tests/unit/test_hawkclient.js b/services/common/tests/unit/test_hawkclient.js
new file mode 100644
index 0000000000..33d125f42e
--- /dev/null
+++ b/services/common/tests/unit/test_hawkclient.js
@@ -0,0 +1,515 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { HawkClient } = ChromeUtils.importESModule(
+  "resource://services-common/hawkclient.sys.mjs"
+);
+
+const SECOND_MS = 1000;
+const MINUTE_MS = SECOND_MS * 60;
+const HOUR_MS = MINUTE_MS * 60;
+
+const TEST_CREDS = {
+  id: "eyJleHBpcmVzIjogMTM2NTAxMDg5OC4x",
+  key: "qTZf4ZFpAMpMoeSsX3zVRjiqmNs=",
+  algorithm: "sha256",
+};
+
+initTestLogging("Trace");
+
+add_task(function test_now() {
+  let client = new HawkClient("https://example.com");
+
+  Assert.ok(client.now() - Date.now() < SECOND_MS);
+});
+
+add_task(function test_updateClockOffset() {
+  let client = new HawkClient("https://example.com");
+
+  let now = new Date();
+  let serverDate = now.toUTCString();
+
+  // Client's clock is off
+  client.now = () => {
+    return now.valueOf() + HOUR_MS;
+  };
+
+  client._updateClockOffset(serverDate);
+
+  // Check that they're close; there will likely be a one-second rounding
+  // error, so checking strict equality will likely fail.
+  //
+  // localtimeOffsetMsec is how many milliseconds to add to the local clock so
+  // that it agrees with the server.  We are one hour ahead of the server, so
+  // our offset should be -1 hour.
+  Assert.ok(Math.abs(client.localtimeOffsetMsec + HOUR_MS) <= SECOND_MS);
+});
+
+add_task(async function test_authenticated_get_request() {
+  let message = '{"msg": "Great Success!"}';
+  let method = "GET";
+
+  let server = httpd_setup({
+    "/foo": (request, response) => {
+      Assert.ok(request.hasHeader("Authorization"));
+
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.bodyOutputStream.write(message, message.length);
+    },
+  });
+
+  let client = new HawkClient(server.baseURI);
+
+  let response = await client.request("/foo", method, TEST_CREDS);
+  let result = JSON.parse(response.body);
+
+  Assert.equal("Great Success!", result.msg);
+
+  await promiseStopServer(server);
+});
+
+async function check_authenticated_request(method) {
+  let server = httpd_setup({
+    "/foo": (request, response) => {
+      Assert.ok(request.hasHeader("Authorization"));
+
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.setHeader("Content-Type", "application/json");
+      response.bodyOutputStream.writeFrom(
+        request.bodyInputStream,
+        request.bodyInputStream.available()
+      );
+    },
+  });
+
+  let client = new HawkClient(server.baseURI);
+
+  let response = await client.request("/foo", method, TEST_CREDS, {
+    foo: "bar",
+  });
+  let result = JSON.parse(response.body);
+
+  Assert.equal("bar", result.foo);
+
+  await promiseStopServer(server);
+}
+
+add_task(async function test_authenticated_post_request() {
+  await check_authenticated_request("POST");
+});
+
+add_task(async function test_authenticated_put_request() {
+  await check_authenticated_request("PUT");
+});
+
+add_task(async function test_authenticated_patch_request() {
+  await check_authenticated_request("PATCH");
+});
+
+add_task(async function test_extra_headers() {
+  let server = httpd_setup({
+    "/foo": (request, response) => {
+      Assert.ok(request.hasHeader("Authorization"));
+      Assert.ok(request.hasHeader("myHeader"));
+      Assert.equal(request.getHeader("myHeader"), "fake");
+
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.setHeader("Content-Type", "application/json");
+      response.bodyOutputStream.writeFrom(
+        request.bodyInputStream,
+        request.bodyInputStream.available()
+      );
+    },
+  });
+
+  let client = new HawkClient(server.baseURI);
+
+  let response = await client.request(
+    "/foo",
+    "POST",
+    TEST_CREDS,
+    { foo: "bar" },
+    { myHeader: "fake" }
+  );
+  let result = JSON.parse(response.body);
+
+  Assert.equal("bar", result.foo);
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_credentials_optional() {
+  let method = "GET";
+  let server = httpd_setup({
+    "/foo": (request, response) => {
+      Assert.ok(!request.hasHeader("Authorization"));
+
+      let message = JSON.stringify({ msg: "you're in the friend zone" });
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.setHeader("Content-Type", "application/json");
+      response.bodyOutputStream.write(message, message.length);
+    },
+  });
+
+  let client = new HawkClient(server.baseURI);
+  let result = await client.request("/foo", method); // credentials undefined
+  Assert.equal(JSON.parse(result.body).msg, "you're in the friend zone");
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_server_error() {
+  let message = "Ohai!";
+  let method = "GET";
+
+  let server = httpd_setup({
+    "/foo": (request, response) => {
+      response.setStatusLine(request.httpVersion, 418, "I am a Teapot");
+      response.bodyOutputStream.write(message, message.length);
+    },
+  });
+
+  let client = new HawkClient(server.baseURI);
+
+  try {
+    await client.request("/foo", method, TEST_CREDS);
+    do_throw("Expected an error");
+  } catch (err) {
+    Assert.equal(418, err.code);
+    Assert.equal("I am a Teapot", err.message);
+  }
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_server_error_json() {
+  let message = JSON.stringify({ error: "Cannot get ye flask." });
+  let method = "GET";
+
+  let server = httpd_setup({
+    "/foo": (request, response) => {
+      response.setStatusLine(
+        request.httpVersion,
+        400,
+        "What wouldst thou deau?"
+      );
+      response.bodyOutputStream.write(message, message.length);
+    },
+  });
+
+  let client = new HawkClient(server.baseURI);
+
+  try {
+    await client.request("/foo", method, TEST_CREDS);
+    do_throw("Expected an error");
+  } catch (err) {
+    Assert.equal("Cannot get ye flask.", err.error);
+  }
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_offset_after_request() {
+  let message = "Ohai!";
+  let method = "GET";
+
+  let server = httpd_setup({
+    "/foo": (request, response) => {
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.bodyOutputStream.write(message, message.length);
+    },
+  });
+
+  let client = new HawkClient(server.baseURI);
+  let now = Date.now();
+  client.now = () => {
+    return now + HOUR_MS;
+  };
+
+  Assert.equal(client.localtimeOffsetMsec, 0);
+
+  await client.request("/foo", method, TEST_CREDS);
+  // Should be about an hour off
+  Assert.ok(Math.abs(client.localtimeOffsetMsec + HOUR_MS) < SECOND_MS);
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_offset_in_hawk_header() {
+  let message = "Ohai!";
+  let method = "GET";
+
+  let server = httpd_setup({
+    "/first": function (request, response) {
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.bodyOutputStream.write(message, message.length);
+    },
+
+    "/second": function (request, response) {
+      // We see a better date now in the ts component of the header
+      let delta = getTimestampDelta(request.getHeader("Authorization"));
+
+      // We're now within HAWK's one-minute window.
+      // I hope this isn't a recipe for intermittent oranges ...
+      if (delta < MINUTE_MS) {
+        response.setStatusLine(request.httpVersion, 200, "OK");
+      } else {
+        response.setStatusLine(request.httpVersion, 400, "Delta: " + delta);
+      }
+      response.bodyOutputStream.write(message, message.length);
+    },
+  });
+
+  let client = new HawkClient(server.baseURI);
+
+  client.now = () => {
+    return Date.now() + 12 * HOUR_MS;
+  };
+
+  // We begin with no offset
+  Assert.equal(client.localtimeOffsetMsec, 0);
+  await client.request("/first", method, TEST_CREDS);
+
+  // After the first server response, our offset is updated to -12 hours.
+  // We should be safely in the window, now.
+  Assert.ok(Math.abs(client.localtimeOffsetMsec + 12 * HOUR_MS) < MINUTE_MS);
+  await client.request("/second", method, TEST_CREDS);
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_2xx_success() {
+  // Just to ensure that we're not biased toward 200 OK for success
+  let credentials = {
+    id: "eyJleHBpcmVzIjogMTM2NTAxMDg5OC4x",
+    key: "qTZf4ZFpAMpMoeSsX3zVRjiqmNs=",
+    algorithm: "sha256",
+  };
+  let method = "GET";
+
+  let server = httpd_setup({
+    "/foo": (request, response) => {
+      response.setStatusLine(request.httpVersion, 202, "Accepted");
+    },
+  });
+
+  let client = new HawkClient(server.baseURI);
+
+  let response = await client.request("/foo", method, credentials);
+
+  // Shouldn't be any content in a 202
+  Assert.equal(response.body, "");
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_retry_request_on_fail() {
+  let attempts = 0;
+  let credentials = {
+    id: "eyJleHBpcmVzIjogMTM2NTAxMDg5OC4x",
+    key: "qTZf4ZFpAMpMoeSsX3zVRjiqmNs=",
+    algorithm: "sha256",
+  };
+  let method = "GET";
+
+  let server = httpd_setup({
+    "/maybe": function (request, response) {
+      // This path should be hit exactly twice; once with a bad timestamp, and
+      // again when the client retries the request with a corrected timestamp.
+      attempts += 1;
+      Assert.ok(attempts <= 2);
+
+      let delta = getTimestampDelta(request.getHeader("Authorization"));
+
+      // First time through, we should have a bad timestamp
+      if (attempts === 1) {
+        Assert.ok(delta > MINUTE_MS);
+        let message = "never!!!";
+        response.setStatusLine(request.httpVersion, 401, "Unauthorized");
+        response.bodyOutputStream.write(message, message.length);
+        return;
+      }
+
+      // Second time through, timestamp should be corrected by client
+      Assert.ok(delta < MINUTE_MS);
+      let message = "i love you!!!";
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.bodyOutputStream.write(message, message.length);
+    },
+  });
+
+  let client = new HawkClient(server.baseURI);
+
+  client.now = () => {
+    return Date.now() + 12 * HOUR_MS;
+  };
+
+  // We begin with no offset
+  Assert.equal(client.localtimeOffsetMsec, 0);
+
+  // Request will have bad timestamp; client will retry once
+  let response = await client.request("/maybe", method, credentials);
+  Assert.equal(response.body, "i love you!!!");
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_multiple_401_retry_once() {
+  // Like test_retry_request_on_fail, but always return a 401
+  // and ensure that the client only retries once.
+  let attempts = 0;
+  let credentials = {
+    id: "eyJleHBpcmVzIjogMTM2NTAxMDg5OC4x",
+    key: "qTZf4ZFpAMpMoeSsX3zVRjiqmNs=",
+    algorithm: "sha256",
+  };
+  let method = "GET";
+
+  let server = httpd_setup({
+    "/maybe": function (request, response) {
+      // This path should be hit exactly twice; once with a bad timestamp, and
+      // again when the client retries the request with a corrected timestamp.
+      attempts += 1;
+
+      Assert.ok(attempts <= 2);
+
+      let message = "never!!!";
+      response.setStatusLine(request.httpVersion, 401, "Unauthorized");
+      response.bodyOutputStream.write(message, message.length);
+    },
+  });
+
+  let client = new HawkClient(server.baseURI);
+
+  client.now = () => {
+    return Date.now() - 12 * HOUR_MS;
+  };
+
+  // We begin with no offset
+  Assert.equal(client.localtimeOffsetMsec, 0);
+
+  // Request will have bad timestamp; client will retry once
+  try {
+    await client.request("/maybe", method, credentials);
+    do_throw("Expected an error");
+  } catch (err) {
+    Assert.equal(err.code, 401);
+  }
+  Assert.equal(attempts, 2);
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_500_no_retry() {
+  // If we get a 500 error, the client should not retry (as it would with a
+  // 401)
+  let credentials = {
+    id: "eyJleHBpcmVzIjogMTM2NTAxMDg5OC4x",
+    key: "qTZf4ZFpAMpMoeSsX3zVRjiqmNs=",
+    algorithm: "sha256",
+  };
+  let method = "GET";
+
+  let server = httpd_setup({
+    "/no-shutup": function (request, response) {
+      let message = "Cannot get ye flask.";
+      response.setStatusLine(request.httpVersion, 500, "Internal server error");
+      response.bodyOutputStream.write(message, message.length);
+    },
+  });
+
+  let client = new HawkClient(server.baseURI);
+
+  // Throw off the clock so the HawkClient would want to retry the request if
+  // it could
+  client.now = () => {
+    return Date.now() - 12 * HOUR_MS;
+  };
+
+  // Request will 500; no retries
+  try {
+    await client.request("/no-shutup", method, credentials);
+    do_throw("Expected an error");
+  } catch (err) {
+    Assert.equal(err.code, 500);
+  }
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_401_then_500() {
+  // Like test_multiple_401_retry_once, but return a 500 to the
+  // second request, ensuring that the promise is properly rejected
+  // in client.request.
+  let attempts = 0;
+  let credentials = {
+    id: "eyJleHBpcmVzIjogMTM2NTAxMDg5OC4x",
+    key: "qTZf4ZFpAMpMoeSsX3zVRjiqmNs=",
+    algorithm: "sha256",
+  };
+  let method = "GET";
+
+  let server = httpd_setup({
+    "/maybe": function (request, response) {
+      // This path should be hit exactly twice; once with a bad timestamp, and
+      // again when the client retries the request with a corrected timestamp.
+      attempts += 1;
+      Assert.ok(attempts <= 2);
+
+      let delta = getTimestampDelta(request.getHeader("Authorization"));
+
+      // First time through, we should have a bad timestamp
+      // Client will retry
+      if (attempts === 1) {
+        Assert.ok(delta > MINUTE_MS);
+        let message = "never!!!";
+        response.setStatusLine(request.httpVersion, 401, "Unauthorized");
+        response.bodyOutputStream.write(message, message.length);
+        return;
+      }
+
+      // Second time through, timestamp should be corrected by client
+      // And fail on the client
+      Assert.ok(delta < MINUTE_MS);
+      let message = "Cannot get ye flask.";
+      response.setStatusLine(request.httpVersion, 500, "Internal server error");
+      response.bodyOutputStream.write(message, message.length);
+    },
+  });
+
+  let client = new HawkClient(server.baseURI);
+
+  client.now = () => {
+    return Date.now() - 12 * HOUR_MS;
+  };
+
+  // We begin with no offset
+  Assert.equal(client.localtimeOffsetMsec, 0);
+
+  // Request will have bad timestamp; client will retry once
+  try {
+    await client.request("/maybe", method, credentials);
+  } catch (err) {
+    Assert.equal(err.code, 500);
+  }
+  Assert.equal(attempts, 2);
+
+  await promiseStopServer(server);
+});
+
+// End of tests.
+// Utility functions follow
+
+function getTimestampDelta(authHeader, now = Date.now()) {
+  let tsMS = new Date(
+    parseInt(/ts="(\d+)"/.exec(authHeader)[1], 10) * SECOND_MS
+  );
+  return Math.abs(tsMS - now);
+}
+
+function run_test() {
+  initTestLogging("Trace");
+  run_next_test();
+}
diff --git a/services/common/tests/unit/test_hawkrequest.js b/services/common/tests/unit/test_hawkrequest.js
new file mode 100644
index 0000000000..13ab6737de
--- /dev/null
+++ b/services/common/tests/unit/test_hawkrequest.js
@@ -0,0 +1,231 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { HAWKAuthenticatedRESTRequest, deriveHawkCredentials } =
+  ChromeUtils.importESModule("resource://services-common/hawkrequest.sys.mjs");
+const { Async } = ChromeUtils.importESModule(
+  "resource://services-common/async.sys.mjs"
+);
+
+// https://github.com/mozilla/fxa-auth-server/wiki/onepw-protocol#wiki-use-session-certificatesign-etc
+var SESSION_KEYS = {
+  sessionToken: h(
+    // eslint-disable-next-line no-useless-concat
+    "a0a1a2a3a4a5a6a7 a8a9aaabacadaeaf" + "b0b1b2b3b4b5b6b7 b8b9babbbcbdbebf"
+  ),
+
+  tokenID: h(
+    // eslint-disable-next-line no-useless-concat
+    "c0a29dcf46174973 da1378696e4c82ae" + "10f723cf4f4d9f75 e39f4ae3851595ab"
+  ),
+
+  reqHMACkey: h(
+    // eslint-disable-next-line no-useless-concat
+    "9d8f22998ee7f579 8b887042466b72d5" + "3e56ab0c094388bf 65831f702d2febc0"
+  ),
+};
+
+function do_register_cleanup() {
+  Services.prefs.clearUserPref("intl.accept_languages");
+  Services.prefs.clearUserPref("services.common.log.logger.rest.request");
+
+  // remove the pref change listener
+  let hawk = new HAWKAuthenticatedRESTRequest("https://example.com");
+  hawk._intl.uninit();
+}
+
+function run_test() {
+  registerCleanupFunction(do_register_cleanup);
+
+  Services.prefs.setStringPref(
+    "services.common.log.logger.rest.request",
+    "Trace"
+  );
+  initTestLogging("Trace");
+
+  run_next_test();
+}
+
+add_test(function test_intl_accept_language() {
+  let testCount = 0;
+  let languages = [
+    "zu-NP;vo", // Nepalese dialect of Zulu, defaulting to Volapük
+    "fa-CG;ik", // Congolese dialect of Farsei, defaulting to Inupiaq
+  ];
+
+  function setLanguagePref(lang) {
+    Services.prefs.setStringPref("intl.accept_languages", lang);
+  }
+
+  let hawk = new HAWKAuthenticatedRESTRequest("https://example.com");
+
+  Services.prefs.addObserver("intl.accept_languages", checkLanguagePref);
+  setLanguagePref(languages[testCount]);
+
+  function checkLanguagePref() {
+    CommonUtils.nextTick(function () {
+      // Ensure we're only called for the number of entries in languages[].
+      Assert.ok(testCount < languages.length);
+
+      Assert.equal(hawk._intl.accept_languages, languages[testCount]);
+
+      testCount++;
+      if (testCount < languages.length) {
+        // Set next language in prefs; Pref service will call checkNextLanguage.
+        setLanguagePref(languages[testCount]);
+        return;
+      }
+
+      // We've checked all the entries in languages[]. Cleanup and move on.
+      info(
+        "Checked " +
+          testCount +
+          " languages. Removing checkLanguagePref as pref observer."
+      );
+      Services.prefs.removeObserver("intl.accept_languages", checkLanguagePref);
+      run_next_test();
+    });
+  }
+});
+
+add_task(async function test_hawk_authenticated_request() {
+  let postData = { your: "data" };
+
+  // An arbitrary date - Feb 2, 1971.  It ends in a bunch of zeroes to make our
+  // computation with the hawk timestamp easier, since hawk throws away the
+  // millisecond values.
+  let then = 34329600000;
+
+  let clockSkew = 120000;
+  let timeOffset = -1 * clockSkew;
+  let localTime = then + clockSkew;
+
+  // Set the accept-languages pref to the Nepalese dialect of Zulu.
+  let acceptLanguage = "zu-NP"; // omit trailing ';', which our HTTP libs snip
+  Services.prefs.setStringPref("intl.accept_languages", acceptLanguage);
+
+  let credentials = {
+    id: "eyJleHBpcmVzIjogMTM2NTAxMDg5OC4x",
+    key: "qTZf4ZFpAMpMoeSsX3zVRjiqmNs=",
+    algorithm: "sha256",
+  };
+
+  let server = httpd_setup({
+    "/elysium": function (request, response) {
+      Assert.ok(request.hasHeader("Authorization"));
+
+      // check that the header timestamp is our arbitrary system date, not
+      // today's date.  Note that hawk header timestamps are in seconds, not
+      // milliseconds.
+      let authorization = request.getHeader("Authorization");
+      let tsMS = parseInt(/ts="(\d+)"/.exec(authorization)[1], 10) * 1000;
+      Assert.equal(tsMS, then);
+
+      // This testing can be a little wonky. In an environment where
+      //   pref("intl.accept_languages") === 'en-US, en'
+      // the header is sent as:
+      //   'en-US,en;q=0.5'
+      // hence our fake value for acceptLanguage.
+      let lang = request.getHeader("Accept-Language");
+      Assert.equal(lang, acceptLanguage);
+
+      let message = "yay";
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.bodyOutputStream.write(message, message.length);
+    },
+  });
+
+  let url = server.baseURI + "/elysium";
+  let extra = {
+    now: localTime,
+    localtimeOffsetMsec: timeOffset,
+  };
+
+  let request = new HAWKAuthenticatedRESTRequest(url, credentials, extra);
+
+  // Allow hawk._intl to respond to the language pref change
+  await Async.promiseYield();
+
+  await request.post(postData);
+  Assert.equal(200, request.response.status);
+  Assert.equal(request.response.body, "yay");
+
+  Services.prefs.clearUserPref("intl.accept_languages");
+  let pref = Services.prefs.getComplexValue(
+    "intl.accept_languages",
+    Ci.nsIPrefLocalizedString
+  );
+  Assert.notEqual(acceptLanguage, pref.data);
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_hawk_language_pref_changed() {
+  let languages = [
+    "zu-NP", // Nepalese dialect of Zulu
+    "fa-CG", // Congolese dialect of Farsi
+  ];
+
+  let credentials = {
+    id: "eyJleHBpcmVzIjogMTM2NTAxMDg5OC4x",
+    key: "qTZf4ZFpAMpMoeSsX3zVRjiqmNs=",
+    algorithm: "sha256",
+  };
+
+  function setLanguage(lang) {
+    Services.prefs.setStringPref("intl.accept_languages", lang);
+  }
+
+  let server = httpd_setup({
+    "/foo": function (request, response) {
+      Assert.equal(languages[1], request.getHeader("Accept-Language"));
+
+      response.setStatusLine(request.httpVersion, 200, "OK");
+    },
+  });
+
+  let url = server.baseURI + "/foo";
+  let request;
+
+  setLanguage(languages[0]);
+
+  // A new request should create the stateful object for tracking the current
+  // language.
+  request = new HAWKAuthenticatedRESTRequest(url, credentials);
+
+  // Wait for change to propagate
+  await Async.promiseYield();
+  Assert.equal(languages[0], request._intl.accept_languages);
+
+  // Change the language pref ...
+  setLanguage(languages[1]);
+
+  await Async.promiseYield();
+
+  request = new HAWKAuthenticatedRESTRequest(url, credentials);
+  let response = await request.post({});
+
+  Assert.equal(200, response.status);
+  Services.prefs.clearUserPref("intl.accept_languages");
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_deriveHawkCredentials() {
+  let credentials = await deriveHawkCredentials(
+    SESSION_KEYS.sessionToken,
+    "sessionToken"
+  );
+  Assert.equal(credentials.id, SESSION_KEYS.tokenID);
+  Assert.equal(
+    CommonUtils.bytesAsHex(credentials.key),
+    SESSION_KEYS.reqHMACkey
+  );
+});
+
+// turn formatted test vectors into normal hex strings
+function h(hexStr) {
+  return hexStr.replace(/\s+/g, "");
+}
diff --git a/services/common/tests/unit/test_kinto.js b/services/common/tests/unit/test_kinto.js
new file mode 100644
index 0000000000..4b5e8471b1
--- /dev/null
+++ b/services/common/tests/unit/test_kinto.js
@@ -0,0 +1,512 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { Kinto } = ChromeUtils.import(
+  "resource://services-common/kinto-offline-client.js"
+);
+const { FirefoxAdapter } = ChromeUtils.importESModule(
+  "resource://services-common/kinto-storage-adapter.sys.mjs"
+);
+
+var server;
+
+// set up what we need to make storage adapters
+const kintoFilename = "kinto.sqlite";
+
+function do_get_kinto_sqliteHandle() {
+  return FirefoxAdapter.openConnection({ path: kintoFilename });
+}
+
+function do_get_kinto_collection(sqliteHandle, collection = "test_collection") {
+  let config = {
+    remote: `http://localhost:${server.identity.primaryPort}/v1/`,
+    headers: { Authorization: "Basic " + btoa("user:pass") },
+    adapter: FirefoxAdapter,
+    adapterOptions: { sqliteHandle },
+  };
+  return new Kinto(config).collection(collection);
+}
+
+async function clear_collection() {
+  let sqliteHandle;
+  try {
+    sqliteHandle = await do_get_kinto_sqliteHandle();
+    const collection = do_get_kinto_collection(sqliteHandle);
+    await collection.clear();
+  } finally {
+    await sqliteHandle.close();
+  }
+}
+
+// test some operations on a local collection
+add_task(async function test_kinto_add_get() {
+  let sqliteHandle;
+  try {
+    sqliteHandle = await do_get_kinto_sqliteHandle();
+    const collection = do_get_kinto_collection(sqliteHandle);
+
+    let newRecord = { foo: "bar" };
+    // check a record is created
+    let createResult = await collection.create(newRecord);
+    Assert.equal(createResult.data.foo, newRecord.foo);
+    // check getting the record gets the same info
+    let getResult = await collection.get(createResult.data.id);
+    deepEqual(createResult.data, getResult.data);
+    // check what happens if we create the same item again (it should throw
+    // since you can't create with id)
+    try {
+      await collection.create(createResult.data);
+      do_throw("Creation of a record with an id should fail");
+    } catch (err) {}
+    // try a few creates without waiting for the first few to resolve
+    let promises = [];
+    promises.push(collection.create(newRecord));
+    promises.push(collection.create(newRecord));
+    promises.push(collection.create(newRecord));
+    await collection.create(newRecord);
+    await Promise.all(promises);
+  } finally {
+    await sqliteHandle.close();
+  }
+});
+
+add_task(clear_collection);
+
+// test some operations on multiple connections
+add_task(async function test_kinto_add_get() {
+  let sqliteHandle;
+  try {
+    sqliteHandle = await do_get_kinto_sqliteHandle();
+    const collection1 = do_get_kinto_collection(sqliteHandle);
+    const collection2 = do_get_kinto_collection(
+      sqliteHandle,
+      "test_collection_2"
+    );
+
+    let newRecord = { foo: "bar" };
+
+    // perform several write operations alternately without waiting for promises
+    // to resolve
+    let promises = [];
+    for (let i = 0; i < 10; i++) {
+      promises.push(collection1.create(newRecord));
+      promises.push(collection2.create(newRecord));
+    }
+
+    // ensure subsequent operations still work
+    await Promise.all([
+      collection1.create(newRecord),
+      collection2.create(newRecord),
+    ]);
+    await Promise.all(promises);
+  } finally {
+    await sqliteHandle.close();
+  }
+});
+
+add_task(clear_collection);
+
+add_task(async function test_kinto_update() {
+  let sqliteHandle;
+  try {
+    sqliteHandle = await do_get_kinto_sqliteHandle();
+    const collection = do_get_kinto_collection(sqliteHandle);
+    const newRecord = { foo: "bar" };
+    // check a record is created
+    let createResult = await collection.create(newRecord);
+    Assert.equal(createResult.data.foo, newRecord.foo);
+    Assert.equal(createResult.data._status, "created");
+    // check we can update this OK
+    let copiedRecord = Object.assign(createResult.data, {});
+    deepEqual(createResult.data, copiedRecord);
+    copiedRecord.foo = "wibble";
+    let updateResult = await collection.update(copiedRecord);
+    // check the field was updated
+    Assert.equal(updateResult.data.foo, copiedRecord.foo);
+    // check the status is still "created", since we haven't synced
+    // the record
+    Assert.equal(updateResult.data._status, "created");
+  } finally {
+    await sqliteHandle.close();
+  }
+});
+
+add_task(clear_collection);
+
+add_task(async function test_kinto_clear() {
+  let sqliteHandle;
+  try {
+    sqliteHandle = await do_get_kinto_sqliteHandle();
+    const collection = do_get_kinto_collection(sqliteHandle);
+
+    // create an expected number of records
+    const expected = 10;
+    const newRecord = { foo: "bar" };
+    for (let i = 0; i < expected; i++) {
+      await collection.create(newRecord);
+    }
+    // check the collection contains the correct number
+    let list = await collection.list();
+    Assert.equal(list.data.length, expected);
+    // clear the collection and check again - should be 0
+    await collection.clear();
+    list = await collection.list();
+    Assert.equal(list.data.length, 0);
+  } finally {
+    await sqliteHandle.close();
+  }
+});
+
+add_task(clear_collection);
+
+add_task(async function test_kinto_delete() {
+  let sqliteHandle;
+  try {
+    sqliteHandle = await do_get_kinto_sqliteHandle();
+    const collection = do_get_kinto_collection(sqliteHandle);
+    const newRecord = { foo: "bar" };
+    // check a record is created
+    let createResult = await collection.create(newRecord);
+    Assert.equal(createResult.data.foo, newRecord.foo);
+    // check getting the record gets the same info
+    let getResult = await collection.get(createResult.data.id);
+    deepEqual(createResult.data, getResult.data);
+    // delete that record
+    let deleteResult = await collection.delete(createResult.data.id);
+    // check the ID is set on the result
+    Assert.equal(getResult.data.id, deleteResult.data.id);
+    // and check that get no longer returns the record
+    try {
+      getResult = await collection.get(createResult.data.id);
+      do_throw("there should not be a result");
+    } catch (e) {}
+  } finally {
+    await sqliteHandle.close();
+  }
+});
+
+add_task(async function test_kinto_list() {
+  let sqliteHandle;
+  try {
+    sqliteHandle = await do_get_kinto_sqliteHandle();
+    const collection = do_get_kinto_collection(sqliteHandle);
+    const expected = 10;
+    const created = [];
+    for (let i = 0; i < expected; i++) {
+      let newRecord = { foo: "test " + i };
+      let createResult = await collection.create(newRecord);
+      created.push(createResult.data);
+    }
+    // check the collection contains the correct number
+    let list = await collection.list();
+    Assert.equal(list.data.length, expected);
+
+    // check that all created records exist in the retrieved list
+    for (let createdRecord of created) {
+      let found = false;
+      for (let retrievedRecord of list.data) {
+        if (createdRecord.id == retrievedRecord.id) {
+          deepEqual(createdRecord, retrievedRecord);
+          found = true;
+        }
+      }
+      Assert.ok(found);
+    }
+  } finally {
+    await sqliteHandle.close();
+  }
+});
+
+add_task(clear_collection);
+
+add_task(async function test_importBulk_ignores_already_imported_records() {
+  let sqliteHandle;
+  try {
+    sqliteHandle = await do_get_kinto_sqliteHandle();
+    const collection = do_get_kinto_collection(sqliteHandle);
+    const record = {
+      id: "41b71c13-17e9-4ee3-9268-6a41abf9730f",
+      title: "foo",
+      last_modified: 1457896541,
+    };
+    await collection.importBulk([record]);
+    let impactedRecords = await collection.importBulk([record]);
+    Assert.equal(impactedRecords.length, 0);
+  } finally {
+    await sqliteHandle.close();
+  }
+});
+
+add_task(clear_collection);
+
+add_task(async function test_loadDump_should_overwrite_old_records() {
+  let sqliteHandle;
+  try {
+    sqliteHandle = await do_get_kinto_sqliteHandle();
+    const collection = do_get_kinto_collection(sqliteHandle);
+    const record = {
+      id: "41b71c13-17e9-4ee3-9268-6a41abf9730f",
+      title: "foo",
+      last_modified: 1457896541,
+    };
+    await collection.loadDump([record]);
+    const updated = Object.assign({}, record, { last_modified: 1457896543 });
+    let impactedRecords = await collection.loadDump([updated]);
+    Assert.equal(impactedRecords.length, 1);
+  } finally {
+    await sqliteHandle.close();
+  }
+});
+
+add_task(clear_collection);
+
+add_task(async function test_loadDump_should_not_overwrite_unsynced_records() {
+  let sqliteHandle;
+  try {
+    sqliteHandle = await do_get_kinto_sqliteHandle();
+    const collection = do_get_kinto_collection(sqliteHandle);
+    const recordId = "41b71c13-17e9-4ee3-9268-6a41abf9730f";
+    await collection.create(
+      { id: recordId, title: "foo" },
+      { useRecordId: true }
+    );
+    const record = { id: recordId, title: "bar", last_modified: 1457896541 };
+    let impactedRecords = await collection.loadDump([record]);
+    Assert.equal(impactedRecords.length, 0);
+  } finally {
+    await sqliteHandle.close();
+  }
+});
+
+add_task(clear_collection);
+
+add_task(
+  async function test_loadDump_should_not_overwrite_records_without_last_modified() {
+    let sqliteHandle;
+    try {
+      sqliteHandle = await do_get_kinto_sqliteHandle();
+      const collection = do_get_kinto_collection(sqliteHandle);
+      const recordId = "41b71c13-17e9-4ee3-9268-6a41abf9730f";
+      await collection.create({ id: recordId, title: "foo" }, { synced: true });
+      const record = { id: recordId, title: "bar", last_modified: 1457896541 };
+      let impactedRecords = await collection.loadDump([record]);
+      Assert.equal(impactedRecords.length, 0);
+    } finally {
+      await sqliteHandle.close();
+    }
+  }
+);
+
+add_task(clear_collection);
+
+// Now do some sanity checks against a server - we're not looking to test
+// core kinto.js functionality here (there is excellent test coverage in
+// kinto.js), more making sure things are basically working as expected.
+add_task(async function test_kinto_sync() {
+  const configPath = "/v1/";
+  const metadataPath = "/v1/buckets/default/collections/test_collection";
+  const recordsPath = "/v1/buckets/default/collections/test_collection/records";
+  // register a handler
+  function handleResponse(request, response) {
+    try {
+      const sampled = getSampleResponse(request, server.identity.primaryPort);
+      if (!sampled) {
+        do_throw(
+          `unexpected ${request.method} request for ${request.path}?${request.queryString}`
+        );
+      }
+
+      response.setStatusLine(
+        null,
+        sampled.status.status,
+        sampled.status.statusText
+      );
+      // send the headers
+      for (let headerLine of sampled.sampleHeaders) {
+        let headerElements = headerLine.split(":");
+        response.setHeader(headerElements[0], headerElements[1].trimLeft());
+      }
+      response.setHeader("Date", new Date().toUTCString());
+
+      response.write(sampled.responseBody);
+    } catch (e) {
+      dump(`${e}\n`);
+    }
+  }
+  server.registerPathHandler(configPath, handleResponse);
+  server.registerPathHandler(metadataPath, handleResponse);
+  server.registerPathHandler(recordsPath, handleResponse);
+
+  // create an empty collection, sync to populate
+  let sqliteHandle;
+  try {
+    let result;
+    sqliteHandle = await do_get_kinto_sqliteHandle();
+    const collection = do_get_kinto_collection(sqliteHandle);
+
+    result = await collection.sync();
+    Assert.ok(result.ok);
+
+    // our test data has a single record; it should be in the local collection
+    let list = await collection.list();
+    Assert.equal(list.data.length, 1);
+
+    // now sync again; we should now have 2 records
+    result = await collection.sync();
+    Assert.ok(result.ok);
+    list = await collection.list();
+    Assert.equal(list.data.length, 2);
+
+    // sync again; the second records should have been modified
+    const before = list.data[0].title;
+    result = await collection.sync();
+    Assert.ok(result.ok);
+    list = await collection.list();
+    const after = list.data[1].title;
+    Assert.notEqual(before, after);
+
+    const manualID = list.data[0].id;
+    Assert.equal(list.data.length, 3);
+    Assert.equal(manualID, "some-manually-chosen-id");
+  } finally {
+    await sqliteHandle.close();
+  }
+});
+
+function run_test() {
+  // Set up an HTTP Server
+  server = new HttpServer();
+  server.start(-1);
+
+  run_next_test();
+
+  registerCleanupFunction(function () {
+    server.stop(function () {});
+  });
+}
+
+// get a response for a given request from sample data
+function getSampleResponse(req, port) {
+  const responses = {
+    OPTIONS: {
+      sampleHeaders: [
+        "Access-Control-Allow-Headers: Content-Length,Expires,Backoff,Retry-After,Last-Modified,Total-Records,ETag,Pragma,Cache-Control,authorization,content-type,if-none-match,Alert,Next-Page",
+        "Access-Control-Allow-Methods: GET,HEAD,OPTIONS,POST,DELETE,OPTIONS",
+        "Access-Control-Allow-Origin: *",
+        "Content-Type: application/json; charset=UTF-8",
+        "Server: waitress",
+      ],
+      status: { status: 200, statusText: "OK" },
+      responseBody: "null",
+    },
+    "GET:/v1/?": {
+      sampleHeaders: [
+        "Access-Control-Allow-Origin: *",
+        "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
+        "Content-Type: application/json; charset=UTF-8",
+        "Server: waitress",
+      ],
+      status: { status: 200, statusText: "OK" },
+      responseBody: JSON.stringify({
+        settings: {
+          batch_max_requests: 25,
+        },
+        url: `http://localhost:${port}/v1/`,
+        documentation: "https://kinto.readthedocs.org/",
+        version: "1.5.1",
+        commit: "cbc6f58",
+        hello: "kinto",
+      }),
+    },
+    "GET:/v1/buckets/default/collections/test_collection": {
+      sampleHeaders: [
+        "Access-Control-Allow-Origin: *",
+        "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
+        "Content-Type: application/json; charset=UTF-8",
+        "Server: waitress",
+        'Etag: "1234"',
+      ],
+      status: { status: 200, statusText: "OK" },
+      responseBody: JSON.stringify({
+        data: {
+          id: "test_collection",
+          last_modified: 1234,
+        },
+      }),
+    },
+    "GET:/v1/buckets/default/collections/test_collection/records?_sort=-last_modified":
+      {
+        sampleHeaders: [
+          "Access-Control-Allow-Origin: *",
+          "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
+          "Content-Type: application/json; charset=UTF-8",
+          "Server: waitress",
+          'Etag: "1445606341071"',
+        ],
+        status: { status: 200, statusText: "OK" },
+        responseBody: JSON.stringify({
+          data: [
+            {
+              last_modified: 1445606341071,
+              done: false,
+              id: "68db8313-686e-4fff-835e-07d78ad6f2af",
+              title: "New test",
+            },
+          ],
+        }),
+      },
+    "GET:/v1/buckets/default/collections/test_collection/records?_sort=-last_modified&_since=1445606341071":
+      {
+        sampleHeaders: [
+          "Access-Control-Allow-Origin: *",
+          "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
+          "Content-Type: application/json; charset=UTF-8",
+          "Server: waitress",
+          'Etag: "1445607941223"',
+        ],
+        status: { status: 200, statusText: "OK" },
+        responseBody: JSON.stringify({
+          data: [
+            {
+              last_modified: 1445607941223,
+              done: false,
+              id: "901967b0-f729-4b30-8d8d-499cba7f4b1d",
+              title: "Another new test",
+            },
+          ],
+        }),
+      },
+    "GET:/v1/buckets/default/collections/test_collection/records?_sort=-last_modified&_since=1445607941223":
+      {
+        sampleHeaders: [
+          "Access-Control-Allow-Origin: *",
+          "Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
+          "Content-Type: application/json; charset=UTF-8",
+          "Server: waitress",
+          'Etag: "1445607541267"',
+        ],
+        status: { status: 200, statusText: "OK" },
+        responseBody: JSON.stringify({
+          data: [
+            {
+              last_modified: 1445607541265,
+              done: false,
+              id: "901967b0-f729-4b30-8d8d-499cba7f4b1d",
+              title: "Modified title",
+            },
+            {
+              last_modified: 1445607541267,
+              done: true,
+              id: "some-manually-chosen-id",
+              title: "New record with custom ID",
+            },
+          ],
+        }),
+      },
+  };
+  return (
+    responses[`${req.method}:${req.path}?${req.queryString}`] ||
+    responses[`${req.method}:${req.path}`] ||
+    responses[req.method]
+  );
+}
diff --git a/services/common/tests/unit/test_load_modules.js b/services/common/tests/unit/test_load_modules.js
new file mode 100644
index 0000000000..0c80899e1c
--- /dev/null
+++ b/services/common/tests/unit/test_load_modules.js
@@ -0,0 +1,55 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+
+const MODULE_BASE = "resource://services-common/";
+const shared_modules = ["async.js", "logmanager.js", "rest.js", "utils.js"];
+
+const non_android_modules = ["tokenserverclient.js"];
+
+const TEST_BASE = "resource://testing-common/services/common/";
+const shared_test_modules = ["logging.js"];
+
+function expectImportsToSucceed(mm, base = MODULE_BASE) {
+  for (let m of mm) {
+    let resource = base + m;
+    let succeeded = false;
+    try {
+      ChromeUtils.import(resource);
+      succeeded = true;
+    } catch (e) {}
+
+    if (!succeeded) {
+      throw new Error(`Importing ${resource} should have succeeded!`);
+    }
+  }
+}
+
+function expectImportsToFail(mm, base = MODULE_BASE) {
+  for (let m of mm) {
+    let resource = base + m;
+    let succeeded = false;
+    try {
+      ChromeUtils.import(resource);
+      succeeded = true;
+    } catch (e) {}
+
+    if (succeeded) {
+      throw new Error(`Importing ${resource} should have failed!`);
+    }
+  }
+}
+
+function run_test() {
+  expectImportsToSucceed(shared_modules);
+  expectImportsToSucceed(shared_test_modules, TEST_BASE);
+
+  if (AppConstants.platform != "android") {
+    expectImportsToSucceed(non_android_modules);
+  } else {
+    expectImportsToFail(non_android_modules);
+  }
+}
diff --git a/services/common/tests/unit/test_logmanager.js b/services/common/tests/unit/test_logmanager.js
new file mode 100644
index 0000000000..f7598a71ed
--- /dev/null
+++ b/services/common/tests/unit/test_logmanager.js
@@ -0,0 +1,321 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// NOTE: The sync test_errorhandler_* tests have quite good coverage for
+// other aspects of this.
+
+const { LogManager } = ChromeUtils.importESModule(
+  "resource://services-common/logmanager.sys.mjs"
+);
+const { FileUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/FileUtils.sys.mjs"
+);
+
+// Returns an array of [consoleAppender, dumpAppender, [fileAppenders]] for
+// the specified log.  Note that fileAppenders will usually have length=1
+function getAppenders(log) {
+  let capps = log.appenders.filter(app => app instanceof Log.ConsoleAppender);
+  equal(capps.length, 1, "should only have one console appender");
+  let dapps = log.appenders.filter(app => app instanceof Log.DumpAppender);
+  equal(dapps.length, 1, "should only have one dump appender");
+  let fapps = log.appenders.filter(
+    app => app instanceof LogManager.StorageStreamAppender
+  );
+  return [capps[0], dapps[0], fapps];
+}
+
+// Test that the correct thing happens when no prefs exist for the log manager.
+add_task(async function test_noPrefs() {
+  // tell the log manager to init with a pref branch that doesn't exist.
+  let lm = new LogManager("no-such-branch.", ["TestLog"], "test");
+
+  let log = Log.repository.getLogger("TestLog");
+  let [capp, dapp, fapps] = getAppenders(log);
+  // The console appender gets "Fatal" while the "dump" appender gets "Error" levels
+  equal(capp.level, Log.Level.Fatal);
+  equal(dapp.level, Log.Level.Error);
+  // and the file (stream) appender gets Debug by default
+  equal(fapps.length, 1, "only 1 file appender");
+  equal(fapps[0].level, Log.Level.Debug);
+  lm.finalize();
+});
+
+// Test that changes to the prefs used by the log manager are updated dynamically.
+add_task(async function test_PrefChanges() {
+  Services.prefs.setCharPref("log-manager.test.log.appender.console", "Trace");
+  Services.prefs.setCharPref("log-manager.test.log.appender.dump", "Trace");
+  Services.prefs.setCharPref(
+    "log-manager.test.log.appender.file.level",
+    "Trace"
+  );
+  let lm = new LogManager("log-manager.test.", ["TestLog2"], "test");
+
+  let log = Log.repository.getLogger("TestLog2");
+  let [capp, dapp, [fapp]] = getAppenders(log);
+  equal(capp.level, Log.Level.Trace);
+  equal(dapp.level, Log.Level.Trace);
+  equal(fapp.level, Log.Level.Trace);
+  // adjust the prefs and they should magically be reflected in the appenders.
+  Services.prefs.setCharPref("log-manager.test.log.appender.console", "Debug");
+  Services.prefs.setCharPref("log-manager.test.log.appender.dump", "Debug");
+  Services.prefs.setCharPref(
+    "log-manager.test.log.appender.file.level",
+    "Debug"
+  );
+  equal(capp.level, Log.Level.Debug);
+  equal(dapp.level, Log.Level.Debug);
+  equal(fapp.level, Log.Level.Debug);
+  // and invalid values should cause them to fallback to their defaults.
+  Services.prefs.setCharPref("log-manager.test.log.appender.console", "xxx");
+  Services.prefs.setCharPref("log-manager.test.log.appender.dump", "xxx");
+  Services.prefs.setCharPref("log-manager.test.log.appender.file.level", "xxx");
+  equal(capp.level, Log.Level.Fatal);
+  equal(dapp.level, Log.Level.Error);
+  equal(fapp.level, Log.Level.Debug);
+  lm.finalize();
+});
+
+// Test that the same log used by multiple log managers does the right thing.
+add_task(async function test_SharedLogs() {
+  // create the prefs for the first instance.
+  Services.prefs.setCharPref(
+    "log-manager-1.test.log.appender.console",
+    "Trace"
+  );
+  Services.prefs.setCharPref("log-manager-1.test.log.appender.dump", "Trace");
+  Services.prefs.setCharPref(
+    "log-manager-1.test.log.appender.file.level",
+    "Trace"
+  );
+  let lm1 = new LogManager("log-manager-1.test.", ["TestLog3"], "test");
+
+  // and the second.
+  Services.prefs.setCharPref(
+    "log-manager-2.test.log.appender.console",
+    "Debug"
+  );
+  Services.prefs.setCharPref("log-manager-2.test.log.appender.dump", "Debug");
+  Services.prefs.setCharPref(
+    "log-manager-2.test.log.appender.file.level",
+    "Debug"
+  );
+  let lm2 = new LogManager("log-manager-2.test.", ["TestLog3"], "test");
+
+  let log = Log.repository.getLogger("TestLog3");
+  let [capp, dapp] = getAppenders(log);
+
+  // console and dump appenders should be "trace" as it is more verbose than
+  // "debug"
+  equal(capp.level, Log.Level.Trace);
+  equal(dapp.level, Log.Level.Trace);
+
+  // Set the prefs on the -1 branch to "Error" - it should then end up with
+  // "Debug" from the -2 branch.
+  Services.prefs.setCharPref(
+    "log-manager-1.test.log.appender.console",
+    "Error"
+  );
+  Services.prefs.setCharPref("log-manager-1.test.log.appender.dump", "Error");
+  Services.prefs.setCharPref(
+    "log-manager-1.test.log.appender.file.level",
+    "Error"
+  );
+
+  equal(capp.level, Log.Level.Debug);
+  equal(dapp.level, Log.Level.Debug);
+
+  lm1.finalize();
+  lm2.finalize();
+});
+
+// A little helper to test what log files exist.  We expect exactly zero (if
+// prefix is null) or exactly one with the specified prefix.
+function checkLogFile(prefix) {
+  let logsdir = FileUtils.getDir("ProfD", ["weave", "logs"], true);
+  let entries = logsdir.directoryEntries;
+  if (!prefix) {
+    // expecting no files.
+    ok(!entries.hasMoreElements());
+  } else {
+    // expecting 1 file.
+    ok(entries.hasMoreElements());
+    let logfile = entries.getNext().QueryInterface(Ci.nsIFile);
+    equal(logfile.leafName.slice(-4), ".txt");
+    ok(logfile.leafName.startsWith(prefix + "-test-"), logfile.leafName);
+    // and remove it ready for the next check.
+    logfile.remove(false);
+  }
+}
+
+// Test that we correctly write error logs by default
+add_task(async function test_logFileErrorDefault() {
+  let lm = new LogManager("log-manager.test.", ["TestLog2"], "test");
+
+  let log = Log.repository.getLogger("TestLog2");
+  log.error("an error message");
+  await lm.resetFileLog(lm.REASON_ERROR);
+  // One error log file exists.
+  checkLogFile("error");
+
+  lm.finalize();
+});
+
+// Test that we correctly write success logs.
+add_task(async function test_logFileSuccess() {
+  Services.prefs.setBoolPref(
+    "log-manager.test.log.appender.file.logOnError",
+    false
+  );
+  Services.prefs.setBoolPref(
+    "log-manager.test.log.appender.file.logOnSuccess",
+    false
+  );
+
+  let lm = new LogManager("log-manager.test.", ["TestLog2"], "test");
+
+  let log = Log.repository.getLogger("TestLog2");
+  log.info("an info message");
+  await lm.resetFileLog();
+  // Zero log files exist.
+  checkLogFile(null);
+
+  // Reset logOnSuccess and do it again - log should appear.
+  Services.prefs.setBoolPref(
+    "log-manager.test.log.appender.file.logOnSuccess",
+    true
+  );
+  log.info("an info message");
+  await lm.resetFileLog();
+
+  checkLogFile("success");
+
+  // Now test with no "reason" specified and no "error" record.
+  log.info("an info message");
+  await lm.resetFileLog();
+  // should get a "success" entry.
+  checkLogFile("success");
+
+  // With no "reason" and an error record - should get no success log.
+  log.error("an error message");
+  await lm.resetFileLog();
+  // should get no entry
+  checkLogFile(null);
+
+  // And finally now with no error, to ensure that the fact we had an error
+  // previously doesn't persist after the .resetFileLog call.
+  log.info("an info message");
+  await lm.resetFileLog();
+  checkLogFile("success");
+
+  lm.finalize();
+});
+
+// Test that we correctly write error logs.
+add_task(async function test_logFileError() {
+  Services.prefs.setBoolPref(
+    "log-manager.test.log.appender.file.logOnError",
+    false
+  );
+  Services.prefs.setBoolPref(
+    "log-manager.test.log.appender.file.logOnSuccess",
+    false
+  );
+
+  let lm = new LogManager("log-manager.test.", ["TestLog2"], "test");
+
+  let log = Log.repository.getLogger("TestLog2");
+  log.info("an info message");
+  let reason = await lm.resetFileLog();
+  Assert.equal(reason, null, "null returned when no file created.");
+  // Zero log files exist.
+  checkLogFile(null);
+
+  // Reset logOnSuccess - success logs should appear if no error records.
+  Services.prefs.setBoolPref(
+    "log-manager.test.log.appender.file.logOnSuccess",
+    true
+  );
+  log.info("an info message");
+  reason = await lm.resetFileLog();
+  Assert.equal(reason, lm.SUCCESS_LOG_WRITTEN);
+  checkLogFile("success");
+
+  // Set logOnError and unset logOnSuccess - error logs should appear.
+  Services.prefs.setBoolPref(
+    "log-manager.test.log.appender.file.logOnSuccess",
+    false
+  );
+  Services.prefs.setBoolPref(
+    "log-manager.test.log.appender.file.logOnError",
+    true
+  );
+  log.error("an error message");
+  reason = await lm.resetFileLog();
+  Assert.equal(reason, lm.ERROR_LOG_WRITTEN);
+  checkLogFile("error");
+
+  // Now test with no "error" record.
+  log.info("an info message");
+  reason = await lm.resetFileLog();
+  // should get no file
+  Assert.equal(reason, null);
+  checkLogFile(null);
+
+  // With an error record we should get an error log.
+  log.error("an error message");
+  reason = await lm.resetFileLog();
+  // should get en error log
+  Assert.equal(reason, lm.ERROR_LOG_WRITTEN);
+  checkLogFile("error");
+
+  // And finally now with success, to ensure that the fact we had an error
+  // previously doesn't persist after the .resetFileLog call.
+  log.info("an info message");
+  await lm.resetFileLog();
+  checkLogFile(null);
+
+  lm.finalize();
+});
+
+function countLogFiles() {
+  let logsdir = FileUtils.getDir("ProfD", ["weave", "logs"], true);
+  let count = 0;
+  for (let entry of logsdir.directoryEntries) {
+    void entry;
+    count += 1;
+  }
+  return count;
+}
+
+// Test that removeAllLogs removes all log files.
+add_task(async function test_logFileError() {
+  Services.prefs.setBoolPref(
+    "log-manager.test.log.appender.file.logOnError",
+    true
+  );
+  Services.prefs.setBoolPref(
+    "log-manager.test.log.appender.file.logOnSuccess",
+    true
+  );
+
+  let lm = new LogManager("log-manager.test.", ["TestLog2"], "test");
+
+  let log = Log.repository.getLogger("TestLog2");
+  log.info("an info message");
+  let reason = await lm.resetFileLog();
+  Assert.equal(reason, lm.SUCCESS_LOG_WRITTEN, "success log was written.");
+
+  log.error("an error message");
+  reason = await lm.resetFileLog();
+  Assert.equal(reason, lm.ERROR_LOG_WRITTEN);
+
+  Assert.equal(countLogFiles(), 2, "expect 2 log files");
+  await lm.removeAllLogs();
+  Assert.equal(
+    countLogFiles(),
+    0,
+    "should be no log files after removing them"
+  );
+
+  lm.finalize();
+});
diff --git a/services/common/tests/unit/test_observers.js b/services/common/tests/unit/test_observers.js
new file mode 100644
index 0000000000..b0fce95e0b
--- /dev/null
+++ b/services/common/tests/unit/test_observers.js
@@ -0,0 +1,82 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { Observers } = ChromeUtils.importESModule(
+  "resource://services-common/observers.sys.mjs"
+);
+
+var gSubject = {};
+
+add_test(function test_function_observer() {
+  let foo = false;
+
+  let onFoo = function (subject, data) {
+    foo = !foo;
+    Assert.equal(subject, gSubject);
+    Assert.equal(data, "some data");
+  };
+
+  Observers.add("foo", onFoo);
+  Observers.notify("foo", gSubject, "some data");
+
+  // The observer was notified after being added.
+  Assert.ok(foo);
+
+  Observers.remove("foo", onFoo);
+  Observers.notify("foo");
+
+  // The observer was not notified after being removed.
+  Assert.ok(foo);
+
+  run_next_test();
+});
+
+add_test(function test_method_observer() {
+  let obj = {
+    foo: false,
+    onFoo(subject, data) {
+      this.foo = !this.foo;
+      Assert.equal(subject, gSubject);
+      Assert.equal(data, "some data");
+    },
+  };
+
+  // The observer is notified after being added.
+  Observers.add("foo", obj.onFoo, obj);
+  Observers.notify("foo", gSubject, "some data");
+  Assert.ok(obj.foo);
+
+  // The observer is not notified after being removed.
+  Observers.remove("foo", obj.onFoo, obj);
+  Observers.notify("foo");
+  Assert.ok(obj.foo);
+
+  run_next_test();
+});
+
+add_test(function test_object_observer() {
+  let obj = {
+    foo: false,
+    observe(subject, topic, data) {
+      this.foo = !this.foo;
+
+      Assert.equal(subject, gSubject);
+      Assert.equal(topic, "foo");
+      Assert.equal(data, "some data");
+    },
+  };
+
+  Observers.add("foo", obj);
+  Observers.notify("foo", gSubject, "some data");
+
+  // The observer is notified after being added.
+  Assert.ok(obj.foo);
+
+  Observers.remove("foo", obj);
+  Observers.notify("foo");
+
+  // The observer is not notified after being removed.
+  Assert.ok(obj.foo);
+
+  run_next_test();
+});
diff --git a/services/common/tests/unit/test_restrequest.js b/services/common/tests/unit/test_restrequest.js
new file mode 100644
index 0000000000..9ae5e9429a
--- /dev/null
+++ b/services/common/tests/unit/test_restrequest.js
@@ -0,0 +1,860 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { RESTRequest } = ChromeUtils.importESModule(
+  "resource://services-common/rest.sys.mjs"
+);
+
+function run_test() {
+  Log.repository.getLogger("Services.Common.RESTRequest").level =
+    Log.Level.Trace;
+  initTestLogging("Trace");
+
+  run_next_test();
+}
+
+/**
+ * Initializing a RESTRequest with an invalid URI throws
+ * NS_ERROR_MALFORMED_URI.
+ */
+add_test(function test_invalid_uri() {
+  do_check_throws(function () {
+    new RESTRequest("an invalid URI");
+  }, Cr.NS_ERROR_MALFORMED_URI);
+  run_next_test();
+});
+
+/**
+ * Verify initial values for attributes.
+ */
+add_test(function test_attributes() {
+  let uri = "http://foo.com/bar/baz";
+  let request = new RESTRequest(uri);
+
+  Assert.ok(request.uri instanceof Ci.nsIURI);
+  Assert.equal(request.uri.spec, uri);
+  Assert.equal(request.response, null);
+  Assert.equal(request.status, request.NOT_SENT);
+  let expectedLoadFlags =
+    Ci.nsIRequest.LOAD_BYPASS_CACHE |
+    Ci.nsIRequest.INHIBIT_CACHING |
+    Ci.nsIRequest.LOAD_ANONYMOUS;
+  Assert.equal(request.loadFlags, expectedLoadFlags);
+
+  run_next_test();
+});
+
+/**
+ * Verify that a proxy auth redirect doesn't break us. This has to be the first
+ * request made in the file!
+ */
+add_task(async function test_proxy_auth_redirect() {
+  let pacFetched = false;
+  function pacHandler(metadata, response) {
+    pacFetched = true;
+    let body = 'function FindProxyForURL(url, host) { return "DIRECT"; }';
+    response.setStatusLine(metadata.httpVersion, 200, "OK");
+    response.setHeader(
+      "Content-Type",
+      "application/x-ns-proxy-autoconfig",
+      false
+    );
+    response.bodyOutputStream.write(body, body.length);
+  }
+
+  let fetched = false;
+  function original(metadata, response) {
+    fetched = true;
+    let body = "TADA!";
+    response.setStatusLine(metadata.httpVersion, 200, "OK");
+    response.bodyOutputStream.write(body, body.length);
+  }
+
+  let server = httpd_setup({
+    "/original": original,
+    "/pac3": pacHandler,
+  });
+  PACSystemSettings.PACURI = server.baseURI + "/pac3";
+  installFakePAC();
+
+  let req = new RESTRequest(server.baseURI + "/original");
+  await req.get();
+
+  Assert.ok(pacFetched);
+  Assert.ok(fetched);
+
+  Assert.ok(req.response.success);
+  Assert.equal("TADA!", req.response.body);
+  uninstallFakePAC();
+  await promiseStopServer(server);
+});
+
+/**
+ * Ensure that failures that cause asyncOpen to throw
+ * result in callbacks being invoked.
+ * Bug 826086.
+ */
+add_task(async function test_forbidden_port() {
+  let request = new RESTRequest("http://localhost:6000/");
+
+  await Assert.rejects(
+    request.get(),
+    error => error.result == Cr.NS_ERROR_PORT_ACCESS_NOT_ALLOWED
+  );
+});
+
+/**
+ * Demonstrate API short-hand: create a request and dispatch it immediately.
+ */
+add_task(async function test_simple_get() {
+  let handler = httpd_handler(200, "OK", "Huzzah!");
+  let server = httpd_setup({ "/resource": handler });
+  let request = new RESTRequest(server.baseURI + "/resource");
+  let promiseResponse = request.get();
+
+  Assert.equal(request.status, request.SENT);
+  Assert.equal(request.method, "GET");
+
+  let response = await promiseResponse;
+  Assert.equal(response, request.response);
+
+  Assert.equal(request.status, request.COMPLETED);
+  Assert.ok(response.success);
+  Assert.equal(response.status, 200);
+  Assert.equal(response.body, "Huzzah!");
+  await promiseStopServer(server);
+});
+
+/**
+ * Test HTTP GET with all bells and whistles.
+ */
+add_task(async function test_get() {
+  let handler = httpd_handler(200, "OK", "Huzzah!");
+  let server = httpd_setup({ "/resource": handler });
+
+  let request = new RESTRequest(server.baseURI + "/resource");
+  Assert.equal(request.status, request.NOT_SENT);
+
+  let promiseResponse = request.get();
+
+  Assert.equal(request.status, request.SENT);
+  Assert.equal(request.method, "GET");
+
+  Assert.ok(!!(request.channel.loadFlags & Ci.nsIRequest.LOAD_BYPASS_CACHE));
+  Assert.ok(!!(request.channel.loadFlags & Ci.nsIRequest.INHIBIT_CACHING));
+
+  let response = await promiseResponse;
+
+  Assert.equal(response, request.response);
+  Assert.equal(request.status, request.COMPLETED);
+  Assert.ok(request.response.success);
+  Assert.equal(request.response.status, 200);
+  Assert.equal(request.response.body, "Huzzah!");
+  Assert.equal(handler.request.method, "GET");
+
+  await Assert.rejects(request.get(), /Request has already been sent/);
+
+  await promiseStopServer(server);
+});
+
+/**
+ * Test HTTP GET with UTF-8 content, and custom Content-Type.
+ */
+add_task(async function test_get_utf8() {
+  let response = "Hello World or Καλημέρα κόσμε or こんにちは 世界 😺";
+
+  let contentType = "text/plain";
+  let charset = true;
+  let charsetSuffix = "; charset=UTF-8";
+
+  let server = httpd_setup({
+    "/resource": function (req, res) {
+      res.setStatusLine(req.httpVersion, 200, "OK");
+      res.setHeader(
+        "Content-Type",
+        contentType + (charset ? charsetSuffix : "")
+      );
+
+      let converter = Cc[
+        "@mozilla.org/intl/converter-output-stream;1"
+      ].createInstance(Ci.nsIConverterOutputStream);
+      converter.init(res.bodyOutputStream, "UTF-8");
+      converter.writeString(response);
+      converter.close();
+    },
+  });
+
+  // Check if charset in Content-Type is propertly interpreted.
+  let request1 = new RESTRequest(server.baseURI + "/resource");
+  await request1.get();
+
+  Assert.equal(request1.response.status, 200);
+  Assert.equal(request1.response.body, response);
+  Assert.equal(
+    request1.response.headers["content-type"],
+    contentType + charsetSuffix
+  );
+
+  // Check that we default to UTF-8 if Content-Type doesn't have a charset
+  charset = false;
+  let request2 = new RESTRequest(server.baseURI + "/resource");
+  await request2.get();
+  Assert.equal(request2.response.status, 200);
+  Assert.equal(request2.response.body, response);
+  Assert.equal(request2.response.headers["content-type"], contentType);
+  Assert.equal(request2.response.charset, "utf-8");
+
+  let request3 = new RESTRequest(server.baseURI + "/resource");
+
+  // With the test server we tend to get onDataAvailable in chunks of 8192 (in
+  // real network requests there doesn't appear to be any pattern to the size of
+  // the data `onDataAvailable` is called with), the smiling cat emoji encodes as
+  // 4 bytes, and so when utf8 encoded, the `"a" + "😺".repeat(2048)` will not be
+  // aligned onto a codepoint.
+  //
+  // Since 8192 isn't guaranteed and could easily change, the following string is
+  // a) very long, and b) misaligned on roughly 3/4 of the bytes, as a safety
+  // measure.
+  response = ("a" + "😺".repeat(2048)).repeat(10);
+
+  await request3.get();
+
+  Assert.equal(request3.response.status, 200);
+
+  // Make sure it came through ok, despite the misalignment.
+  Assert.equal(request3.response.body, response);
+
+  await promiseStopServer(server);
+});
+
+/**
+ * Test HTTP POST data is encoded as UTF-8 by default.
+ */
+add_task(async function test_post_utf8() {
+  // We setup a handler that responds with exactly what it received.
+  // Given we've already tested above that responses are correctly utf-8
+  // decoded we can surmise that the correct response coming back means the
+  // input must also have been encoded.
+  let server = httpd_setup({
+    "/echo": function (req, res) {
+      res.setStatusLine(req.httpVersion, 200, "OK");
+      res.setHeader("Content-Type", req.getHeader("content-type"));
+      // Get the body as bytes and write them back without touching them
+      let sis = Cc["@mozilla.org/scriptableinputstream;1"].createInstance(
+        Ci.nsIScriptableInputStream
+      );
+      sis.init(req.bodyInputStream);
+      let body = sis.read(sis.available());
+      sis.close();
+      res.write(body);
+    },
+  });
+
+  let data = {
+    copyright: "©",
+    // See the comment in test_get_utf8 about this string.
+    long: ("a" + "😺".repeat(2048)).repeat(10),
+  };
+  let request1 = new RESTRequest(server.baseURI + "/echo");
+  await request1.post(data);
+
+  Assert.equal(request1.response.status, 200);
+  deepEqual(JSON.parse(request1.response.body), data);
+  Assert.equal(
+    request1.response.headers["content-type"],
+    "application/json; charset=utf-8"
+  );
+
+  await promiseStopServer(server);
+});
+
+/**
+ * Test more variations of charset handling.
+ */
+add_task(async function test_charsets() {
+  let response = "Hello World, I can't speak Russian";
+
+  let contentType = "text/plain";
+  let charset = true;
+  let charsetSuffix = "; charset=us-ascii";
+
+  let server = httpd_setup({
+    "/resource": function (req, res) {
+      res.setStatusLine(req.httpVersion, 200, "OK");
+      res.setHeader(
+        "Content-Type",
+        contentType + (charset ? charsetSuffix : "")
+      );
+
+      let converter = Cc[
+        "@mozilla.org/intl/converter-output-stream;1"
+      ].createInstance(Ci.nsIConverterOutputStream);
+      converter.init(res.bodyOutputStream, "us-ascii");
+      converter.writeString(response);
+      converter.close();
+    },
+  });
+
+  // Check that provided charset overrides hint.
+  let request1 = new RESTRequest(server.baseURI + "/resource");
+  request1.charset = "not-a-charset";
+  await request1.get();
+  Assert.equal(request1.response.status, 200);
+  Assert.equal(request1.response.body, response);
+  Assert.equal(
+    request1.response.headers["content-type"],
+    contentType + charsetSuffix
+  );
+  Assert.equal(request1.response.charset, "us-ascii");
+
+  // Check that hint is used if Content-Type doesn't have a charset.
+  charset = false;
+  let request2 = new RESTRequest(server.baseURI + "/resource");
+  request2.charset = "us-ascii";
+  await request2.get();
+
+  Assert.equal(request2.response.status, 200);
+  Assert.equal(request2.response.body, response);
+  Assert.equal(request2.response.headers["content-type"], contentType);
+  Assert.equal(request2.response.charset, "us-ascii");
+
+  await promiseStopServer(server);
+});
+
+/**
+ * Used for testing PATCH/PUT/POST methods.
+ */
+async function check_posting_data(method) {
+  let funcName = method.toLowerCase();
+  let handler = httpd_handler(200, "OK", "Got it!");
+  let server = httpd_setup({ "/resource": handler });
+
+  let request = new RESTRequest(server.baseURI + "/resource");
+  Assert.equal(request.status, request.NOT_SENT);
+  let responsePromise = request[funcName]("Hullo?");
+  Assert.equal(request.status, request.SENT);
+  Assert.equal(request.method, method);
+
+  let response = await responsePromise;
+
+  Assert.equal(response, request.response);
+
+  Assert.equal(request.status, request.COMPLETED);
+  Assert.ok(request.response.success);
+  Assert.equal(request.response.status, 200);
+  Assert.equal(request.response.body, "Got it!");
+
+  Assert.equal(handler.request.method, method);
+  Assert.equal(handler.request.body, "Hullo?");
+  Assert.equal(handler.request.getHeader("Content-Type"), "text/plain");
+
+  await Assert.rejects(
+    request[funcName]("Hai!"),
+    /Request has already been sent/
+  );
+
+  await promiseStopServer(server);
+}
+
+/**
+ * Test HTTP PATCH with a simple string argument and default Content-Type.
+ */
+add_task(async function test_patch() {
+  await check_posting_data("PATCH");
+});
+
+/**
+ * Test HTTP PUT with a simple string argument and default Content-Type.
+ */
+add_task(async function test_put() {
+  await check_posting_data("PUT");
+});
+
+/**
+ * Test HTTP POST with a simple string argument and default Content-Type.
+ */
+add_task(async function test_post() {
+  await check_posting_data("POST");
+});
+
+/**
+ * Test HTTP DELETE.
+ */
+add_task(async function test_delete() {
+  let handler = httpd_handler(200, "OK", "Got it!");
+  let server = httpd_setup({ "/resource": handler });
+
+  let request = new RESTRequest(server.baseURI + "/resource");
+  Assert.equal(request.status, request.NOT_SENT);
+  let responsePromise = request.delete();
+  Assert.equal(request.status, request.SENT);
+  Assert.equal(request.method, "DELETE");
+
+  let response = await responsePromise;
+  Assert.equal(response, request.response);
+
+  Assert.equal(request.status, request.COMPLETED);
+  Assert.ok(request.response.success);
+  Assert.equal(request.response.status, 200);
+  Assert.equal(request.response.body, "Got it!");
+  Assert.equal(handler.request.method, "DELETE");
+
+  await Assert.rejects(request.delete(), /Request has already been sent/);
+
+  await promiseStopServer(server);
+});
+
+/**
+ * Test an HTTP response with a non-200 status code.
+ */
+add_task(async function test_get_404() {
+  let handler = httpd_handler(404, "Not Found", "Cannae find it!");
+  let server = httpd_setup({ "/resource": handler });
+
+  let request = new RESTRequest(server.baseURI + "/resource");
+  await request.get();
+
+  Assert.equal(request.status, request.COMPLETED);
+  Assert.ok(!request.response.success);
+  Assert.equal(request.response.status, 404);
+  Assert.equal(request.response.body, "Cannae find it!");
+
+  await promiseStopServer(server);
+});
+
+/**
+ * The 'data' argument to PUT, if not a string already, is automatically
+ * stringified as JSON.
+ */
+add_task(async function test_put_json() {
+  let handler = httpd_handler(200, "OK");
+  let server = httpd_setup({ "/resource": handler });
+
+  let sample_data = {
+    some: "sample_data",
+    injson: "format",
+    number: 42,
+  };
+  let request = new RESTRequest(server.baseURI + "/resource");
+  await request.put(sample_data);
+
+  Assert.equal(request.status, request.COMPLETED);
+  Assert.ok(request.response.success);
+  Assert.equal(request.response.status, 200);
+  Assert.equal(request.response.body, "");
+
+  Assert.equal(handler.request.method, "PUT");
+  Assert.equal(handler.request.body, JSON.stringify(sample_data));
+  Assert.equal(
+    handler.request.getHeader("Content-Type"),
+    "application/json; charset=utf-8"
+  );
+
+  await promiseStopServer(server);
+});
+
+/**
+ * The 'data' argument to POST, if not a string already, is automatically
+ * stringified as JSON.
+ */
+add_task(async function test_post_json() {
+  let handler = httpd_handler(200, "OK");
+  let server = httpd_setup({ "/resource": handler });
+
+  let sample_data = {
+    some: "sample_data",
+    injson: "format",
+    number: 42,
+  };
+  let request = new RESTRequest(server.baseURI + "/resource");
+  await request.post(sample_data);
+
+  Assert.equal(request.status, request.COMPLETED);
+  Assert.ok(request.response.success);
+  Assert.equal(request.response.status, 200);
+  Assert.equal(request.response.body, "");
+
+  Assert.equal(handler.request.method, "POST");
+  Assert.equal(handler.request.body, JSON.stringify(sample_data));
+  Assert.equal(
+    handler.request.getHeader("Content-Type"),
+    "application/json; charset=utf-8"
+  );
+
+  await promiseStopServer(server);
+});
+
+/**
+ * The content-type will be text/plain without a charset if the 'data' argument
+ * to POST is already a string.
+ */
+add_task(async function test_post_json() {
+  let handler = httpd_handler(200, "OK");
+  let server = httpd_setup({ "/resource": handler });
+
+  let sample_data = "hello";
+  let request = new RESTRequest(server.baseURI + "/resource");
+  await request.post(sample_data);
+  Assert.equal(request.status, request.COMPLETED);
+  Assert.ok(request.response.success);
+  Assert.equal(request.response.status, 200);
+  Assert.equal(request.response.body, "");
+
+  Assert.equal(handler.request.method, "POST");
+  Assert.equal(handler.request.body, sample_data);
+  Assert.equal(handler.request.getHeader("Content-Type"), "text/plain");
+
+  await promiseStopServer(server);
+});
+
+/**
+ * HTTP PUT with a custom Content-Type header.
+ */
+add_task(async function test_put_override_content_type() {
+  let handler = httpd_handler(200, "OK");
+  let server = httpd_setup({ "/resource": handler });
+
+  let request = new RESTRequest(server.baseURI + "/resource");
+  request.setHeader("Content-Type", "application/lolcat");
+  await request.put("O HAI!!1!");
+
+  Assert.equal(request.status, request.COMPLETED);
+  Assert.ok(request.response.success);
+  Assert.equal(request.response.status, 200);
+  Assert.equal(request.response.body, "");
+
+  Assert.equal(handler.request.method, "PUT");
+  Assert.equal(handler.request.body, "O HAI!!1!");
+  Assert.equal(handler.request.getHeader("Content-Type"), "application/lolcat");
+
+  await promiseStopServer(server);
+});
+
+/**
+ * HTTP POST with a custom Content-Type header.
+ */
+add_task(async function test_post_override_content_type() {
+  let handler = httpd_handler(200, "OK");
+  let server = httpd_setup({ "/resource": handler });
+
+  let request = new RESTRequest(server.baseURI + "/resource");
+  request.setHeader("Content-Type", "application/lolcat");
+  await request.post("O HAI!!1!");
+
+  Assert.equal(request.status, request.COMPLETED);
+  Assert.ok(request.response.success);
+  Assert.equal(request.response.status, 200);
+  Assert.equal(request.response.body, "");
+
+  Assert.equal(handler.request.method, "POST");
+  Assert.equal(handler.request.body, "O HAI!!1!");
+  Assert.equal(handler.request.getHeader("Content-Type"), "application/lolcat");
+
+  await promiseStopServer(server);
+});
+
+/**
+ * No special headers are sent by default on a GET request.
+ */
+add_task(async function test_get_no_headers() {
+  let handler = httpd_handler(200, "OK");
+  let server = httpd_setup({ "/resource": handler });
+
+  let ignore_headers = [
+    "host",
+    "user-agent",
+    "accept",
+    "accept-language",
+    "accept-encoding",
+    "accept-charset",
+    "keep-alive",
+    "connection",
+    "pragma",
+    "cache-control",
+    "content-length",
+    "sec-fetch-dest",
+    "sec-fetch-mode",
+    "sec-fetch-site",
+    "sec-fetch-user",
+  ];
+  let request = new RESTRequest(server.baseURI + "/resource");
+  await request.get();
+
+  Assert.equal(request.response.status, 200);
+  Assert.equal(request.response.body, "");
+
+  let server_headers = handler.request.headers;
+  while (server_headers.hasMoreElements()) {
+    let header = server_headers.getNext().toString();
+    if (!ignore_headers.includes(header)) {
+      do_throw("Got unexpected header!");
+    }
+  }
+
+  await promiseStopServer(server);
+});
+
+/**
+ * Client includes default Accept header in API requests
+ */
+add_task(async function test_default_accept_headers() {
+  let handler = httpd_handler(200, "OK");
+  let server = httpd_setup({ "/resource": handler });
+
+  let request = new RESTRequest(server.baseURI + "/resource");
+  await request.get();
+
+  Assert.equal(request.response.status, 200);
+  Assert.equal(request.response.body, "");
+
+  let accept_header = handler.request.getHeader("accept");
+
+  Assert.ok(!accept_header.includes("text/html"));
+  Assert.ok(!accept_header.includes("application/xhtml+xml"));
+  Assert.ok(!accept_header.includes("applcation/xml"));
+
+  Assert.ok(
+    accept_header.includes("application/json") ||
+      accept_header.includes("application/newlines")
+  );
+
+  await promiseStopServer(server);
+});
+
+/**
+ * Test changing the URI after having created the request.
+ */
+add_task(async function test_changing_uri() {
+  let handler = httpd_handler(200, "OK");
+  let server = httpd_setup({ "/resource": handler });
+
+  let request = new RESTRequest("http://localhost:1234/the-wrong-resource");
+  request.uri = CommonUtils.makeURI(server.baseURI + "/resource");
+  let response = await request.get();
+  Assert.equal(response.status, 200);
+  await promiseStopServer(server);
+});
+
+/**
+ * Test setting HTTP request headers.
+ */
+add_task(async function test_request_setHeader() {
+  let handler = httpd_handler(200, "OK");
+  let server = httpd_setup({ "/resource": handler });
+
+  let request = new RESTRequest(server.baseURI + "/resource");
+
+  request.setHeader("X-What-Is-Weave", "awesome");
+  request.setHeader("X-WHAT-is-Weave", "more awesomer");
+  request.setHeader("Another-Header", "Hello World");
+  await request.get();
+
+  Assert.equal(request.response.status, 200);
+  Assert.equal(request.response.body, "");
+
+  Assert.equal(handler.request.getHeader("X-What-Is-Weave"), "more awesomer");
+  Assert.equal(handler.request.getHeader("another-header"), "Hello World");
+
+  await promiseStopServer(server);
+});
+
+/**
+ * Test receiving HTTP response headers.
+ */
+add_task(async function test_response_headers() {
+  function handler(request, response) {
+    response.setHeader("X-What-Is-Weave", "awesome");
+    response.setHeader("Another-Header", "Hello World");
+    response.setStatusLine(request.httpVersion, 200, "OK");
+  }
+  let server = httpd_setup({ "/resource": handler });
+  let request = new RESTRequest(server.baseURI + "/resource");
+  await request.get();
+
+  Assert.equal(request.response.status, 200);
+  Assert.equal(request.response.body, "");
+
+  Assert.equal(request.response.headers["x-what-is-weave"], "awesome");
+  Assert.equal(request.response.headers["another-header"], "Hello World");
+
+  await promiseStopServer(server);
+});
+
+/**
+ * The onComplete() handler gets called in case of any network errors
+ * (e.g. NS_ERROR_CONNECTION_REFUSED).
+ */
+add_task(async function test_connection_refused() {
+  let request = new RESTRequest("http://localhost:1234/resource");
+
+  // Fail the test if we resolve, return the error if we reject
+  await Assert.rejects(
+    request.get(),
+    error =>
+      error.result == Cr.NS_ERROR_CONNECTION_REFUSED &&
+      error.message == "NS_ERROR_CONNECTION_REFUSED"
+  );
+
+  Assert.equal(request.status, request.COMPLETED);
+});
+
+/**
+ * Abort a request that just sent off.
+ */
+add_task(async function test_abort() {
+  function handler() {
+    do_throw("Shouldn't have gotten here!");
+  }
+  let server = httpd_setup({ "/resource": handler });
+
+  let request = new RESTRequest(server.baseURI + "/resource");
+
+  // Aborting a request that hasn't been sent yet is pointless and will throw.
+  do_check_throws(function () {
+    request.abort();
+  });
+
+  let responsePromise = request.get();
+  request.abort();
+
+  // Aborting an already aborted request is pointless and will throw.
+  do_check_throws(function () {
+    request.abort();
+  });
+
+  Assert.equal(request.status, request.ABORTED);
+
+  await Assert.rejects(responsePromise, /NS_BINDING_ABORTED/);
+
+  await promiseStopServer(server);
+});
+
+/**
+ * A non-zero 'timeout' property specifies the amount of seconds to wait after
+ * channel activity until the request is automatically canceled.
+ */
+add_task(async function test_timeout() {
+  let server = new HttpServer();
+  let server_connection;
+  server._handler.handleResponse = function (connection) {
+    // This is a handler that doesn't do anything, just keeps the connection
+    // open, thereby mimicking a timing out connection. We keep a reference to
+    // the open connection for later so it can be properly disposed of. That's
+    // why you really only want to make one HTTP request to this server ever.
+    server_connection = connection;
+  };
+  server.start();
+  let identity = server.identity;
+  let uri =
+    identity.primaryScheme +
+    "://" +
+    identity.primaryHost +
+    ":" +
+    identity.primaryPort;
+
+  let request = new RESTRequest(uri + "/resource");
+  request.timeout = 0.1; // 100 milliseconds
+
+  await Assert.rejects(
+    request.get(),
+    error => error.result == Cr.NS_ERROR_NET_TIMEOUT
+  );
+
+  Assert.equal(request.status, request.ABORTED);
+
+  // server_connection is undefined on the Android emulator for reasons
+  // unknown. Yet, we still get here. If this test is refactored, we should
+  // investigate the reason why the above callback is behaving differently.
+  if (server_connection) {
+    _("Closing connection.");
+    server_connection.close();
+  }
+  await promiseStopServer(server);
+});
+
+add_task(async function test_new_channel() {
+  _("Ensure a redirect to a new channel is handled properly.");
+
+  function checkUA(metadata) {
+    let ua = metadata.getHeader("User-Agent");
+    _("User-Agent is " + ua);
+    Assert.equal("foo bar", ua);
+  }
+
+  let redirectRequested = false;
+  let redirectURL;
+  function redirectHandler(metadata, response) {
+    checkUA(metadata);
+    redirectRequested = true;
+
+    let body = "Redirecting";
+    response.setStatusLine(metadata.httpVersion, 307, "TEMPORARY REDIRECT");
+    response.setHeader("Location", redirectURL);
+    response.bodyOutputStream.write(body, body.length);
+  }
+
+  let resourceRequested = false;
+  function resourceHandler(metadata, response) {
+    checkUA(metadata);
+    resourceRequested = true;
+
+    let body = "Test";
+    response.setHeader("Content-Type", "text/plain");
+    response.bodyOutputStream.write(body, body.length);
+  }
+
+  let server1 = httpd_setup({ "/redirect": redirectHandler });
+  let server2 = httpd_setup({ "/resource": resourceHandler });
+  redirectURL = server2.baseURI + "/resource";
+
+  let request = new RESTRequest(server1.baseURI + "/redirect");
+  request.setHeader("User-Agent", "foo bar");
+
+  // Swizzle in our own fakery, because this redirect is neither
+  // internal nor URI-preserving. RESTRequest's policy is to only
+  // copy headers under certain circumstances.
+  let protoMethod = request.shouldCopyOnRedirect;
+  request.shouldCopyOnRedirect = function wrapped(o, n, f) {
+    // Check the default policy.
+    Assert.ok(!protoMethod.call(this, o, n, f));
+    return true;
+  };
+
+  let response = await request.get();
+
+  Assert.equal(200, response.status);
+  Assert.equal("Test", response.body);
+  Assert.ok(redirectRequested);
+  Assert.ok(resourceRequested);
+
+  await promiseStopServer(server1);
+  await promiseStopServer(server2);
+});
+
+add_task(async function test_not_sending_cookie() {
+  function handler(metadata, response) {
+    let body = "COOKIE!";
+    response.setStatusLine(metadata.httpVersion, 200, "OK");
+    response.bodyOutputStream.write(body, body.length);
+    Assert.ok(!metadata.hasHeader("Cookie"));
+  }
+  let server = httpd_setup({ "/test": handler });
+
+  let uri = CommonUtils.makeURI(server.baseURI);
+  let channel = NetUtil.newChannel({
+    uri,
+    loadUsingSystemPrincipal: true,
+    contentPolicyType: Ci.nsIContentPolicy.TYPE_DOCUMENT,
+  });
+  Services.cookies.setCookieStringFromHttp(uri, "test=test; path=/;", channel);
+
+  let res = new RESTRequest(server.baseURI + "/test");
+  let response = await res.get();
+
+  Assert.ok(response.success);
+  Assert.equal("COOKIE!", response.body);
+
+  await promiseStopServer(server);
+});
diff --git a/services/common/tests/unit/test_storage_adapter.js b/services/common/tests/unit/test_storage_adapter.js
new file mode 100644
index 0000000000..1dda35ad12
--- /dev/null
+++ b/services/common/tests/unit/test_storage_adapter.js
@@ -0,0 +1,307 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { Sqlite } = ChromeUtils.importESModule(
+  "resource://gre/modules/Sqlite.sys.mjs"
+);
+const { FirefoxAdapter } = ChromeUtils.importESModule(
+  "resource://services-common/kinto-storage-adapter.sys.mjs"
+);
+
+// set up what we need to make storage adapters
+const kintoFilename = "kinto.sqlite";
+
+function do_get_kinto_connection() {
+  return FirefoxAdapter.openConnection({ path: kintoFilename });
+}
+
+function do_get_kinto_adapter(sqliteHandle) {
+  return new FirefoxAdapter("test", { sqliteHandle });
+}
+
+function do_get_kinto_db() {
+  let profile = do_get_profile();
+  let kintoDB = profile.clone();
+  kintoDB.append(kintoFilename);
+  return kintoDB;
+}
+
+function cleanup_kinto() {
+  add_test(function cleanup_kinto_files() {
+    let kintoDB = do_get_kinto_db();
+    // clean up the db
+    kintoDB.remove(false);
+    run_next_test();
+  });
+}
+
+function test_collection_operations() {
+  add_task(async function test_kinto_clear() {
+    let sqliteHandle = await do_get_kinto_connection();
+    let adapter = do_get_kinto_adapter(sqliteHandle);
+    await adapter.clear();
+    await sqliteHandle.close();
+  });
+
+  // test creating new records... and getting them again
+  add_task(async function test_kinto_create_new_get_existing() {
+    let sqliteHandle = await do_get_kinto_connection();
+    let adapter = do_get_kinto_adapter(sqliteHandle);
+    let record = { id: "test-id", foo: "bar" };
+    await adapter.execute(transaction => transaction.create(record));
+    let newRecord = await adapter.get("test-id");
+    // ensure the record is the same as when it was added
+    deepEqual(record, newRecord);
+    await sqliteHandle.close();
+  });
+
+  // test removing records
+  add_task(async function test_kinto_can_remove_some_records() {
+    let sqliteHandle = await do_get_kinto_connection();
+    let adapter = do_get_kinto_adapter(sqliteHandle);
+    // create a second record
+    let record = { id: "test-id-2", foo: "baz" };
+    await adapter.execute(transaction => transaction.create(record));
+    let newRecord = await adapter.get("test-id-2");
+    deepEqual(record, newRecord);
+    // delete the record
+    await adapter.execute(transaction => transaction.delete(record.id));
+    newRecord = await adapter.get(record.id);
+    // ... and ensure it's no longer there
+    Assert.equal(newRecord, undefined);
+    // ensure the other record still exists
+    newRecord = await adapter.get("test-id");
+    Assert.notEqual(newRecord, undefined);
+    await sqliteHandle.close();
+  });
+
+  // test getting records that don't exist
+  add_task(async function test_kinto_get_non_existant() {
+    let sqliteHandle = await do_get_kinto_connection();
+    let adapter = do_get_kinto_adapter(sqliteHandle);
+    // Kinto expects adapters to either:
+    let newRecord = await adapter.get("missing-test-id");
+    // resolve with an undefined record
+    Assert.equal(newRecord, undefined);
+    await sqliteHandle.close();
+  });
+
+  // test updating records... and getting them again
+  add_task(async function test_kinto_update_get_existing() {
+    let sqliteHandle = await do_get_kinto_connection();
+    let adapter = do_get_kinto_adapter(sqliteHandle);
+    let originalRecord = { id: "test-id", foo: "bar" };
+    let updatedRecord = { id: "test-id", foo: "baz" };
+    await adapter.clear();
+    await adapter.execute(transaction => transaction.create(originalRecord));
+    await adapter.execute(transaction => transaction.update(updatedRecord));
+    // ensure the record exists
+    let newRecord = await adapter.get("test-id");
+    // ensure the record is the same as when it was added
+    deepEqual(updatedRecord, newRecord);
+    await sqliteHandle.close();
+  });
+
+  // test listing records
+  add_task(async function test_kinto_list() {
+    let sqliteHandle = await do_get_kinto_connection();
+    let adapter = do_get_kinto_adapter(sqliteHandle);
+    let originalRecord = { id: "test-id-1", foo: "bar" };
+    let records = await adapter.list();
+    Assert.equal(records.length, 1);
+    await adapter.execute(transaction => transaction.create(originalRecord));
+    records = await adapter.list();
+    Assert.equal(records.length, 2);
+    await sqliteHandle.close();
+  });
+
+  // test aborting transaction
+  add_task(async function test_kinto_aborting_transaction() {
+    let sqliteHandle = await do_get_kinto_connection();
+    let adapter = do_get_kinto_adapter(sqliteHandle);
+    await adapter.clear();
+    let record = { id: 1, foo: "bar" };
+    let error = null;
+    try {
+      await adapter.execute(transaction => {
+        transaction.create(record);
+        throw new Error("unexpected");
+      });
+    } catch (e) {
+      error = e;
+    }
+    Assert.notEqual(error, null);
+    let records = await adapter.list();
+    Assert.equal(records.length, 0);
+    await sqliteHandle.close();
+  });
+
+  // test save and get last modified
+  add_task(async function test_kinto_last_modified() {
+    const initialValue = 0;
+    const intendedValue = 12345678;
+
+    let sqliteHandle = await do_get_kinto_connection();
+    let adapter = do_get_kinto_adapter(sqliteHandle);
+    let lastModified = await adapter.getLastModified();
+    Assert.equal(lastModified, initialValue);
+    let result = await adapter.saveLastModified(intendedValue);
+    Assert.equal(result, intendedValue);
+    lastModified = await adapter.getLastModified();
+    Assert.equal(lastModified, intendedValue);
+
+    // test saveLastModified parses values correctly
+    result = await adapter.saveLastModified(" " + intendedValue + " blah");
+    // should resolve with the parsed int
+    Assert.equal(result, intendedValue);
+    // and should have saved correctly
+    lastModified = await adapter.getLastModified();
+    Assert.equal(lastModified, intendedValue);
+    await sqliteHandle.close();
+  });
+
+  // test loadDump(records)
+  add_task(async function test_kinto_import_records() {
+    let sqliteHandle = await do_get_kinto_connection();
+    let adapter = do_get_kinto_adapter(sqliteHandle);
+    let record1 = { id: 1, foo: "bar" };
+    let record2 = { id: 2, foo: "baz" };
+    let impactedRecords = await adapter.loadDump([record1, record2]);
+    Assert.equal(impactedRecords.length, 2);
+    let newRecord1 = await adapter.get("1");
+    // ensure the record is the same as when it was added
+    deepEqual(record1, newRecord1);
+    let newRecord2 = await adapter.get("2");
+    // ensure the record is the same as when it was added
+    deepEqual(record2, newRecord2);
+    await sqliteHandle.close();
+  });
+
+  add_task(async function test_kinto_import_records_should_override_existing() {
+    let sqliteHandle = await do_get_kinto_connection();
+    let adapter = do_get_kinto_adapter(sqliteHandle);
+    await adapter.clear();
+    let records = await adapter.list();
+    Assert.equal(records.length, 0);
+    let impactedRecords = await adapter.loadDump([
+      { id: 1, foo: "bar" },
+      { id: 2, foo: "baz" },
+    ]);
+    Assert.equal(impactedRecords.length, 2);
+    await adapter.loadDump([
+      { id: 1, foo: "baz" },
+      { id: 3, foo: "bab" },
+    ]);
+    records = await adapter.list();
+    Assert.equal(records.length, 3);
+    let newRecord1 = await adapter.get("1");
+    deepEqual(newRecord1.foo, "baz");
+    await sqliteHandle.close();
+  });
+
+  add_task(async function test_import_updates_lastModified() {
+    let sqliteHandle = await do_get_kinto_connection();
+    let adapter = do_get_kinto_adapter(sqliteHandle);
+    await adapter.loadDump([
+      { id: 1, foo: "bar", last_modified: 1457896541 },
+      { id: 2, foo: "baz", last_modified: 1458796542 },
+    ]);
+    let lastModified = await adapter.getLastModified();
+    Assert.equal(lastModified, 1458796542);
+    await sqliteHandle.close();
+  });
+
+  add_task(async function test_import_preserves_older_lastModified() {
+    let sqliteHandle = await do_get_kinto_connection();
+    let adapter = do_get_kinto_adapter(sqliteHandle);
+    await adapter.saveLastModified(1458796543);
+
+    await adapter.loadDump([
+      { id: 1, foo: "bar", last_modified: 1457896541 },
+      { id: 2, foo: "baz", last_modified: 1458796542 },
+    ]);
+    let lastModified = await adapter.getLastModified();
+    Assert.equal(lastModified, 1458796543);
+    await sqliteHandle.close();
+  });
+
+  add_task(async function test_save_metadata_preserves_lastModified() {
+    let sqliteHandle = await do_get_kinto_connection();
+
+    let adapter = do_get_kinto_adapter(sqliteHandle);
+    await adapter.saveLastModified(42);
+
+    await adapter.saveMetadata({ id: "col" });
+
+    let lastModified = await adapter.getLastModified();
+    Assert.equal(lastModified, 42);
+    await sqliteHandle.close();
+  });
+}
+
+// test kinto db setup and operations in various scenarios
+// test from scratch - no current existing database
+add_test(function test_db_creation() {
+  add_test(function test_create_from_scratch() {
+    // ensure the file does not exist in the profile
+    let kintoDB = do_get_kinto_db();
+    Assert.ok(!kintoDB.exists());
+    run_next_test();
+  });
+
+  test_collection_operations();
+
+  cleanup_kinto();
+  run_next_test();
+});
+
+// this is the closest we can get to a schema version upgrade at v1 - test an
+// existing database
+add_test(function test_creation_from_empty_db() {
+  add_test(function test_create_from_empty_db() {
+    // place an empty kinto db file in the profile
+    let profile = do_get_profile();
+
+    let emptyDB = do_get_file("test_storage_adapter/empty.sqlite");
+    emptyDB.copyTo(profile, kintoFilename);
+
+    run_next_test();
+  });
+
+  test_collection_operations();
+
+  cleanup_kinto();
+  run_next_test();
+});
+
+// test schema version upgrade at v2
+add_test(function test_migration_from_v1_to_v2() {
+  add_test(function test_migrate_from_v1_to_v2() {
+    // place an empty kinto db file in the profile
+    let profile = do_get_profile();
+
+    let v1DB = do_get_file("test_storage_adapter/v1.sqlite");
+    v1DB.copyTo(profile, kintoFilename);
+
+    run_next_test();
+  });
+
+  add_test(async function schema_is_update_from_1_to_2() {
+    // The `v1.sqlite` has schema version 1.
+    let sqliteHandle = await Sqlite.openConnection({ path: kintoFilename });
+    Assert.equal(await sqliteHandle.getSchemaVersion(), 1);
+    await sqliteHandle.close();
+
+    // The `.openConnection()` migrates it to version 2.
+    sqliteHandle = await FirefoxAdapter.openConnection({ path: kintoFilename });
+    Assert.equal(await sqliteHandle.getSchemaVersion(), 2);
+    await sqliteHandle.close();
+
+    run_next_test();
+  });
+
+  test_collection_operations();
+
+  cleanup_kinto();
+  run_next_test();
+});
diff --git a/services/common/tests/unit/test_storage_adapter/empty.sqlite b/services/common/tests/unit/test_storage_adapter/empty.sqlite
new file mode 100644
index 0000000000..7f295b4146
--- /dev/null
+++ b/services/common/tests/unit/test_storage_adapter/empty.sqlite
diff --git a/services/common/tests/unit/test_storage_adapter/v1.sqlite b/services/common/tests/unit/test_storage_adapter/v1.sqlite
new file mode 100644
index 0000000000..8482b8b31d
--- /dev/null
+++ b/services/common/tests/unit/test_storage_adapter/v1.sqlite
diff --git a/services/common/tests/unit/test_storage_adapter_shutdown.js b/services/common/tests/unit/test_storage_adapter_shutdown.js
new file mode 100644
index 0000000000..dce26ce842
--- /dev/null
+++ b/services/common/tests/unit/test_storage_adapter_shutdown.js
@@ -0,0 +1,28 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { AsyncShutdown } = ChromeUtils.importESModule(
+  "resource://gre/modules/AsyncShutdown.sys.mjs"
+);
+
+const { FirefoxAdapter } = ChromeUtils.importESModule(
+  "resource://services-common/kinto-storage-adapter.sys.mjs"
+);
+
+add_task(async function test_sqlite_shutdown() {
+  const sqliteHandle = await FirefoxAdapter.openConnection({
+    path: "kinto.sqlite",
+  });
+
+  // Shutdown Sqlite.sys.mjs synchronously.
+  Services.prefs.setBoolPref("toolkit.asyncshutdown.testing", true);
+  AsyncShutdown.profileBeforeChange._trigger();
+  Services.prefs.clearUserPref("toolkit.asyncshutdown.testing");
+
+  try {
+    sqliteHandle.execute("SELECT 1;");
+    equal("Should not succeed, connection should be closed.", false);
+  } catch (e) {
+    equal(e.message, "Connection is not open.");
+  }
+});
diff --git a/services/common/tests/unit/test_tokenauthenticatedrequest.js b/services/common/tests/unit/test_tokenauthenticatedrequest.js
new file mode 100644
index 0000000000..70735894e4
--- /dev/null
+++ b/services/common/tests/unit/test_tokenauthenticatedrequest.js
@@ -0,0 +1,50 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const { CryptoUtils } = ChromeUtils.importESModule(
+  "resource://services-crypto/utils.sys.mjs"
+);
+const { TokenAuthenticatedRESTRequest } = ChromeUtils.importESModule(
+  "resource://services-common/rest.sys.mjs"
+);
+
+function run_test() {
+  initTestLogging("Trace");
+  run_next_test();
+}
+
+add_task(async function test_authenticated_request() {
+  _("Ensure that sending a MAC authenticated GET request works as expected.");
+
+  let message = "Great Success!";
+
+  let id = "eyJleHBpcmVzIjogMTM2NTAxMDg5OC4x";
+  let key = "qTZf4ZFpAMpMoeSsX3zVRjiqmNs=";
+  let method = "GET";
+
+  let nonce = btoa(CryptoUtils.generateRandomBytesLegacy(16));
+  let ts = Math.floor(Date.now() / 1000);
+  let extra = { ts, nonce };
+
+  let auth;
+
+  let server = httpd_setup({
+    "/foo": function (request, response) {
+      Assert.ok(request.hasHeader("Authorization"));
+      Assert.equal(auth, request.getHeader("Authorization"));
+
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.bodyOutputStream.write(message, message.length);
+    },
+  });
+  let uri = CommonUtils.makeURI(server.baseURI + "/foo");
+  let sig = await CryptoUtils.computeHTTPMACSHA1(id, key, method, uri, extra);
+  auth = sig.getHeader();
+
+  let req = new TokenAuthenticatedRESTRequest(uri, { id, key }, extra);
+  await req.get();
+
+  Assert.equal(message, req.response.body);
+
+  await promiseStopServer(server);
+});
diff --git a/services/common/tests/unit/test_tokenserverclient.js b/services/common/tests/unit/test_tokenserverclient.js
new file mode 100644
index 0000000000..c1c47f6e1a
--- /dev/null
+++ b/services/common/tests/unit/test_tokenserverclient.js
@@ -0,0 +1,382 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const {
+  TokenServerClient,
+  TokenServerClientError,
+  TokenServerClientServerError,
+} = ChromeUtils.importESModule(
+  "resource://services-common/tokenserverclient.sys.mjs"
+);
+
+initTestLogging("Trace");
+
+add_task(async function test_working_token_exchange() {
+  _("Ensure that working OAuth token exchange works as expected.");
+
+  let service = "http://example.com/foo";
+  let duration = 300;
+
+  let server = httpd_setup({
+    "/1.0/foo/1.0": function (request, response) {
+      Assert.ok(request.hasHeader("accept"));
+      Assert.equal("application/json", request.getHeader("accept"));
+
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.setHeader("Content-Type", "application/json");
+
+      let body = JSON.stringify({
+        id: "id",
+        key: "key",
+        api_endpoint: service,
+        uid: "uid",
+        duration,
+      });
+      response.bodyOutputStream.write(body, body.length);
+    },
+  });
+
+  let client = new TokenServerClient();
+  let url = server.baseURI + "/1.0/foo/1.0";
+  let result = await client.getTokenUsingOAuth(url, "access_token");
+  Assert.equal("object", typeof result);
+  do_check_attribute_count(result, 7);
+  Assert.equal(service, result.endpoint);
+  Assert.equal("id", result.id);
+  Assert.equal("key", result.key);
+  Assert.equal("uid", result.uid);
+  Assert.equal(duration, result.duration);
+  Assert.deepEqual(undefined, result.node_type);
+  await promiseStopServer(server);
+});
+
+add_task(async function test_working_token_exchange_with_nodetype() {
+  _("Ensure that a token response with a node type as expected.");
+
+  let service = "http://example.com/foo";
+  let duration = 300;
+  let nodeType = "the-node-type";
+
+  let server = httpd_setup({
+    "/1.0/foo/1.0": function (request, response) {
+      Assert.ok(request.hasHeader("accept"));
+      Assert.equal("application/json", request.getHeader("accept"));
+
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.setHeader("Content-Type", "application/json");
+
+      let body = JSON.stringify({
+        id: "id",
+        key: "key",
+        api_endpoint: service,
+        uid: "uid",
+        duration,
+        node_type: nodeType,
+      });
+      response.bodyOutputStream.write(body, body.length);
+    },
+  });
+
+  let client = new TokenServerClient();
+  let url = server.baseURI + "/1.0/foo/1.0";
+  let result = await client.getTokenUsingOAuth(url, "access_token");
+  Assert.equal("object", typeof result);
+  do_check_attribute_count(result, 7);
+  Assert.equal(service, result.endpoint);
+  Assert.equal("id", result.id);
+  Assert.equal("key", result.key);
+  Assert.equal("uid", result.uid);
+  Assert.equal(duration, result.duration);
+  Assert.equal(nodeType, result.node_type);
+  await promiseStopServer(server);
+});
+
+add_task(async function test_invalid_arguments() {
+  _("Ensure invalid arguments to APIs are rejected.");
+
+  let args = [
+    [null, "access_token"],
+    ["http://example.com/", null],
+  ];
+
+  for (let arg of args) {
+    let client = new TokenServerClient();
+    await Assert.rejects(client.getTokenUsingOAuth(arg[0], arg[1]), ex => {
+      Assert.ok(ex instanceof TokenServerClientError);
+      return true;
+    });
+  }
+});
+
+add_task(async function test_invalid_403_no_content_type() {
+  _("Ensure that a 403 without content-type is handled properly.");
+
+  let server = httpd_setup({
+    "/1.0/foo/1.0": function (request, response) {
+      response.setStatusLine(request.httpVersion, 403, "Forbidden");
+      // No Content-Type header by design.
+
+      let body = JSON.stringify({
+        errors: [{ description: "irrelevant", location: "body", name: "" }],
+        urls: { foo: "http://bar" },
+      });
+      response.bodyOutputStream.write(body, body.length);
+    },
+  });
+
+  let client = new TokenServerClient();
+  let url = server.baseURI + "/1.0/foo/1.0";
+
+  await Assert.rejects(
+    client.getTokenUsingOAuth(url, "access_token"),
+    error => {
+      Assert.ok(error instanceof TokenServerClientServerError);
+      Assert.equal(error.cause, "malformed-response");
+
+      Assert.equal(null, error.urls);
+      return true;
+    }
+  );
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_send_extra_headers() {
+  _("Ensures that the condition acceptance header is sent when asked.");
+
+  let duration = 300;
+  let server = httpd_setup({
+    "/1.0/foo/1.0": function (request, response) {
+      Assert.ok(request.hasHeader("x-foo"));
+      Assert.equal(request.getHeader("x-foo"), "42");
+
+      Assert.ok(request.hasHeader("x-bar"));
+      Assert.equal(request.getHeader("x-bar"), "17");
+
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.setHeader("Content-Type", "application/json");
+
+      let body = JSON.stringify({
+        id: "id",
+        key: "key",
+        api_endpoint: "http://example.com/",
+        uid: "uid",
+        duration,
+      });
+      response.bodyOutputStream.write(body, body.length);
+    },
+  });
+
+  let client = new TokenServerClient();
+  let url = server.baseURI + "/1.0/foo/1.0";
+
+  let extra = {
+    "X-Foo": 42,
+    "X-Bar": 17,
+  };
+
+  await client.getTokenUsingOAuth(url, "access_token", extra);
+  // Other tests validate other things.
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_error_404_empty() {
+  _("Ensure that 404 responses without proper response are handled properly.");
+
+  let server = httpd_setup();
+
+  let client = new TokenServerClient();
+  let url = server.baseURI + "/foo";
+
+  await Assert.rejects(
+    client.getTokenUsingOAuth(url, "access_token"),
+    error => {
+      Assert.ok(error instanceof TokenServerClientServerError);
+      Assert.equal(error.cause, "malformed-response");
+
+      Assert.notEqual(null, error.response);
+      return true;
+    }
+  );
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_error_404_proper_response() {
+  _("Ensure that a Cornice error report for 404 is handled properly.");
+
+  let server = httpd_setup({
+    "/1.0/foo/1.0": function (request, response) {
+      response.setStatusLine(request.httpVersion, 404, "Not Found");
+      response.setHeader("Content-Type", "application/json; charset=utf-8");
+
+      let body = JSON.stringify({
+        status: 404,
+        errors: [{ description: "No service", location: "body", name: "" }],
+      });
+
+      response.bodyOutputStream.write(body, body.length);
+    },
+  });
+
+  let client = new TokenServerClient();
+  let url = server.baseURI + "/1.0/foo/1.0";
+
+  await Assert.rejects(
+    client.getTokenUsingOAuth(url, "access_token"),
+    error => {
+      Assert.ok(error instanceof TokenServerClientServerError);
+      Assert.equal(error.cause, "unknown-service");
+      return true;
+    }
+  );
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_bad_json() {
+  _("Ensure that malformed JSON is handled properly.");
+
+  let server = httpd_setup({
+    "/1.0/foo/1.0": function (request, response) {
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.setHeader("Content-Type", "application/json");
+
+      let body = '{"id": "id", baz}';
+      response.bodyOutputStream.write(body, body.length);
+    },
+  });
+
+  let client = new TokenServerClient();
+  let url = server.baseURI + "/1.0/foo/1.0";
+
+  await Assert.rejects(
+    client.getTokenUsingOAuth(url, "access_token"),
+    error => {
+      Assert.notEqual(null, error);
+      Assert.equal("TokenServerClientServerError", error.name);
+      Assert.equal(error.cause, "malformed-response");
+      Assert.notEqual(null, error.response);
+      return true;
+    }
+  );
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_400_response() {
+  _("Ensure HTTP 400 is converted to malformed-request.");
+
+  let server = httpd_setup({
+    "/1.0/foo/1.0": function (request, response) {
+      response.setStatusLine(request.httpVersion, 400, "Bad Request");
+      response.setHeader("Content-Type", "application/json; charset=utf-8");
+
+      let body = "{}"; // Actual content may not be used.
+      response.bodyOutputStream.write(body, body.length);
+    },
+  });
+
+  let client = new TokenServerClient();
+  let url = server.baseURI + "/1.0/foo/1.0";
+
+  await Assert.rejects(
+    client.getTokenUsingOAuth(url, "access_token"),
+    error => {
+      Assert.notEqual(null, error);
+      Assert.equal("TokenServerClientServerError", error.name);
+      Assert.notEqual(null, error.response);
+      Assert.equal(error.cause, "malformed-request");
+      return true;
+    }
+  );
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_401_with_error_cause() {
+  _("Ensure 401 cause is specified in body.status");
+
+  let server = httpd_setup({
+    "/1.0/foo/1.0": function (request, response) {
+      response.setStatusLine(request.httpVersion, 401, "Unauthorized");
+      response.setHeader("Content-Type", "application/json; charset=utf-8");
+
+      let body = JSON.stringify({ status: "no-soup-for-you" });
+      response.bodyOutputStream.write(body, body.length);
+    },
+  });
+
+  let client = new TokenServerClient();
+  let url = server.baseURI + "/1.0/foo/1.0";
+
+  await Assert.rejects(
+    client.getTokenUsingOAuth(url, "access_token"),
+    error => {
+      Assert.notEqual(null, error);
+      Assert.equal("TokenServerClientServerError", error.name);
+      Assert.notEqual(null, error.response);
+      Assert.equal(error.cause, "no-soup-for-you");
+      return true;
+    }
+  );
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_unhandled_media_type() {
+  _("Ensure that unhandled media types throw an error.");
+
+  let server = httpd_setup({
+    "/1.0/foo/1.0": function (request, response) {
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.setHeader("Content-Type", "text/plain");
+
+      let body = "hello, world";
+      response.bodyOutputStream.write(body, body.length);
+    },
+  });
+
+  let url = server.baseURI + "/1.0/foo/1.0";
+  let client = new TokenServerClient();
+
+  await Assert.rejects(
+    client.getTokenUsingOAuth(url, "access_token"),
+    error => {
+      Assert.notEqual(null, error);
+      Assert.equal("TokenServerClientServerError", error.name);
+      Assert.notEqual(null, error.response);
+      return true;
+    }
+  );
+
+  await promiseStopServer(server);
+});
+
+add_task(async function test_rich_media_types() {
+  _("Ensure that extra tokens in the media type aren't rejected.");
+
+  let duration = 300;
+  let server = httpd_setup({
+    "/foo": function (request, response) {
+      response.setStatusLine(request.httpVersion, 200, "OK");
+      response.setHeader("Content-Type", "application/json; foo=bar; bar=foo");
+
+      let body = JSON.stringify({
+        id: "id",
+        key: "key",
+        api_endpoint: "foo",
+        uid: "uid",
+        duration,
+      });
+      response.bodyOutputStream.write(body, body.length);
+    },
+  });
+
+  let url = server.baseURI + "/foo";
+  let client = new TokenServerClient();
+
+  await client.getTokenUsingOAuth(url, "access_token");
+  await promiseStopServer(server);
+});
diff --git a/services/common/tests/unit/test_uptake_telemetry.js b/services/common/tests/unit/test_uptake_telemetry.js
new file mode 100644
index 0000000000..24967b641f
--- /dev/null
+++ b/services/common/tests/unit/test_uptake_telemetry.js
@@ -0,0 +1,121 @@
+const { TelemetryTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/TelemetryTestUtils.sys.mjs"
+);
+const { UptakeTelemetry } = ChromeUtils.importESModule(
+  "resource://services-common/uptake-telemetry.sys.mjs"
+);
+
+const COMPONENT = "remotesettings";
+
+async function withFakeClientID(uuid, f) {
+  const { Policy } = ChromeUtils.importESModule(
+    "resource://services-common/uptake-telemetry.sys.mjs"
+  );
+  let oldGetClientID = Policy.getClientID;
+  Policy._clientIDHash = null;
+  Policy.getClientID = () => Promise.resolve(uuid);
+  try {
+    return await f();
+  } finally {
+    Policy.getClientID = oldGetClientID;
+  }
+}
+
+add_task(async function test_unknown_status_is_not_reported() {
+  const source = "update-source";
+  const startSnapshot = getUptakeTelemetrySnapshot(COMPONENT, source);
+
+  try {
+    await UptakeTelemetry.report(COMPONENT, "unknown-status", { source });
+  } catch (e) {}
+
+  const endSnapshot = getUptakeTelemetrySnapshot(COMPONENT, source);
+  Assert.deepEqual(startSnapshot, endSnapshot);
+});
+
+add_task(async function test_age_is_converted_to_string_and_reported() {
+  const status = UptakeTelemetry.STATUS.SUCCESS;
+  const age = 42;
+
+  await withFakeChannel("nightly", async () => {
+    await UptakeTelemetry.report(COMPONENT, status, { source: "s", age });
+  });
+
+  TelemetryTestUtils.assertEvents([
+    [
+      "uptake.remotecontent.result",
+      "uptake",
+      COMPONENT,
+      status,
+      { source: "s", age: `${age}` },
+    ],
+  ]);
+});
+
+add_task(async function test_each_status_can_be_caught_in_snapshot() {
+  const source = "some-source";
+  const startSnapshot = getUptakeTelemetrySnapshot(COMPONENT, source);
+
+  const expectedIncrements = {};
+  await withFakeChannel("nightly", async () => {
+    for (const status of Object.values(UptakeTelemetry.STATUS)) {
+      expectedIncrements[status] = 1;
+      await UptakeTelemetry.report(COMPONENT, status, { source });
+    }
+  });
+
+  const endSnapshot = getUptakeTelemetrySnapshot(COMPONENT, source);
+  checkUptakeTelemetry(startSnapshot, endSnapshot, expectedIncrements);
+});
+
+add_task(async function test_events_are_sent_when_hash_is_mod_0() {
+  const source = "some-source";
+  const startSnapshot = getUptakeTelemetrySnapshot(COMPONENT, source);
+  const startSuccess = startSnapshot.success || 0;
+  const uuid = "d81bbfad-d741-41f5-a7e6-29f6bde4972a"; // hash % 100 = 0
+  await withFakeClientID(uuid, async () => {
+    await withFakeChannel("release", async () => {
+      await UptakeTelemetry.report(COMPONENT, UptakeTelemetry.STATUS.SUCCESS, {
+        source,
+      });
+    });
+  });
+  const endSnapshot = getUptakeTelemetrySnapshot(COMPONENT, source);
+  Assert.equal(endSnapshot.success, startSuccess + 1);
+});
+
+add_task(
+  async function test_events_are_not_sent_when_hash_is_greater_than_pref() {
+    const source = "some-source";
+    const startSnapshot = getUptakeTelemetrySnapshot(COMPONENT, source);
+    const startSuccess = startSnapshot.success || 0;
+    const uuid = "d81bbfad-d741-41f5-a7e6-29f6bde49721"; // hash % 100 = 1
+    await withFakeClientID(uuid, async () => {
+      await withFakeChannel("release", async () => {
+        await UptakeTelemetry.report(
+          COMPONENT,
+          UptakeTelemetry.STATUS.SUCCESS,
+          { source }
+        );
+      });
+    });
+    const endSnapshot = getUptakeTelemetrySnapshot(COMPONENT, source);
+    Assert.equal(endSnapshot.success || 0, startSuccess);
+  }
+);
+
+add_task(async function test_events_are_sent_when_nightly() {
+  const source = "some-source";
+  const startSnapshot = getUptakeTelemetrySnapshot(COMPONENT, source);
+  const startSuccess = startSnapshot.success || 0;
+  const uuid = "d81bbfad-d741-41f5-a7e6-29f6bde49721"; // hash % 100 = 1
+  await withFakeClientID(uuid, async () => {
+    await withFakeChannel("nightly", async () => {
+      await UptakeTelemetry.report(COMPONENT, UptakeTelemetry.STATUS.SUCCESS, {
+        source,
+      });
+    });
+  });
+  const endSnapshot = getUptakeTelemetrySnapshot(COMPONENT, source);
+  Assert.equal(endSnapshot.success, startSuccess + 1);
+});
diff --git a/services/common/tests/unit/test_utils_atob.js b/services/common/tests/unit/test_utils_atob.js
new file mode 100644
index 0000000000..9e24b56f6f
--- /dev/null
+++ b/services/common/tests/unit/test_utils_atob.js
@@ -0,0 +1,9 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function run_test() {
+  let data = ["Zm9vYmE=", "Zm9vYmE==", "Zm9vYmE==="];
+  for (let d in data) {
+    Assert.equal(CommonUtils.safeAtoB(data[d]), "fooba");
+  }
+}
diff --git a/services/common/tests/unit/test_utils_convert_string.js b/services/common/tests/unit/test_utils_convert_string.js
new file mode 100644
index 0000000000..fcfd874994
--- /dev/null
+++ b/services/common/tests/unit/test_utils_convert_string.js
@@ -0,0 +1,146 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+// A wise line of Greek verse, and the utf-8 byte encoding.
+// N.b., Greek begins at utf-8 ce 91
+const TEST_STR = "πόλλ' οἶδ' ἀλώπηξ, ἀλλ' ἐχῖνος ἓν μέγα";
+const TEST_HEX = h(
+  "cf 80 cf 8c ce bb ce bb   27 20 ce bf e1 bc b6 ce" +
+    "b4 27 20 e1 bc 80 ce bb   cf 8e cf 80 ce b7 ce be" +
+    "2c 20 e1 bc 80 ce bb ce   bb 27 20 e1 bc 90 cf 87" +
+    "e1 bf 96 ce bd ce bf cf   82 20 e1 bc 93 ce bd 20" +
+    "ce bc ce ad ce b3 ce b1"
+);
+// Integer byte values for the above
+const TEST_BYTES = [
+  207, 128, 207, 140, 206, 187, 206, 187, 39, 32, 206, 191, 225, 188, 182, 206,
+  180, 39, 32, 225, 188, 128, 206, 187, 207, 142, 207, 128, 206, 183, 206, 190,
+  44, 32, 225, 188, 128, 206, 187, 206, 187, 39, 32, 225, 188, 144, 207, 135,
+  225, 191, 150, 206, 189, 206, 191, 207, 130, 32, 225, 188, 147, 206, 189, 32,
+  206, 188, 206, 173, 206, 179, 206, 177,
+];
+
+add_test(function test_compress_string() {
+  const INPUT = "hello";
+
+  let result = CommonUtils.convertString(INPUT, "uncompressed", "deflate");
+  Assert.equal(result.length, 13);
+
+  let result2 = CommonUtils.convertString(INPUT, "uncompressed", "deflate");
+  Assert.equal(result, result2);
+
+  let result3 = CommonUtils.convertString(result, "deflate", "uncompressed");
+  Assert.equal(result3, INPUT);
+
+  run_next_test();
+});
+
+add_test(function test_compress_utf8() {
+  const INPUT =
+    "Árvíztűrő tükörfúrógép いろはにほへとちりぬるを Pijamalı hasta, yağız şoföre çabucak güvendi.";
+  let inputUTF8 = CommonUtils.encodeUTF8(INPUT);
+
+  let compressed = CommonUtils.convertString(
+    inputUTF8,
+    "uncompressed",
+    "deflate"
+  );
+  let uncompressed = CommonUtils.convertString(
+    compressed,
+    "deflate",
+    "uncompressed"
+  );
+
+  Assert.equal(uncompressed, inputUTF8);
+
+  let outputUTF8 = CommonUtils.decodeUTF8(uncompressed);
+  Assert.equal(outputUTF8, INPUT);
+
+  run_next_test();
+});
+
+add_test(function test_bad_argument() {
+  let failed = false;
+  try {
+    CommonUtils.convertString(null, "uncompressed", "deflate");
+  } catch (ex) {
+    failed = true;
+    Assert.ok(ex.message.startsWith("Input string must be defined"));
+  } finally {
+    Assert.ok(failed);
+  }
+
+  run_next_test();
+});
+
+add_task(function test_stringAsHex() {
+  Assert.equal(TEST_HEX, CommonUtils.stringAsHex(TEST_STR));
+});
+
+add_task(function test_hexAsString() {
+  Assert.equal(TEST_STR, CommonUtils.hexAsString(TEST_HEX));
+});
+
+add_task(function test_hexToBytes() {
+  let bytes = CommonUtils.hexToBytes(TEST_HEX);
+  Assert.equal(TEST_BYTES.length, bytes.length);
+  // Ensure that the decimal values of each byte are correct
+  Assert.ok(arraysEqual(TEST_BYTES, CommonUtils.stringToByteArray(bytes)));
+});
+
+add_task(function test_bytesToHex() {
+  // Create a list of our character bytes from the reference int values
+  let bytes = CommonUtils.byteArrayToString(TEST_BYTES);
+  Assert.equal(TEST_HEX, CommonUtils.bytesAsHex(bytes));
+});
+
+add_task(function test_stringToBytes() {
+  Assert.ok(
+    arraysEqual(
+      TEST_BYTES,
+      CommonUtils.stringToByteArray(CommonUtils.stringToBytes(TEST_STR))
+    )
+  );
+});
+
+add_task(function test_stringRoundTrip() {
+  Assert.equal(
+    TEST_STR,
+    CommonUtils.hexAsString(CommonUtils.stringAsHex(TEST_STR))
+  );
+});
+
+add_task(function test_hexRoundTrip() {
+  Assert.equal(
+    TEST_HEX,
+    CommonUtils.stringAsHex(CommonUtils.hexAsString(TEST_HEX))
+  );
+});
+
+add_task(function test_byteArrayRoundTrip() {
+  Assert.ok(
+    arraysEqual(
+      TEST_BYTES,
+      CommonUtils.stringToByteArray(CommonUtils.byteArrayToString(TEST_BYTES))
+    )
+  );
+});
+
+// turn formatted test vectors into normal hex strings
+function h(hexStr) {
+  return hexStr.replace(/\s+/g, "");
+}
+
+function arraysEqual(a1, a2) {
+  if (a1.length !== a2.length) {
+    return false;
+  }
+  for (let i = 0; i < a1.length; i++) {
+    if (a1[i] !== a2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
diff --git a/services/common/tests/unit/test_utils_dateprefs.js b/services/common/tests/unit/test_utils_dateprefs.js
new file mode 100644
index 0000000000..0a79ac436a
--- /dev/null
+++ b/services/common/tests/unit/test_utils_dateprefs.js
@@ -0,0 +1,81 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { Preferences } = ChromeUtils.importESModule(
+  "resource://gre/modules/Preferences.sys.mjs"
+);
+
+var prefs = new Preferences("servicescommon.tests.");
+
+function DummyLogger() {
+  this.messages = [];
+}
+DummyLogger.prototype.warn = function warn(message) {
+  this.messages.push(message);
+};
+
+add_test(function test_set_basic() {
+  let now = new Date();
+
+  CommonUtils.setDatePref(prefs, "test00", now);
+  let value = prefs.get("test00");
+  Assert.equal(value, "" + now.getTime());
+
+  let now2 = CommonUtils.getDatePref(prefs, "test00");
+
+  Assert.equal(now.getTime(), now2.getTime());
+
+  run_next_test();
+});
+
+add_test(function test_set_bounds_checking() {
+  let d = new Date(2342354);
+
+  let failed = false;
+  try {
+    CommonUtils.setDatePref(prefs, "test01", d);
+  } catch (ex) {
+    Assert.ok(ex.message.startsWith("Trying to set"));
+    failed = true;
+  }
+
+  Assert.ok(failed);
+  run_next_test();
+});
+
+add_test(function test_get_bounds_checking() {
+  prefs.set("test_bounds_checking", "13241431");
+
+  let log = new DummyLogger();
+  let d = CommonUtils.getDatePref(prefs, "test_bounds_checking", 0, log);
+  Assert.equal(d.getTime(), 0);
+  Assert.equal(log.messages.length, 1);
+
+  run_next_test();
+});
+
+add_test(function test_get_bad_default() {
+  let failed = false;
+  try {
+    CommonUtils.getDatePref(prefs, "get_bad_default", new Date());
+  } catch (ex) {
+    Assert.ok(ex.message.startsWith("Default value is not a number"));
+    failed = true;
+  }
+
+  Assert.ok(failed);
+  run_next_test();
+});
+
+add_test(function test_get_invalid_number() {
+  prefs.set("get_invalid_number", "hello world");
+
+  let log = new DummyLogger();
+  let d = CommonUtils.getDatePref(prefs, "get_invalid_number", 42, log);
+  Assert.equal(d.getTime(), 42);
+  Assert.equal(log.messages.length, 1);
+
+  run_next_test();
+});
diff --git a/services/common/tests/unit/test_utils_encodeBase32.js b/services/common/tests/unit/test_utils_encodeBase32.js
new file mode 100644
index 0000000000..3299ac8d05
--- /dev/null
+++ b/services/common/tests/unit/test_utils_encodeBase32.js
@@ -0,0 +1,55 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function run_test() {
+  // Testing byte array manipulation.
+  Assert.equal(
+    "FOOBAR",
+    CommonUtils.byteArrayToString([70, 79, 79, 66, 65, 82])
+  );
+  Assert.equal("", CommonUtils.byteArrayToString([]));
+
+  _("Testing encoding...");
+  // Test vectors from RFC 4648
+  Assert.equal(CommonUtils.encodeBase32(""), "");
+  Assert.equal(CommonUtils.encodeBase32("f"), "MY======");
+  Assert.equal(CommonUtils.encodeBase32("fo"), "MZXQ====");
+  Assert.equal(CommonUtils.encodeBase32("foo"), "MZXW6===");
+  Assert.equal(CommonUtils.encodeBase32("foob"), "MZXW6YQ=");
+  Assert.equal(CommonUtils.encodeBase32("fooba"), "MZXW6YTB");
+  Assert.equal(CommonUtils.encodeBase32("foobar"), "MZXW6YTBOI======");
+
+  Assert.equal(
+    CommonUtils.encodeBase32("Bacon is a vegetable."),
+    "IJQWG33OEBUXGIDBEB3GKZ3FORQWE3DFFY======"
+  );
+
+  _("Checking assumptions...");
+  for (let i = 0; i <= 255; ++i) {
+    Assert.equal(undefined | i, i);
+  }
+
+  _("Testing decoding...");
+  Assert.equal(CommonUtils.decodeBase32(""), "");
+  Assert.equal(CommonUtils.decodeBase32("MY======"), "f");
+  Assert.equal(CommonUtils.decodeBase32("MZXQ===="), "fo");
+  Assert.equal(CommonUtils.decodeBase32("MZXW6YTB"), "fooba");
+  Assert.equal(CommonUtils.decodeBase32("MZXW6YTBOI======"), "foobar");
+
+  // Same with incorrect or missing padding.
+  Assert.equal(CommonUtils.decodeBase32("MZXW6YTBOI=="), "foobar");
+  Assert.equal(CommonUtils.decodeBase32("MZXW6YTBOI"), "foobar");
+
+  let encoded = CommonUtils.encodeBase32("Bacon is a vegetable.");
+  _("Encoded to " + JSON.stringify(encoded));
+  Assert.equal(CommonUtils.decodeBase32(encoded), "Bacon is a vegetable.");
+
+  // Test failure.
+  let err;
+  try {
+    CommonUtils.decodeBase32("000");
+  } catch (ex) {
+    err = ex;
+  }
+  Assert.equal(err.message, "Unknown character in base32: 0");
+}
diff --git a/services/common/tests/unit/test_utils_encodeBase64URL.js b/services/common/tests/unit/test_utils_encodeBase64URL.js
new file mode 100644
index 0000000000..84d98b06f1
--- /dev/null
+++ b/services/common/tests/unit/test_utils_encodeBase64URL.js
@@ -0,0 +1,21 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_test(function test_simple() {
+  let expected = {
+    hello: "aGVsbG8=",
+    "<>?": "PD4_",
+  };
+
+  for (let [k, v] of Object.entries(expected)) {
+    Assert.equal(CommonUtils.encodeBase64URL(k), v);
+  }
+
+  run_next_test();
+});
+
+add_test(function test_no_padding() {
+  Assert.equal(CommonUtils.encodeBase64URL("hello", false), "aGVsbG8");
+
+  run_next_test();
+});
diff --git a/services/common/tests/unit/test_utils_ensureMillisecondsTimestamp.js b/services/common/tests/unit/test_utils_ensureMillisecondsTimestamp.js
new file mode 100644
index 0000000000..f334364b2d
--- /dev/null
+++ b/services/common/tests/unit/test_utils_ensureMillisecondsTimestamp.js
@@ -0,0 +1,40 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function run_test() {
+  Assert.equal(null, CommonUtils.ensureMillisecondsTimestamp(null));
+  Assert.equal(null, CommonUtils.ensureMillisecondsTimestamp(0));
+  Assert.equal(null, CommonUtils.ensureMillisecondsTimestamp("0"));
+  Assert.equal(null, CommonUtils.ensureMillisecondsTimestamp("000"));
+
+  Assert.equal(
+    null,
+    CommonUtils.ensureMillisecondsTimestamp(999 * 10000000000)
+  );
+
+  do_check_throws(function err() {
+    CommonUtils.ensureMillisecondsTimestamp(-1);
+  });
+  do_check_throws(function err() {
+    CommonUtils.ensureMillisecondsTimestamp(1);
+  });
+  do_check_throws(function err() {
+    CommonUtils.ensureMillisecondsTimestamp(1.5);
+  });
+  do_check_throws(function err() {
+    CommonUtils.ensureMillisecondsTimestamp(999 * 10000000000 + 0.5);
+  });
+
+  do_check_throws(function err() {
+    CommonUtils.ensureMillisecondsTimestamp("-1");
+  });
+  do_check_throws(function err() {
+    CommonUtils.ensureMillisecondsTimestamp("1");
+  });
+  do_check_throws(function err() {
+    CommonUtils.ensureMillisecondsTimestamp("1.5");
+  });
+  do_check_throws(function err() {
+    CommonUtils.ensureMillisecondsTimestamp("" + (999 * 10000000000 + 0.5));
+  });
+}
diff --git a/services/common/tests/unit/test_utils_makeURI.js b/services/common/tests/unit/test_utils_makeURI.js
new file mode 100644
index 0000000000..d6d7e19db9
--- /dev/null
+++ b/services/common/tests/unit/test_utils_makeURI.js
@@ -0,0 +1,62 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+_("Make sure uri strings are converted to nsIURIs");
+
+function run_test() {
+  _test_makeURI();
+}
+
+function _test_makeURI() {
+  _("Check http uris");
+  let uri1 = "http://mozillalabs.com/";
+  Assert.equal(CommonUtils.makeURI(uri1).spec, uri1);
+  let uri2 = "http://www.mozillalabs.com/";
+  Assert.equal(CommonUtils.makeURI(uri2).spec, uri2);
+  let uri3 = "http://mozillalabs.com/path";
+  Assert.equal(CommonUtils.makeURI(uri3).spec, uri3);
+  let uri4 = "http://mozillalabs.com/multi/path";
+  Assert.equal(CommonUtils.makeURI(uri4).spec, uri4);
+  let uri5 = "http://mozillalabs.com/?query";
+  Assert.equal(CommonUtils.makeURI(uri5).spec, uri5);
+  let uri6 = "http://mozillalabs.com/#hash";
+  Assert.equal(CommonUtils.makeURI(uri6).spec, uri6);
+
+  _("Check https uris");
+  let uris1 = "https://mozillalabs.com/";
+  Assert.equal(CommonUtils.makeURI(uris1).spec, uris1);
+  let uris2 = "https://www.mozillalabs.com/";
+  Assert.equal(CommonUtils.makeURI(uris2).spec, uris2);
+  let uris3 = "https://mozillalabs.com/path";
+  Assert.equal(CommonUtils.makeURI(uris3).spec, uris3);
+  let uris4 = "https://mozillalabs.com/multi/path";
+  Assert.equal(CommonUtils.makeURI(uris4).spec, uris4);
+  let uris5 = "https://mozillalabs.com/?query";
+  Assert.equal(CommonUtils.makeURI(uris5).spec, uris5);
+  let uris6 = "https://mozillalabs.com/#hash";
+  Assert.equal(CommonUtils.makeURI(uris6).spec, uris6);
+
+  _("Check chrome uris");
+  let uric1 = "chrome://browser/content/browser.xhtml";
+  Assert.equal(CommonUtils.makeURI(uric1).spec, uric1);
+  let uric2 = "chrome://browser/skin/browser.css";
+  Assert.equal(CommonUtils.makeURI(uric2).spec, uric2);
+
+  _("Check about uris");
+  let uria1 = "about:weave";
+  Assert.equal(CommonUtils.makeURI(uria1).spec, uria1);
+  let uria2 = "about:weave/";
+  Assert.equal(CommonUtils.makeURI(uria2).spec, uria2);
+  let uria3 = "about:weave/path";
+  Assert.equal(CommonUtils.makeURI(uria3).spec, uria3);
+  let uria4 = "about:weave/multi/path";
+  Assert.equal(CommonUtils.makeURI(uria4).spec, uria4);
+  let uria5 = "about:weave/?query";
+  Assert.equal(CommonUtils.makeURI(uria5).spec, uria5);
+  let uria6 = "about:weave/#hash";
+  Assert.equal(CommonUtils.makeURI(uria6).spec, uria6);
+
+  _("Invalid uris are undefined");
+  Assert.equal(CommonUtils.makeURI("mozillalabs.com"), undefined);
+  Assert.equal(CommonUtils.makeURI("this is a test"), undefined);
+}
diff --git a/services/common/tests/unit/test_utils_namedTimer.js b/services/common/tests/unit/test_utils_namedTimer.js
new file mode 100644
index 0000000000..47ac0b9dc1
--- /dev/null
+++ b/services/common/tests/unit/test_utils_namedTimer.js
@@ -0,0 +1,73 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_test(function test_required_args() {
+  try {
+    CommonUtils.namedTimer(function callback() {
+      do_throw("Shouldn't fire.");
+    }, 0);
+    do_throw("Should have thrown!");
+  } catch (ex) {
+    run_next_test();
+  }
+});
+
+add_test(function test_simple() {
+  _("Test basic properties of CommonUtils.namedTimer.");
+
+  const delay = 200;
+  let that = {};
+  let t0 = Date.now();
+  CommonUtils.namedTimer(
+    function callback(timer) {
+      Assert.equal(this, that);
+      Assert.equal(this._zetimer, null);
+      Assert.ok(timer instanceof Ci.nsITimer);
+      // Difference should be ~delay, but hard to predict on all platforms,
+      // particularly Windows XP.
+      Assert.ok(Date.now() > t0);
+      run_next_test();
+    },
+    delay,
+    that,
+    "_zetimer"
+  );
+});
+
+add_test(function test_delay() {
+  _("Test delaying a timer that hasn't fired yet.");
+
+  const delay = 100;
+  let that = {};
+  let t0 = Date.now();
+  function callback(timer) {
+    // Difference should be ~2*delay, but hard to predict on all platforms,
+    // particularly Windows XP.
+    Assert.ok(Date.now() - t0 > delay);
+    run_next_test();
+  }
+  CommonUtils.namedTimer(callback, delay, that, "_zetimer");
+  CommonUtils.namedTimer(callback, 2 * delay, that, "_zetimer");
+  run_next_test();
+});
+
+add_test(function test_clear() {
+  _("Test clearing a timer that hasn't fired yet.");
+
+  const delay = 0;
+  let that = {};
+  CommonUtils.namedTimer(
+    function callback(timer) {
+      do_throw("Shouldn't fire!");
+    },
+    delay,
+    that,
+    "_zetimer"
+  );
+
+  that._zetimer.clear();
+  Assert.equal(that._zetimer, null);
+  CommonUtils.nextTick(run_next_test);
+
+  run_next_test();
+});
diff --git a/services/common/tests/unit/test_utils_sets.js b/services/common/tests/unit/test_utils_sets.js
new file mode 100644
index 0000000000..c15d48528f
--- /dev/null
+++ b/services/common/tests/unit/test_utils_sets.js
@@ -0,0 +1,66 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const EMPTY = new Set();
+const A = new Set(["a"]);
+const ABC = new Set(["a", "b", "c"]);
+const ABCD = new Set(["a", "b", "c", "d"]);
+const BC = new Set(["b", "c"]);
+const BCD = new Set(["b", "c", "d"]);
+const FGH = new Set(["f", "g", "h"]);
+const BCDFGH = new Set(["b", "c", "d", "f", "g", "h"]);
+
+var union = CommonUtils.union;
+var difference = CommonUtils.difference;
+var intersection = CommonUtils.intersection;
+var setEqual = CommonUtils.setEqual;
+
+function do_check_setEqual(a, b) {
+  Assert.ok(setEqual(a, b));
+}
+
+function do_check_not_setEqual(a, b) {
+  Assert.ok(!setEqual(a, b));
+}
+
+add_test(function test_setEqual() {
+  do_check_setEqual(EMPTY, EMPTY);
+  do_check_setEqual(EMPTY, new Set());
+  do_check_setEqual(A, A);
+  do_check_setEqual(A, new Set(["a"]));
+  do_check_setEqual(new Set(["a"]), A);
+  do_check_not_setEqual(A, EMPTY);
+  do_check_not_setEqual(EMPTY, A);
+  do_check_not_setEqual(ABC, A);
+  run_next_test();
+});
+
+add_test(function test_union() {
+  do_check_setEqual(EMPTY, union(EMPTY, EMPTY));
+  do_check_setEqual(ABC, union(EMPTY, ABC));
+  do_check_setEqual(ABC, union(ABC, ABC));
+  do_check_setEqual(ABCD, union(ABC, BCD));
+  do_check_setEqual(ABCD, union(BCD, ABC));
+  do_check_setEqual(BCDFGH, union(BCD, FGH));
+  run_next_test();
+});
+
+add_test(function test_difference() {
+  do_check_setEqual(EMPTY, difference(EMPTY, EMPTY));
+  do_check_setEqual(EMPTY, difference(EMPTY, A));
+  do_check_setEqual(EMPTY, difference(A, A));
+  do_check_setEqual(ABC, difference(ABC, EMPTY));
+  do_check_setEqual(ABC, difference(ABC, FGH));
+  do_check_setEqual(A, difference(ABC, BCD));
+  run_next_test();
+});
+
+add_test(function test_intersection() {
+  do_check_setEqual(EMPTY, intersection(EMPTY, EMPTY));
+  do_check_setEqual(EMPTY, intersection(ABC, EMPTY));
+  do_check_setEqual(EMPTY, intersection(ABC, FGH));
+  do_check_setEqual(BC, intersection(ABC, BCD));
+  run_next_test();
+});
diff --git a/services/common/tests/unit/test_utils_utf8.js b/services/common/tests/unit/test_utils_utf8.js
new file mode 100644
index 0000000000..aa075873b9
--- /dev/null
+++ b/services/common/tests/unit/test_utils_utf8.js
@@ -0,0 +1,9 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function run_test() {
+  let str = "Umlaute: \u00FC \u00E4\n"; // Umlaute: ü ä
+  let encoded = CommonUtils.encodeUTF8(str);
+  let decoded = CommonUtils.decodeUTF8(encoded);
+  Assert.equal(decoded, str);
+}
diff --git a/services/common/tests/unit/test_utils_uuid.js b/services/common/tests/unit/test_utils_uuid.js
new file mode 100644
index 0000000000..33b407e92d
--- /dev/null
+++ b/services/common/tests/unit/test_utils_uuid.js
@@ -0,0 +1,12 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+function run_test() {
+  let uuid = CommonUtils.generateUUID();
+  Assert.equal(uuid.length, 36);
+  Assert.equal(uuid[8], "-");
+
+  run_next_test();
+}
diff --git a/services/common/tests/unit/xpcshell.ini b/services/common/tests/unit/xpcshell.ini
new file mode 100644
index 0000000000..5fdf8d423b
--- /dev/null
+++ b/services/common/tests/unit/xpcshell.ini
@@ -0,0 +1,47 @@
+[DEFAULT]
+head = head_global.js head_helpers.js head_http.js
+firefox-appdir = browser
+support-files =
+  test_storage_adapter/**
+
+# Test load modules first so syntax failures are caught early.
+[test_load_modules.js]
+
+[test_kinto.js]
+tags = blocklist
+[test_storage_adapter.js]
+tags = remote-settings blocklist
+[test_storage_adapter_shutdown.js]
+tags = remote-settings blocklist
+
+[test_utils_atob.js]
+[test_utils_convert_string.js]
+[test_utils_dateprefs.js]
+[test_utils_encodeBase32.js]
+[test_utils_encodeBase64URL.js]
+[test_utils_ensureMillisecondsTimestamp.js]
+[test_utils_makeURI.js]
+[test_utils_namedTimer.js]
+[test_utils_sets.js]
+[test_utils_utf8.js]
+[test_utils_uuid.js]
+
+[test_async_chain.js]
+[test_async_foreach.js]
+
+[test_hawkclient.js]
+skip-if = os == "android"
+[test_hawkrequest.js]
+skip-if = os == "android"
+
+[test_logmanager.js]
+[test_observers.js]
+[test_restrequest.js]
+
+[test_tokenauthenticatedrequest.js]
+
+[test_tokenserverclient.js]
+skip-if = os == "android"
+
+[test_uptake_telemetry.js]
+tags = remote-settings