mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-10-03 22:55:12 +00:00
1651 lines
58 KiB
JavaScript
1651 lines
58 KiB
JavaScript
/* Any copyright is dedicated to the Public Domain.
|
|
* http://creativecommons.org/publicdomain/zero/1.0/ */
|
|
|
|
"use strict";
|
|
|
|
Cu.import("resource://testing-common/httpd.js");
|
|
Cu.import("resource://testing-common/AddonManagerTesting.jsm");
|
|
|
|
XPCOMUtils.defineLazyModuleGetter(this, "Experiments",
|
|
"resource:///modules/experiments/Experiments.jsm");
|
|
|
|
const FILE_MANIFEST = "experiments.manifest";
|
|
const MANIFEST_HANDLER = "manifests/handler";
|
|
|
|
const SEC_IN_ONE_DAY = 24 * 60 * 60;
|
|
const MS_IN_ONE_DAY = SEC_IN_ONE_DAY * 1000;
|
|
|
|
var gProfileDir = null;
|
|
var gHttpServer = null;
|
|
var gHttpRoot = null;
|
|
var gDataRoot = null;
|
|
var gPolicy = null;
|
|
var gManifestObject = null;
|
|
var gManifestHandlerURI = null;
|
|
var gTimerScheduleOffset = -1;
|
|
|
|
function uninstallExperimentAddons() {
|
|
return Task.spawn(function* () {
|
|
let addons = yield getExperimentAddons();
|
|
for (let a of addons) {
|
|
yield AddonTestUtils.uninstallAddonByID(a.id);
|
|
}
|
|
});
|
|
}
|
|
|
|
function testCleanup(experimentsInstance) {
|
|
return Task.spawn(function* () {
|
|
yield promiseRestartManager();
|
|
yield uninstallExperimentAddons();
|
|
yield removeCacheFile();
|
|
});
|
|
}
|
|
|
|
function run_test() {
|
|
run_next_test();
|
|
}
|
|
|
|
add_task(function* test_setup() {
|
|
loadAddonManager();
|
|
gProfileDir = do_get_profile();
|
|
|
|
gHttpServer = new HttpServer();
|
|
gHttpServer.start(-1);
|
|
let port = gHttpServer.identity.primaryPort;
|
|
gHttpRoot = "http://localhost:" + port + "/";
|
|
gDataRoot = gHttpRoot + "data/";
|
|
gManifestHandlerURI = gHttpRoot + MANIFEST_HANDLER;
|
|
gHttpServer.registerDirectory("/data/", do_get_cwd());
|
|
gHttpServer.registerPathHandler("/" + MANIFEST_HANDLER, (request, response) => {
|
|
response.setStatusLine(null, 200, "OK");
|
|
response.write(JSON.stringify(gManifestObject));
|
|
response.processAsync();
|
|
response.finish();
|
|
});
|
|
do_register_cleanup(() => gHttpServer.stop(() => {}));
|
|
|
|
Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
|
|
Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
|
|
Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
|
|
Services.prefs.setCharPref(PREF_MANIFEST_URI, gManifestHandlerURI);
|
|
Services.prefs.setIntPref(PREF_FETCHINTERVAL, 0);
|
|
|
|
gPolicy = new Experiments.Policy();
|
|
patchPolicy(gPolicy, {
|
|
updatechannel: () => "nightly",
|
|
oneshotTimer: (callback, timeout, thisObj, name) => gTimerScheduleOffset = timeout,
|
|
});
|
|
});
|
|
|
|
add_task(function* test_contract() {
|
|
Cc["@mozilla.org/browser/experiments-service;1"].getService();
|
|
});
|
|
|
|
// Test basic starting and stopping of experiments.
|
|
|
|
add_task(function* test_getExperiments() {
|
|
const OBSERVER_TOPIC = "experiments-changed";
|
|
let observerFireCount = 0;
|
|
let expectedObserverFireCount = 0;
|
|
let observer = () => ++observerFireCount;
|
|
Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
|
|
|
|
// Dates the following tests are based on.
|
|
|
|
let baseDate = new Date(2014, 5, 1, 12);
|
|
let startDate1 = futureDate(baseDate, 50 * MS_IN_ONE_DAY);
|
|
let endDate1 = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
|
|
let startDate2 = futureDate(baseDate, 150 * MS_IN_ONE_DAY);
|
|
let endDate2 = futureDate(baseDate, 200 * MS_IN_ONE_DAY);
|
|
|
|
// The manifest data we test with.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT2_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT2_XPI_NAME,
|
|
xpiHash: EXPERIMENT2_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate2),
|
|
endTime: dateToSeconds(endDate2),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate1),
|
|
endTime: dateToSeconds(endDate1),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
// Data to compare the result of Experiments.getExperiments() against.
|
|
|
|
let experimentListData = [
|
|
{
|
|
id: EXPERIMENT2_ID,
|
|
name: "Test experiment 2",
|
|
description: "And yet another experiment that experiments experimentally.",
|
|
},
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
name: EXPERIMENT1_NAME,
|
|
description: "Yet another experiment that experiments experimentally.",
|
|
},
|
|
];
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
// Trigger update, clock set to before any activation.
|
|
// Use updateManifest() to provide for coverage of that path.
|
|
|
|
let now = baseDate;
|
|
gTimerScheduleOffset = -1;
|
|
defineNow(gPolicy, now);
|
|
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
Assert.equal(experiments.getActiveExperimentID(), null,
|
|
"getActiveExperimentID should return null");
|
|
|
|
let list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 0, "Experiment list should be empty.");
|
|
let addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 0, "Precondition: No experiment add-ons are installed.");
|
|
|
|
try {
|
|
let b = yield experiments.getExperimentBranch();
|
|
Assert.ok(false, "getExperimentBranch should fail with no experiment");
|
|
}
|
|
catch (e) {
|
|
Assert.ok(true, "getExperimentBranch correctly threw");
|
|
}
|
|
|
|
// Trigger update, clock set for experiment 1 to start.
|
|
|
|
now = futureDate(startDate1, 5 * MS_IN_ONE_DAY);
|
|
gTimerScheduleOffset = -1;
|
|
defineNow(gPolicy, now);
|
|
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
Assert.equal(experiments.getActiveExperimentID(), EXPERIMENT1_ID,
|
|
"getActiveExperimentID should return the active experiment1");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 1, "An experiment add-on was installed.");
|
|
|
|
experimentListData[1].active = true;
|
|
experimentListData[1].endDate = now.getTime() + 10 * MS_IN_ONE_DAY;
|
|
for (let k of Object.keys(experimentListData[1])) {
|
|
Assert.equal(experimentListData[1][k], list[0][k],
|
|
"Property " + k + " should match reference data.");
|
|
}
|
|
|
|
let b = yield experiments.getExperimentBranch();
|
|
Assert.strictEqual(b, null, "getExperimentBranch should return null by default");
|
|
|
|
b = yield experiments.getExperimentBranch(EXPERIMENT1_ID);
|
|
Assert.strictEqual(b, null, "getExperimentsBranch should return null (with id)");
|
|
|
|
yield experiments.setExperimentBranch(EXPERIMENT1_ID, "foo");
|
|
b = yield experiments.getExperimentBranch();
|
|
Assert.strictEqual(b, "foo", "getExperimentsBranch should return the set value");
|
|
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
Assert.equal(gTimerScheduleOffset, 10 * MS_IN_ONE_DAY,
|
|
"Experiment re-evaluation should have been scheduled correctly.");
|
|
|
|
// Trigger update, clock set for experiment 1 to stop.
|
|
|
|
now = futureDate(endDate1, 1000);
|
|
gTimerScheduleOffset = -1;
|
|
defineNow(gPolicy, now);
|
|
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
Assert.equal(experiments.getActiveExperimentID(), null,
|
|
"getActiveExperimentID should return null again");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 0, "The experiment add-on should be uninstalled.");
|
|
|
|
experimentListData[1].active = false;
|
|
experimentListData[1].endDate = now.getTime();
|
|
for (let k of Object.keys(experimentListData[1])) {
|
|
Assert.equal(experimentListData[1][k], list[0][k],
|
|
"Property " + k + " should match reference data.");
|
|
}
|
|
|
|
Assert.equal(gTimerScheduleOffset, startDate2 - now,
|
|
"Experiment re-evaluation should have been scheduled correctly.");
|
|
|
|
// Trigger update, clock set for experiment 2 to start.
|
|
// Use notify() to provide for coverage of that path.
|
|
|
|
now = startDate2;
|
|
gTimerScheduleOffset = -1;
|
|
defineNow(gPolicy, now);
|
|
|
|
yield experiments.notify();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
Assert.equal(experiments.getActiveExperimentID(), EXPERIMENT2_ID,
|
|
"getActiveExperimentID should return the active experiment2");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 2, "Experiment list should have 2 entries now.");
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 1, "An experiment add-on is installed.");
|
|
|
|
experimentListData[0].active = true;
|
|
experimentListData[0].endDate = now.getTime() + 10 * MS_IN_ONE_DAY;
|
|
for (let i=0; i<experimentListData.length; ++i) {
|
|
let entry = experimentListData[i];
|
|
for (let k of Object.keys(entry)) {
|
|
Assert.equal(entry[k], list[i][k],
|
|
"Entry " + i + " - Property '" + k + "' should match reference data.");
|
|
}
|
|
}
|
|
|
|
Assert.equal(gTimerScheduleOffset, 10 * MS_IN_ONE_DAY,
|
|
"Experiment re-evaluation should have been scheduled correctly.");
|
|
|
|
// Trigger update, clock set for experiment 2 to stop.
|
|
|
|
now = futureDate(startDate2, 10 * MS_IN_ONE_DAY + 1000);
|
|
gTimerScheduleOffset = -1;
|
|
defineNow(gPolicy, now);
|
|
yield experiments.notify();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
Assert.equal(experiments.getActiveExperimentID(), null,
|
|
"getActiveExperimentID should return null again2");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 2, "Experiment list should have 2 entries now.");
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 0, "No experiments add-ons are installed.");
|
|
|
|
experimentListData[0].active = false;
|
|
experimentListData[0].endDate = now.getTime();
|
|
for (let i=0; i<experimentListData.length; ++i) {
|
|
let entry = experimentListData[i];
|
|
for (let k of Object.keys(entry)) {
|
|
Assert.equal(entry[k], list[i][k],
|
|
"Entry " + i + " - Property '" + k + "' should match reference data.");
|
|
}
|
|
}
|
|
|
|
// Cleanup.
|
|
|
|
Services.obs.removeObserver(observer, OBSERVER_TOPIC);
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
add_task(function* test_getActiveExperimentID() {
|
|
// Check that getActiveExperimentID returns the correct result even
|
|
// after .uninit()
|
|
|
|
// Dates the following tests are based on.
|
|
|
|
let baseDate = new Date(2014, 5, 1, 12);
|
|
let startDate1 = futureDate(baseDate, 50 * MS_IN_ONE_DAY);
|
|
let endDate1 = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate1),
|
|
endTime: dateToSeconds(endDate1),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
let now = futureDate(startDate1, 5 * MS_IN_ONE_DAY);
|
|
gTimerScheduleOffset = -1;
|
|
defineNow(gPolicy, now);
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
yield experiments.updateManifest();
|
|
|
|
Assert.equal(experiments.getActiveExperimentID(), EXPERIMENT1_ID,
|
|
"getActiveExperimentID should return the active experiment1");
|
|
|
|
yield promiseRestartManager();
|
|
Assert.equal(experiments.getActiveExperimentID(), EXPERIMENT1_ID,
|
|
"getActiveExperimentID should return the active experiment1 after uninit()");
|
|
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// Test that we handle the experiments addon already being
|
|
// installed properly.
|
|
// We should just pave over them.
|
|
|
|
add_task(function* test_addonAlreadyInstalled() {
|
|
const OBSERVER_TOPIC = "experiments-changed";
|
|
let observerFireCount = 0;
|
|
let expectedObserverFireCount = 0;
|
|
let observer = () => ++observerFireCount;
|
|
Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
|
|
|
|
// Dates the following tests are based on.
|
|
|
|
let baseDate = new Date(2014, 5, 1, 12);
|
|
let startDate = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
|
|
let endDate = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
|
|
|
|
// The manifest data we test with.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate),
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
// Trigger update, clock set to before any activation.
|
|
|
|
let now = baseDate;
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
let list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 0, "Experiment list should be empty.");
|
|
|
|
// Trigger update, clock set for the experiment to start.
|
|
|
|
now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, true, "Experiment 1 should be active.");
|
|
|
|
let addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 1, "1 add-on is installed.");
|
|
|
|
// Install conflicting addon.
|
|
|
|
yield AddonTestUtils.installXPIFromURL(gDataRoot + EXPERIMENT1_XPI_NAME, EXPERIMENT1_XPI_SHA1);
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 1, "1 add-on is installed.");
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should still have 1 entry.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, true, "Experiment 1 should be active.");
|
|
|
|
// Cleanup.
|
|
|
|
Services.obs.removeObserver(observer, OBSERVER_TOPIC);
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
add_task(function* test_lastActiveToday() {
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
replaceExperiments(experiments, FAKE_EXPERIMENTS_1);
|
|
|
|
let e = yield experiments.getExperiments();
|
|
Assert.equal(e.length, 1, "Monkeypatch successful.");
|
|
Assert.equal(e[0].id, "id1", "ID looks sane");
|
|
Assert.ok(e[0].active, "Experiment is active.");
|
|
|
|
let lastActive = yield experiments.lastActiveToday();
|
|
Assert.equal(e[0], lastActive, "Last active object is expected.");
|
|
|
|
replaceExperiments(experiments, FAKE_EXPERIMENTS_2);
|
|
e = yield experiments.getExperiments();
|
|
Assert.equal(e.length, 2, "Monkeypatch successful.");
|
|
|
|
defineNow(gPolicy, e[0].endDate);
|
|
|
|
lastActive = yield experiments.lastActiveToday();
|
|
Assert.ok(lastActive, "Have a last active experiment");
|
|
Assert.equal(lastActive, e[0], "Last active object is expected.");
|
|
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// Test explicitly disabling experiments.
|
|
|
|
add_task(function* test_disableExperiment() {
|
|
// Dates this test is based on.
|
|
|
|
let startDate = new Date(2004, 10, 9, 12);
|
|
let endDate = futureDate(startDate, 100 * MS_IN_ONE_DAY);
|
|
|
|
// The manifest data we test with.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate),
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
// Data to compare the result of Experiments.getExperiments() against.
|
|
|
|
let experimentInfo = {
|
|
id: EXPERIMENT1_ID,
|
|
name: EXPERIMENT1_NAME,
|
|
description: "Yet another experiment that experiments experimentally.",
|
|
};
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
// Trigger update, clock set for the experiment to start.
|
|
|
|
let now = futureDate(startDate, 5 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
|
|
let list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
|
|
experimentInfo.active = true;
|
|
experimentInfo.endDate = now.getTime() + 10 * MS_IN_ONE_DAY;
|
|
for (let k of Object.keys(experimentInfo)) {
|
|
Assert.equal(experimentInfo[k], list[0][k],
|
|
"Property " + k + " should match reference data.");
|
|
}
|
|
|
|
// Test disabling the experiment.
|
|
|
|
now = futureDate(now, 1 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.disableExperiment("foo");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
|
|
|
|
experimentInfo.active = false;
|
|
experimentInfo.endDate = now.getTime();
|
|
for (let k of Object.keys(experimentInfo)) {
|
|
Assert.equal(experimentInfo[k], list[0][k],
|
|
"Property " + k + " should match reference data.");
|
|
}
|
|
|
|
// Test that updating the list doesn't re-enable it.
|
|
|
|
now = futureDate(now, 1 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
|
|
|
|
for (let k of Object.keys(experimentInfo)) {
|
|
Assert.equal(experimentInfo[k], list[0][k],
|
|
"Property " + k + " should match reference data.");
|
|
}
|
|
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
add_task(function* test_disableExperimentsFeature() {
|
|
// Dates this test is based on.
|
|
|
|
let startDate = new Date(2004, 10, 9, 12);
|
|
let endDate = futureDate(startDate, 100 * MS_IN_ONE_DAY);
|
|
|
|
// The manifest data we test with.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate),
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
// Data to compare the result of Experiments.getExperiments() against.
|
|
|
|
let experimentInfo = {
|
|
id: EXPERIMENT1_ID,
|
|
name: EXPERIMENT1_NAME,
|
|
description: "Yet another experiment that experiments experimentally.",
|
|
};
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
Assert.equal(experiments.enabled, true, "Experiments feature should be enabled.");
|
|
|
|
// Trigger update, clock set for the experiment to start.
|
|
|
|
let now = futureDate(startDate, 5 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
|
|
let list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
|
|
experimentInfo.active = true;
|
|
experimentInfo.endDate = now.getTime() + 10 * MS_IN_ONE_DAY;
|
|
for (let k of Object.keys(experimentInfo)) {
|
|
Assert.equal(experimentInfo[k], list[0][k],
|
|
"Property " + k + " should match reference data.");
|
|
}
|
|
|
|
// Test disabling experiments.
|
|
|
|
experiments._toggleExperimentsEnabled(false);
|
|
yield experiments.notify();
|
|
Assert.equal(experiments.enabled, false, "Experiments feature should be disabled now.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
|
|
|
|
experimentInfo.active = false;
|
|
experimentInfo.endDate = now.getTime();
|
|
for (let k of Object.keys(experimentInfo)) {
|
|
Assert.equal(experimentInfo[k], list[0][k],
|
|
"Property " + k + " should match reference data.");
|
|
}
|
|
|
|
// Test that updating the list doesn't re-enable it.
|
|
|
|
now = futureDate(now, 1 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
try {
|
|
yield experiments.updateManifest();
|
|
} catch (e) {
|
|
// Exception expected, the feature is disabled.
|
|
}
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
|
|
|
|
for (let k of Object.keys(experimentInfo)) {
|
|
Assert.equal(experimentInfo[k], list[0][k],
|
|
"Property " + k + " should match reference data.");
|
|
}
|
|
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// Test that after a failed experiment install:
|
|
// * the next applicable experiment gets installed
|
|
// * changing the experiments data later triggers re-evaluation
|
|
|
|
add_task(function* test_installFailure() {
|
|
const OBSERVER_TOPIC = "experiments-changed";
|
|
let observerFireCount = 0;
|
|
let expectedObserverFireCount = 0;
|
|
let observer = () => ++observerFireCount;
|
|
Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
|
|
|
|
// Dates the following tests are based on.
|
|
|
|
let baseDate = new Date(2014, 5, 1, 12);
|
|
let startDate = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
|
|
let endDate = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
|
|
|
|
// The manifest data we test with.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate),
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
{
|
|
id: EXPERIMENT2_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT2_XPI_NAME,
|
|
xpiHash: EXPERIMENT2_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate),
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
// Data to compare the result of Experiments.getExperiments() against.
|
|
|
|
let experimentListData = [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
name: EXPERIMENT1_NAME,
|
|
description: "Yet another experiment that experiments experimentally.",
|
|
},
|
|
{
|
|
id: EXPERIMENT2_ID,
|
|
name: "Test experiment 2",
|
|
description: "And yet another experiment that experiments experimentally.",
|
|
},
|
|
];
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
// Trigger update, clock set to before any activation.
|
|
|
|
let now = baseDate;
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
let list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 0, "Experiment list should be empty.");
|
|
|
|
// Trigger update, clock set for experiment 1 & 2 to start,
|
|
// invalid hash for experiment 1.
|
|
// Order in the manifest matters, so we should start experiment 1,
|
|
// fail to install it & start experiment 2 instead.
|
|
|
|
now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
gManifestObject.experiments[0].xpiHash = "sha1:0000000000000000000000000000000000000000";
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT2_ID, "Experiment 2 should be the sole entry.");
|
|
Assert.equal(list[0].active, true, "Experiment 2 should be active.");
|
|
|
|
// Trigger update, clock set for experiment 2 to stop.
|
|
|
|
now = futureDate(now, 20 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
experimentListData[0].active = false;
|
|
experimentListData[0].endDate = now;
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT2_ID, "Experiment 2 should be the sole entry.");
|
|
Assert.equal(list[0].active, false, "Experiment should not be active.");
|
|
|
|
// Trigger update with a fixed entry for experiment 1,
|
|
// which should get re-evaluated & started now.
|
|
|
|
now = futureDate(now, 20 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
gManifestObject.experiments[0].xpiHash = EXPERIMENT1_XPI_SHA1;
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
experimentListData[0].active = true;
|
|
experimentListData[0].endDate = now.getTime() + 10 * MS_IN_ONE_DAY;
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 2, "Experiment list should have 2 entries now.");
|
|
|
|
for (let i=0; i<experimentListData.length; ++i) {
|
|
let entry = experimentListData[i];
|
|
for (let k of Object.keys(entry)) {
|
|
Assert.equal(entry[k], list[i][k],
|
|
"Entry " + i + " - Property '" + k + "' should match reference data.");
|
|
}
|
|
}
|
|
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// Test that after an experiment was disabled by user action,
|
|
// the experiment is not activated again if manifest data changes.
|
|
|
|
add_task(function* test_userDisabledAndUpdated() {
|
|
const OBSERVER_TOPIC = "experiments-changed";
|
|
let observerFireCount = 0;
|
|
let expectedObserverFireCount = 0;
|
|
let observer = () => ++observerFireCount;
|
|
Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
|
|
|
|
// Dates the following tests are based on.
|
|
|
|
let baseDate = new Date(2014, 5, 1, 12);
|
|
let startDate = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
|
|
let endDate = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
|
|
|
|
// The manifest data we test with.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate),
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
// Trigger update, clock set to before any activation.
|
|
|
|
let now = baseDate;
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
let list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 0, "Experiment list should be empty.");
|
|
|
|
// Trigger update, clock set for experiment 1 to start.
|
|
|
|
now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, true, "Experiment 1 should be active.");
|
|
let todayActive = yield experiments.lastActiveToday();
|
|
Assert.ok(todayActive, "Last active for today reports a value.");
|
|
Assert.equal(todayActive.id, list[0].id, "The entry is what we expect.");
|
|
|
|
// Explicitly disable an experiment.
|
|
|
|
now = futureDate(now, 20 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.disableExperiment("foo");
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, false, "Experiment should not be active anymore.");
|
|
todayActive = yield experiments.lastActiveToday();
|
|
Assert.ok(todayActive, "Last active for today still returns a value.");
|
|
Assert.equal(todayActive.id, list[0].id, "The ID is still the same.");
|
|
|
|
// Trigger an update with a faked change for experiment 1.
|
|
|
|
now = futureDate(now, 20 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
experiments._experiments.get(EXPERIMENT1_ID)._manifestData.xpiHash =
|
|
"sha1:0000000000000000000000000000000000000000";
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, expectedObserverFireCount,
|
|
"Experiments observer should not have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, false, "Experiment should still be inactive.");
|
|
|
|
// Cleanup.
|
|
|
|
Services.obs.removeObserver(observer, OBSERVER_TOPIC);
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// Test that changing the hash for an active experiments triggers an
|
|
// update for it.
|
|
|
|
add_task(function* test_updateActiveExperiment() {
|
|
const OBSERVER_TOPIC = "experiments-changed";
|
|
let observerFireCount = 0;
|
|
let expectedObserverFireCount = 0;
|
|
let observer = () => ++observerFireCount;
|
|
Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
|
|
|
|
// Dates the following tests are based on.
|
|
|
|
let baseDate = new Date(2014, 5, 1, 12);
|
|
let startDate = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
|
|
let endDate = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
|
|
|
|
// The manifest data we test with.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate),
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
// Trigger update, clock set to before any activation.
|
|
|
|
let now = baseDate;
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
let list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 0, "Experiment list should be empty.");
|
|
|
|
let todayActive = yield experiments.lastActiveToday();
|
|
Assert.equal(todayActive, null, "No experiment active today.");
|
|
|
|
// Trigger update, clock set for the experiment to start.
|
|
|
|
now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, true, "Experiment 1 should be active.");
|
|
Assert.equal(list[0].name, EXPERIMENT1_NAME, "Experiments name should match.");
|
|
todayActive = yield experiments.lastActiveToday();
|
|
Assert.ok(todayActive, "todayActive() returns a value.");
|
|
Assert.equal(todayActive.id, list[0].id, "It returns the active experiment.");
|
|
|
|
// Trigger an update for the active experiment by changing it's hash (and xpi)
|
|
// in the manifest.
|
|
|
|
now = futureDate(now, 1 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
gManifestObject.experiments[0].xpiHash = EXPERIMENT1A_XPI_SHA1;
|
|
gManifestObject.experiments[0].xpiURL = gDataRoot + EXPERIMENT1A_XPI_NAME;
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, true, "Experiment 1 should still be active.");
|
|
Assert.equal(list[0].name, EXPERIMENT1A_NAME, "Experiments name should have been updated.");
|
|
todayActive = yield experiments.lastActiveToday();
|
|
Assert.equal(todayActive.id, list[0].id, "last active today is still sane.");
|
|
|
|
// Cleanup.
|
|
|
|
Services.obs.removeObserver(observer, OBSERVER_TOPIC);
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// Tests that setting the disable flag for an active experiment
|
|
// stops it.
|
|
|
|
add_task(function* test_disableActiveExperiment() {
|
|
const OBSERVER_TOPIC = "experiments-changed";
|
|
let observerFireCount = 0;
|
|
let expectedObserverFireCount = 0;
|
|
let observer = () => ++observerFireCount;
|
|
Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
|
|
|
|
// Dates the following tests are based on.
|
|
|
|
let baseDate = new Date(2014, 5, 1, 12);
|
|
let startDate = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
|
|
let endDate = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
|
|
|
|
// The manifest data we test with.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate),
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
// Trigger update, clock set to before any activation.
|
|
|
|
let now = baseDate;
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
let list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 0, "Experiment list should be empty.");
|
|
|
|
// Trigger update, clock set for the experiment to start.
|
|
|
|
now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, true, "Experiment 1 should be active.");
|
|
|
|
// Trigger an update with the experiment being disabled.
|
|
|
|
now = futureDate(now, 1 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
gManifestObject.experiments[0].disabled = true;
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, false, "Experiment 1 should be disabled.");
|
|
|
|
// Check that the experiment stays disabled.
|
|
|
|
now = futureDate(now, 1 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
delete gManifestObject.experiments[0].disabled;
|
|
yield experiments.updateManifest();
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, false, "Experiment 1 should still be disabled.");
|
|
|
|
// Cleanup.
|
|
|
|
Services.obs.removeObserver(observer, OBSERVER_TOPIC);
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// Test that:
|
|
// * setting the frozen flag for a not-yet-started experiment keeps
|
|
// it from starting
|
|
// * after a removing the frozen flag, the experiment can still start
|
|
|
|
add_task(function* test_freezePendingExperiment() {
|
|
const OBSERVER_TOPIC = "experiments-changed";
|
|
let observerFireCount = 0;
|
|
let expectedObserverFireCount = 0;
|
|
let observer = () => ++observerFireCount;
|
|
Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
|
|
|
|
// Dates the following tests are based on.
|
|
|
|
let baseDate = new Date(2014, 5, 1, 12);
|
|
let startDate = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
|
|
let endDate = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
|
|
|
|
// The manifest data we test with.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate),
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
// Trigger update, clock set to before any activation.
|
|
|
|
let now = baseDate;
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
let list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 0, "Experiment list should be empty.");
|
|
|
|
// Trigger update, clock set for the experiment to start but frozen.
|
|
|
|
now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
gManifestObject.experiments[0].frozen = true;
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, expectedObserverFireCount,
|
|
"Experiments observer should have not been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 0, "Experiment list should have no entries yet.");
|
|
|
|
// Trigger an update with the experiment not being frozen anymore.
|
|
|
|
now = futureDate(now, 1 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
delete gManifestObject.experiments[0].frozen;
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, true, "Experiment 1 should be active now.");
|
|
|
|
// Cleanup.
|
|
|
|
Services.obs.removeObserver(observer, OBSERVER_TOPIC);
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// Test that setting the frozen flag for an active experiment doesn't
|
|
// stop it.
|
|
|
|
add_task(function* test_freezeActiveExperiment() {
|
|
const OBSERVER_TOPIC = "experiments-changed";
|
|
let observerFireCount = 0;
|
|
let expectedObserverFireCount = 0;
|
|
let observer = () => ++observerFireCount;
|
|
Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
|
|
|
|
// Dates the following tests are based on.
|
|
|
|
let baseDate = new Date(2014, 5, 1, 12);
|
|
let startDate = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
|
|
let endDate = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
|
|
|
|
// The manifest data we test with.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate),
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
// Trigger update, clock set to before any activation.
|
|
|
|
let now = baseDate;
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
let list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 0, "Experiment list should be empty.");
|
|
|
|
// Trigger update, clock set for the experiment to start.
|
|
|
|
now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, true, "Experiment 1 should be active.");
|
|
Assert.equal(list[0].name, EXPERIMENT1_NAME, "Experiments name should match.");
|
|
|
|
// Trigger an update with the experiment being disabled.
|
|
|
|
now = futureDate(now, 1 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
gManifestObject.experiments[0].frozen = true;
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, true, "Experiment 1 should still be active.");
|
|
|
|
// Cleanup.
|
|
|
|
Services.obs.removeObserver(observer, OBSERVER_TOPIC);
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// Test that removing an active experiment from the manifest doesn't
|
|
// stop it.
|
|
|
|
add_task(function* test_removeActiveExperiment() {
|
|
const OBSERVER_TOPIC = "experiments-changed";
|
|
let observerFireCount = 0;
|
|
let expectedObserverFireCount = 0;
|
|
let observer = () => ++observerFireCount;
|
|
Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
|
|
|
|
// Dates the following tests are based on.
|
|
|
|
let baseDate = new Date(2014, 5, 1, 12);
|
|
let startDate = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
|
|
let endDate = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
|
|
let startDate2 = futureDate(baseDate, 20000 * MS_IN_ONE_DAY);
|
|
let endDate2 = futureDate(baseDate, 30000 * MS_IN_ONE_DAY);
|
|
|
|
// The manifest data we test with.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate),
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
{
|
|
id: EXPERIMENT2_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT2_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate2),
|
|
endTime: dateToSeconds(endDate2),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
// Trigger update, clock set to before any activation.
|
|
|
|
let now = baseDate;
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
let list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 0, "Experiment list should be empty.");
|
|
|
|
// Trigger update, clock set for the experiment to start.
|
|
|
|
now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, true, "Experiment 1 should be active.");
|
|
Assert.equal(list[0].name, EXPERIMENT1_NAME, "Experiments name should match.");
|
|
|
|
// Trigger an update with experiment 1 missing from the manifest
|
|
|
|
now = futureDate(now, 1 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
gManifestObject.experiments[0].frozen = true;
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, true, "Experiment 1 should still be active.");
|
|
|
|
// Cleanup.
|
|
|
|
Services.obs.removeObserver(observer, OBSERVER_TOPIC);
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// Test that we correctly handle experiment start & install failures.
|
|
|
|
add_task(function* test_invalidUrl() {
|
|
const OBSERVER_TOPIC = "experiments-changed";
|
|
let observerFireCount = 0;
|
|
let expectedObserverFireCount = 0;
|
|
let observer = () => ++observerFireCount;
|
|
Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
|
|
|
|
// Dates the following tests are based on.
|
|
|
|
let baseDate = new Date(2014, 5, 1, 12);
|
|
let startDate = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
|
|
let endDate = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
|
|
|
|
// The manifest data we test with.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME + ".invalid",
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: 0,
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
// Trigger update, clock set for the experiment to start.
|
|
|
|
let now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
gTimerScheduleOffset = null;
|
|
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
Assert.equal(gTimerScheduleOffset, null, "No new timer should have been scheduled.");
|
|
|
|
let list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 0, "Experiment list should be empty.");
|
|
|
|
// Cleanup.
|
|
|
|
Services.obs.removeObserver(observer, OBSERVER_TOPIC);
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// Test that we handle it properly when active experiment addons are being
|
|
// uninstalled.
|
|
|
|
add_task(function* test_unexpectedUninstall() {
|
|
const OBSERVER_TOPIC = "experiments-changed";
|
|
let observerFireCount = 0;
|
|
let expectedObserverFireCount = 0;
|
|
let observer = () => ++observerFireCount;
|
|
Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
|
|
|
|
// Dates the following tests are based on.
|
|
|
|
let baseDate = new Date(2014, 5, 1, 12);
|
|
let startDate = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
|
|
let endDate = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
|
|
|
|
// The manifest data we test with.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate),
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
// Trigger update, clock set to before any activation.
|
|
|
|
let now = baseDate;
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
let list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 0, "Experiment list should be empty.");
|
|
|
|
// Trigger update, clock set for the experiment to start.
|
|
|
|
now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
Assert.equal(observerFireCount, ++expectedObserverFireCount,
|
|
"Experiments observer should have been called.");
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, true, "Experiment 1 should be active.");
|
|
|
|
// Uninstall the addon through the addon manager instead of stopping it through
|
|
// the experiments API.
|
|
|
|
yield AddonTestUtils.uninstallAddonByID(EXPERIMENT1_ID);
|
|
yield experiments._mainTask;
|
|
|
|
yield experiments.notify();
|
|
|
|
list = yield experiments.getExperiments();
|
|
Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
|
|
Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.equal(list[0].active, false, "Experiment 1 should not be active anymore.");
|
|
|
|
// Cleanup.
|
|
|
|
Services.obs.removeObserver(observer, OBSERVER_TOPIC);
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// If the Addon Manager knows of an experiment that we don't, it should get
|
|
// uninstalled.
|
|
add_task(function* testUnknownExperimentsUninstalled() {
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
let addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 0, "Precondition: No experiment add-ons are present.");
|
|
|
|
// Simulate us not listening.
|
|
experiments._unregisterWithAddonManager();
|
|
yield AddonTestUtils.installXPIFromURL(gDataRoot + EXPERIMENT1_XPI_NAME, EXPERIMENT1_XPI_SHA1);
|
|
experiments._registerWithAddonManager();
|
|
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 1, "Experiment 1 installed via AddonManager");
|
|
|
|
// Simulate no known experiments.
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [],
|
|
};
|
|
|
|
yield experiments.updateManifest();
|
|
let fromManifest = yield experiments.getExperiments();
|
|
Assert.equal(fromManifest.length, 0, "No experiments known in manifest.");
|
|
|
|
// And the unknown add-on should be gone.
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 0, "Experiment 1 was uninstalled.");
|
|
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// If someone else installs an experiment add-on, we detect and stop that.
|
|
add_task(function* testForeignExperimentInstall() {
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [],
|
|
};
|
|
|
|
yield experiments.init();
|
|
|
|
let addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 0, "Precondition: No experiment add-ons present.");
|
|
|
|
let failed = false;
|
|
try {
|
|
yield AddonTestUtils.installXPIFromURL(gDataRoot + EXPERIMENT1_XPI_NAME, EXPERIMENT1_XPI_SHA1);
|
|
} catch (ex) {
|
|
failed = true;
|
|
}
|
|
Assert.ok(failed, "Add-on install should not have completed successfully");
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 0, "Add-on install should have been cancelled.");
|
|
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// Experiment add-ons will be disabled after Addon Manager restarts. Ensure
|
|
// we enable them automatically.
|
|
add_task(function* testEnabledAfterRestart() {
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: gPolicy.now().getTime() / 1000 - 60,
|
|
endTime: gPolicy.now().getTime() / 1000 + 60,
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
let addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 0, "Precondition: No experiment add-ons installed.");
|
|
|
|
yield experiments.updateManifest();
|
|
let fromManifest = yield experiments.getExperiments();
|
|
Assert.equal(fromManifest.length, 1, "A single experiment is known.");
|
|
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 1, "A single experiment add-on is installed.");
|
|
Assert.ok(addons[0].isActive, "That experiment is active.");
|
|
|
|
dump("Restarting Addon Manager\n");
|
|
yield promiseRestartManager();
|
|
experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 1, "The experiment is still there after restart.");
|
|
Assert.ok(addons[0].userDisabled, "But it is disabled.");
|
|
Assert.equal(addons[0].isActive, false, "And not active.");
|
|
|
|
yield experiments.updateManifest();
|
|
Assert.ok(addons[0].isActive, "It activates when the manifest is evaluated.");
|
|
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// If experiment add-ons were ever started, maxStartTime shouldn't be evaluated
|
|
// anymore. Ensure that if maxStartTime is passed but experiment has started
|
|
// already, maxStartTime does not cause deactivation.
|
|
|
|
add_task(function* testMaxStartTimeEvaluation() {
|
|
|
|
// Dates the following tests are based on.
|
|
|
|
let startDate = new Date(2014, 5, 1, 12);
|
|
let now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
|
|
let maxStartDate = futureDate(startDate, 100 * MS_IN_ONE_DAY);
|
|
let endDate = futureDate(startDate, 1000 * MS_IN_ONE_DAY);
|
|
|
|
defineNow(gPolicy, now);
|
|
|
|
// The manifest data we test with.
|
|
// We set a value for maxStartTime.
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: dateToSeconds(startDate),
|
|
endTime: dateToSeconds(endDate),
|
|
maxActiveSeconds: 1000 * SEC_IN_ONE_DAY,
|
|
maxStartTime: dateToSeconds(maxStartDate),
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
let addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 0, "Precondition: No experiment add-ons installed.");
|
|
|
|
yield experiments.updateManifest();
|
|
let fromManifest = yield experiments.getExperiments();
|
|
Assert.equal(fromManifest.length, 1, "A single experiment is known.");
|
|
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 1, "A single experiment add-on is installed.");
|
|
Assert.ok(addons[0].isActive, "That experiment is active.");
|
|
|
|
dump("Setting current time to maxStartTime + 100 days and reloading manifest\n");
|
|
now = futureDate(maxStartDate, 100 * MS_IN_ONE_DAY);
|
|
defineNow(gPolicy, now);
|
|
yield experiments.updateManifest();
|
|
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 1, "The experiment is still there.");
|
|
Assert.ok(addons[0].isActive, "It is still active.");
|
|
|
|
yield testCleanup(experiments);
|
|
});
|
|
|
|
// Test coverage for an add-on uninstall disabling the experiment and that it stays
|
|
// disabled over restarts.
|
|
add_task(function* test_foreignUninstallAndRestart() {
|
|
let experiments = new Experiments.Experiments(gPolicy);
|
|
|
|
gManifestObject = {
|
|
"version": 1,
|
|
experiments: [
|
|
{
|
|
id: EXPERIMENT1_ID,
|
|
xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
|
|
xpiHash: EXPERIMENT1_XPI_SHA1,
|
|
startTime: gPolicy.now().getTime() / 1000 - 60,
|
|
endTime: gPolicy.now().getTime() / 1000 + 60,
|
|
maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
|
|
appName: ["XPCShell"],
|
|
channel: ["nightly"],
|
|
},
|
|
],
|
|
};
|
|
|
|
let addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 0, "Precondition: No experiment add-ons installed.");
|
|
|
|
yield experiments.updateManifest();
|
|
let experimentList = yield experiments.getExperiments();
|
|
Assert.equal(experimentList.length, 1, "A single experiment is known.");
|
|
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 1, "A single experiment add-on is installed.");
|
|
Assert.ok(addons[0].isActive, "That experiment is active.");
|
|
|
|
yield AddonTestUtils.uninstallAddonByID(EXPERIMENT1_ID);
|
|
yield experiments._mainTask;
|
|
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 0, "Experiment add-on should have been removed.");
|
|
|
|
experimentList = yield experiments.getExperiments();
|
|
Assert.equal(experimentList.length, 1, "A single experiment is known.");
|
|
Assert.equal(experimentList[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.ok(!experimentList[0].active, "Experiment 1 should not be active anymore.");
|
|
|
|
// Fake restart behaviour.
|
|
yield promiseRestartManager();
|
|
experiments = new Experiments.Experiments(gPolicy);
|
|
yield experiments.updateManifest();
|
|
|
|
addons = yield getExperimentAddons();
|
|
Assert.equal(addons.length, 0, "No experiment add-ons installed.");
|
|
|
|
experimentList = yield experiments.getExperiments();
|
|
Assert.equal(experimentList.length, 1, "A single experiment is known.");
|
|
Assert.equal(experimentList[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
|
|
Assert.ok(!experimentList[0].active, "Experiment 1 should not be active.");
|
|
|
|
yield testCleanup(experiments);
|
|
});
|