summaryrefslogtreecommitdiffstats
path: root/toolkit/components/crashes/CrashManagerTest.jsm
diff options
context:
space:
mode:
Diffstat (limited to 'toolkit/components/crashes/CrashManagerTest.jsm')
-rw-r--r--toolkit/components/crashes/CrashManagerTest.jsm186
1 files changed, 186 insertions, 0 deletions
diff --git a/toolkit/components/crashes/CrashManagerTest.jsm b/toolkit/components/crashes/CrashManagerTest.jsm
new file mode 100644
index 000000000..2c6c4b1a0
--- /dev/null
+++ b/toolkit/components/crashes/CrashManagerTest.jsm
@@ -0,0 +1,186 @@
+/* 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/. */
+
+/*
+ * This file provides common and shared functionality to facilitate
+ * testing of the Crashes component (CrashManager.jsm).
+ */
+
+"use strict";
+
+const {classes: Cc, interfaces: Ci, utils: Cu} = Components;
+
+this.EXPORTED_SYMBOLS = [
+ "configureLogging",
+ "getManager",
+ "sleep",
+ "TestingCrashManager",
+];
+
+Cu.import("resource://gre/modules/CrashManager.jsm", this);
+Cu.import("resource://gre/modules/Log.jsm", this);
+Cu.import("resource://gre/modules/osfile.jsm", this);
+Cu.import("resource://gre/modules/Promise.jsm", this);
+Cu.import("resource://gre/modules/Task.jsm", this);
+Cu.import("resource://gre/modules/Timer.jsm", this);
+
+var loggingConfigured = false;
+
+this.configureLogging = function () {
+ if (loggingConfigured) {
+ return;
+ }
+
+ let log = Log.repository.getLogger("Crashes.CrashManager");
+ log.level = Log.Level.All;
+ let appender = new Log.DumpAppender();
+ appender.level = Log.Level.All;
+ log.addAppender(appender);
+ loggingConfigured = true;
+};
+
+this.sleep = function (wait) {
+ let deferred = Promise.defer();
+
+ setTimeout(() => {
+ deferred.resolve();
+ }, wait);
+
+ return deferred.promise;
+};
+
+this.TestingCrashManager = function (options) {
+ CrashManager.call(this, options);
+}
+
+this.TestingCrashManager.prototype = {
+ __proto__: CrashManager.prototype,
+
+ createDummyDump: function (submitted=false, date=new Date(), hr=false) {
+ let uuid = Cc["@mozilla.org/uuid-generator;1"]
+ .getService(Ci.nsIUUIDGenerator)
+ .generateUUID()
+ .toString();
+ uuid = uuid.substring(1, uuid.length - 1);
+
+ let path;
+ let mode;
+ if (submitted) {
+ if (hr) {
+ path = OS.Path.join(this._submittedDumpsDir, "bp-hr-" + uuid + ".txt");
+ } else {
+ path = OS.Path.join(this._submittedDumpsDir, "bp-" + uuid + ".txt");
+ }
+ mode = OS.Constants.libc.S_IRUSR | OS.Constants.libc.S_IWUSR |
+ OS.Constants.libc.S_IRGRP | OS.Constants.libc.S_IROTH;
+ } else {
+ path = OS.Path.join(this._pendingDumpsDir, uuid + ".dmp");
+ mode = OS.Constants.libc.S_IRUSR | OS.Constants.libc.S_IWUSR;
+ }
+
+ return Task.spawn(function* () {
+ let f = yield OS.File.open(path, {create: true}, {unixMode: mode});
+ yield f.setDates(date, date);
+ yield f.close();
+ dump("Created fake crash: " + path + "\n");
+
+ return uuid;
+ });
+ },
+
+ createIgnoredDumpFile: function (filename, submitted=false) {
+ let path;
+ if (submitted) {
+ path = OS.Path.join(this._submittedDumpsDir, filename);
+ } else {
+ path = OS.Path.join(this._pendingDumpsDir, filename);
+ }
+
+ return Task.spawn(function* () {
+ let mode = OS.Constants.libc.S_IRUSR | OS.Constants.libc.S_IWUSR;
+ yield OS.File.open(path, {create: true}, {unixMode: mode});
+ dump ("Create ignored dump file: " + path + "\n");
+ });
+ },
+
+ createEventsFile: function (filename, type, date, content, index=0) {
+ let path = OS.Path.join(this._eventsDirs[index], filename);
+
+ let data = type + "\n" +
+ Math.floor(date.getTime() / 1000) + "\n" +
+ content;
+ let encoder = new TextEncoder();
+ let array = encoder.encode(data);
+
+ return Task.spawn(function* () {
+ yield OS.File.writeAtomic(path, array);
+ yield OS.File.setDates(path, date, date);
+ });
+ },
+
+ /**
+ * Overwrite event file handling to process our test file type.
+ *
+ * We can probably delete this once we have actual events defined.
+ */
+ _handleEventFilePayload: function (store, entry, type, date, payload) {
+ if (type == "test.1") {
+ if (payload == "malformed") {
+ return this.EVENT_FILE_ERROR_MALFORMED;
+ } else if (payload == "success") {
+ return this.EVENT_FILE_SUCCESS;
+ }
+ return this.EVENT_FILE_ERROR_UNKNOWN_EVENT;
+ }
+
+ return CrashManager.prototype._handleEventFilePayload.call(this,
+ store,
+ entry,
+ type,
+ date,
+ payload);
+ },
+};
+
+var DUMMY_DIR_COUNT = 0;
+
+this.getManager = function () {
+ return Task.spawn(function* () {
+ const dirMode = OS.Constants.libc.S_IRWXU;
+ let baseFile = OS.Constants.Path.profileDir;
+
+ function makeDir(create=true) {
+ return Task.spawn(function* () {
+ let path = OS.Path.join(baseFile, "dummy-dir-" + DUMMY_DIR_COUNT++);
+
+ if (!create) {
+ return path;
+ }
+
+ dump("Creating directory: " + path + "\n");
+ yield OS.File.makeDir(path, {unixMode: dirMode});
+
+ return path;
+ });
+ }
+
+ let pendingD = yield makeDir();
+ let submittedD = yield makeDir();
+ let eventsD1 = yield makeDir();
+ let eventsD2 = yield makeDir();
+
+ // Store directory is created at run-time if needed. Ensure those code
+ // paths are triggered.
+ let storeD = yield makeDir(false);
+
+ let m = new TestingCrashManager({
+ pendingDumpsDir: pendingD,
+ submittedDumpsDir: submittedD,
+ eventsDirs: [eventsD1, eventsD2],
+ storeDir: storeD,
+ });
+
+ return m;
+ });
+};