diff options
Diffstat (limited to 'toolkit/crashreporter/test/browser')
8 files changed, 678 insertions, 0 deletions
diff --git a/toolkit/crashreporter/test/browser/.eslintrc.js b/toolkit/crashreporter/test/browser/.eslintrc.js new file mode 100644 index 000000000..c764b133d --- /dev/null +++ b/toolkit/crashreporter/test/browser/.eslintrc.js @@ -0,0 +1,7 @@ +"use strict"; + +module.exports = { + "extends": [ + "../../../../testing/mochitest/browser.eslintrc.js" + ] +}; diff --git a/toolkit/crashreporter/test/browser/browser.ini b/toolkit/crashreporter/test/browser/browser.ini new file mode 100644 index 000000000..b58176571 --- /dev/null +++ b/toolkit/crashreporter/test/browser/browser.ini @@ -0,0 +1,8 @@ +[DEFAULT] +support-files = + head.js + +[browser_aboutCrashes.js] +[browser_aboutCrashesResubmit.js] +[browser_bug471404.js] +[browser_clearReports.js] diff --git a/toolkit/crashreporter/test/browser/browser_aboutCrashes.js b/toolkit/crashreporter/test/browser/browser_aboutCrashes.js new file mode 100644 index 000000000..1293df030 --- /dev/null +++ b/toolkit/crashreporter/test/browser/browser_aboutCrashes.js @@ -0,0 +1,27 @@ +add_task(function* test() { + let appD = make_fake_appdir(); + let crD = appD.clone(); + crD.append("Crash Reports"); + let crashes = add_fake_crashes(crD, 5); + // sanity check + let dirSvc = Components.classes["@mozilla.org/file/directory_service;1"] + .getService(Components.interfaces.nsIProperties); + let appDtest = dirSvc.get("UAppData", Components.interfaces.nsILocalFile); + ok(appD.equals(appDtest), "directory service provider registered ok"); + + yield BrowserTestUtils.withNewTab({ gBrowser, url: "about:crashes" }, function (browser) { + info("about:crashes loaded"); + return ContentTask.spawn(browser, crashes, function (crashes) { + let doc = content.document; + let crashlinks = doc.getElementById("submitted").querySelectorAll(".crashReport"); + Assert.equal(crashlinks.length, crashes.length, + "about:crashes lists correct number of crash reports"); + for (let i = 0; i < crashes.length; i++) { + Assert.equal(crashlinks[i].firstChild.textContent, crashes[i].id, + i + ": crash ID is correct"); + } + }); + }); + + cleanup_fake_appdir(); +}); diff --git a/toolkit/crashreporter/test/browser/browser_aboutCrashesResubmit.js b/toolkit/crashreporter/test/browser/browser_aboutCrashesResubmit.js new file mode 100644 index 000000000..a911c67e8 --- /dev/null +++ b/toolkit/crashreporter/test/browser/browser_aboutCrashesResubmit.js @@ -0,0 +1,152 @@ +function cleanup_and_finish() { + try { + cleanup_fake_appdir(); + } catch (ex) {} + Services.prefs.clearUserPref("breakpad.reportURL"); + BrowserTestUtils.removeTab(gBrowser.selectedTab).then(finish); +} + +/* + * check_crash_list + * + * Check that the list of crashes displayed by about:crashes matches + * the list of crashes that we placed in the pending+submitted directories. + * + * NB: This function is run in the child process via ContentTask.spawn. + */ +function check_crash_list(crashes) { + let doc = content.document; + let crashlinks = doc.getElementsByClassName("crashReport"); + Assert.equal(crashlinks.length, crashes.length, + "about:crashes lists correct number of crash reports"); + // no point in checking this if the lists aren't the same length + if (crashlinks.length == crashes.length) { + for (let i=0; i<crashes.length; i++) { + Assert.equal(crashlinks[i].id, crashes[i].id, i + ": crash ID is correct"); + if (crashes[i].pending) { + // we set the breakpad.reportURL pref in test() + Assert.equal(crashlinks[i].getAttribute("href"), + "http://example.com/browser/toolkit/crashreporter/about/throttling", + "pending URL links to the correct static page"); + } + } + } +} + +/* + * check_submit_pending + * + * Click on a pending crash in about:crashes, wait for it to be submitted (which + * should redirect us to the crash report page). Verify that the data provided + * by our test crash report server matches the data we submitted. + * Additionally, click "back" and verify that the link now points to our new + */ +function check_submit_pending(tab, crashes) { + let browser = gBrowser.getBrowserForTab(tab); + let SubmittedCrash = null; + let CrashID = null; + let CrashURL = null; + function csp_onload() { + // loaded the crash report page + ok(true, 'got submission onload'); + + ContentTask.spawn(browser, null, function() { + // grab the Crash ID here to verify later + let CrashID = content.location.search.split("=")[1]; + let CrashURL = content.location.toString(); + + // check the JSON content vs. what we submitted + let result = JSON.parse(content.document.documentElement.textContent); + Assert.equal(result.upload_file_minidump, "MDMP", "minidump file sent properly"); + Assert.equal(result.memory_report, "Let's pretend this is a memory report", + "memory report sent properly"); + Assert.equal(+result.Throttleable, 0, "correctly sent as non-throttleable"); + // we checked these, they're set by the submission process, + // so they won't be in the "extra" data. + delete result.upload_file_minidump; + delete result.memory_report; + delete result.Throttleable; + + return { id: CrashID, url: CrashURL, result }; + }).then(({ id, url, result }) => { + // Likewise, this is discarded before it gets to the server + delete SubmittedCrash.extra.ServerURL; + + CrashID = id; + CrashURL = url; + for (let x in result) { + if (x in SubmittedCrash.extra) + is(result[x], SubmittedCrash.extra[x], + "submitted value for " + x + " matches expected"); + else + ok(false, "property " + x + " missing from submitted data!"); + } + for (let y in SubmittedCrash.extra) { + if (!(y in result)) + ok(false, "property " + y + " missing from result data!"); + } + + // NB: Despite appearances, this doesn't use a CPOW. + BrowserTestUtils.waitForEvent(browser, "pageshow", true).then(csp_pageshow); + + // now navigate back + browser.goBack(); + }); + } + function csp_fail() { + browser.removeEventListener("CrashSubmitFailed", csp_fail, true); + ok(false, "failed to submit crash report!"); + cleanup_and_finish(); + } + browser.addEventListener("CrashSubmitFailed", csp_fail, true); + BrowserTestUtils.browserLoaded(browser, false, (url) => url !== "about:crashes").then(csp_onload); + function csp_pageshow() { + ContentTask.spawn(browser, { CrashID, CrashURL }, function({ CrashID, CrashURL }) { + Assert.equal(content.location.href, "about:crashes", "navigated back successfully"); + let link = content.document.getElementById(CrashID); + Assert.notEqual(link, null, "crash report link changed correctly"); + if (link) + Assert.equal(link.href, CrashURL, "crash report link points to correct href"); + }).then(cleanup_and_finish); + } + + // try submitting the pending report + for (let crash of crashes) { + if (crash.pending) { + SubmittedCrash = crash; + break; + } + } + + ContentTask.spawn(browser, SubmittedCrash.id, function(id) { + let link = content.document.getElementById(id); + link.click(); + }); +} + +function test() { + waitForExplicitFinish(); + let appD = make_fake_appdir(); + let crD = appD.clone(); + crD.append("Crash Reports"); + let crashes = add_fake_crashes(crD, 1); + // we don't need much data here, it's not going to a real Socorro + crashes.push(addPendingCrashreport(crD, + crashes[crashes.length - 1].date + 60000, + {'ServerURL': 'http://example.com/browser/toolkit/crashreporter/test/browser/crashreport.sjs', + 'ProductName': 'Test App', + // test that we don't truncate + // at = (bug 512853) + 'Foo': 'ABC=XYZ' + })); + crashes.sort((a, b) => b.date - a.date); + + // set this pref so we can link to our test server + Services.prefs.setCharPref("breakpad.reportURL", + "http://example.com/browser/toolkit/crashreporter/test/browser/crashreport.sjs?id="); + + BrowserTestUtils.openNewForegroundTab(gBrowser, "about:crashes").then((tab) => { + ContentTask.spawn(tab.linkedBrowser, crashes, check_crash_list) + .then(() => check_submit_pending(tab, crashes)); + }); +} diff --git a/toolkit/crashreporter/test/browser/browser_bug471404.js b/toolkit/crashreporter/test/browser/browser_bug471404.js new file mode 100644 index 000000000..f0eb00b71 --- /dev/null +++ b/toolkit/crashreporter/test/browser/browser_bug471404.js @@ -0,0 +1,41 @@ +function check_clear_visible(browser, aVisible) { + return ContentTask.spawn(browser, aVisible, function (aVisible) { + let doc = content.document; + let visible = false; + let button = doc.getElementById("clear-reports"); + if (button) { + let style = doc.defaultView.getComputedStyle(button, ""); + if (style.display != "none" && + style.visibility == "visible") + visible = true; + } + Assert.equal(visible, aVisible, + "clear reports button is " + (aVisible ? "visible" : "hidden")); + }); +} + +// each test here has a setup (run before loading about:crashes) and onload (run after about:crashes loads) +var _tests = [{setup: null, onload: function(browser) { return check_clear_visible(browser, false); }}, + {setup: function(crD) { return add_fake_crashes(crD, 1); }, + onload: function(browser) { return check_clear_visible(browser, true); }} + ]; + +add_task(function* test() { + let appD = make_fake_appdir(); + let crD = appD.clone(); + crD.append("Crash Reports"); + + yield BrowserTestUtils.withNewTab({ gBrowser, url: "about:blank" }, function* (browser) { + for (let test of _tests) { + // Run setup before loading about:crashes. + if (test.setup) { + yield test.setup(crD); + } + + BrowserTestUtils.loadURI(browser, "about:crashes"); + yield BrowserTestUtils.browserLoaded(browser).then(() => test.onload(browser)); + } + }); + + cleanup_fake_appdir(); +}); diff --git a/toolkit/crashreporter/test/browser/browser_clearReports.js b/toolkit/crashreporter/test/browser/browser_clearReports.js new file mode 100644 index 000000000..a7a1780a9 --- /dev/null +++ b/toolkit/crashreporter/test/browser/browser_clearReports.js @@ -0,0 +1,124 @@ +/* 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/. */ + +function clickClearReports(browser) { + let doc = content.document; + + let button = doc.getElementById("clear-reports"); + + if (!button) { + Assert.ok(false, "Button not found"); + return Promise.resolve(); + } + + let style = doc.defaultView.getComputedStyle(button, ""); + + Assert.notEqual(style.display, "none", "Clear reports button visible"); + + let deferred = {}; + deferred.promise = new Promise(resolve => deferred.resolve = resolve); + var observer = new content.MutationObserver(function(mutations) { + for (let mutation of mutations) { + if (mutation.type == "attributes" && + mutation.attributeName == "style") { + observer.disconnect(); + Assert.equal(style.display, "none", "Clear reports button hidden"); + deferred.resolve(); + } + } + }); + observer.observe(button, { + attributes: true, + childList: true, + characterData: true, + attributeFilter: ["style"], + }); + + button.click(); + return deferred.promise; +} + +var promptShown = false; + +var oldPrompt = Services.prompt; +Services.prompt = { + confirm: function() { + promptShown = true; + return true; + }, +}; + +registerCleanupFunction(function () { + Services.prompt = oldPrompt; +}); + +add_task(function* test() { + let appD = make_fake_appdir(); + let crD = appD.clone(); + crD.append("Crash Reports"); + + // Add crashes to submitted dir + let submitdir = crD.clone(); + submitdir.append("submitted"); + + let file1 = submitdir.clone(); + file1.append("bp-nontxt"); + file1.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o666); + let file2 = submitdir.clone(); + file2.append("nonbp-file.txt"); + file2.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o666); + add_fake_crashes(crD, 5); + + // Add crashes to pending dir + let pendingdir = crD.clone(); + pendingdir.append("pending"); + + let crashes = add_fake_crashes(crD, 2); + addPendingCrashreport(crD, crashes[0].date); + addPendingCrashreport(crD, crashes[1].date); + + // Add crashes to reports dir + let report1 = crD.clone(); + report1.append("NotInstallTime777"); + report1.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o666); + let report2 = crD.clone(); + report2.append("InstallTime" + Services.appinfo.appBuildID); + report2.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o666); + let report3 = crD.clone(); + report3.append("InstallTimeNew"); + report3.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o666); + let report4 = crD.clone(); + report4.append("InstallTimeOld"); + report4.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o666); + report4.lastModifiedTime = Date.now() - 63172000000; + + registerCleanupFunction(function () { + cleanup_fake_appdir(); + }); + + yield BrowserTestUtils.withNewTab({ gBrowser, url: "about:crashes" }, + function* (browser) { + let dirs = [ submitdir, pendingdir, crD ]; + let existing = [ file1.path, file2.path, report1.path, report2.path, + report3.path, submitdir.path, pendingdir.path ]; + + yield ContentTask.spawn(browser, null, clickClearReports); + + for (let dir of dirs) { + let entries = dir.directoryEntries; + while (entries.hasMoreElements()) { + let file = entries.getNext().QueryInterface(Ci.nsIFile); + let index = existing.indexOf(file.path); + isnot(index, -1, file.leafName + " exists"); + + if (index != -1) { + existing.splice(index, 1); + } + } + } + + is(existing.length, 0, "All the files that should still exist exist"); + ok(promptShown, "Prompt shown"); + }); +}); diff --git a/toolkit/crashreporter/test/browser/crashreport.sjs b/toolkit/crashreporter/test/browser/crashreport.sjs new file mode 100644 index 000000000..f3bd858eb --- /dev/null +++ b/toolkit/crashreporter/test/browser/crashreport.sjs @@ -0,0 +1,180 @@ +const Cc = Components.classes; +const Ci = Components.interfaces; +const CC = Components.Constructor; + +const BinaryInputStream = CC("@mozilla.org/binaryinputstream;1", + "nsIBinaryInputStream", + "setInputStream"); + +function parseHeaders(data, start) +{ + let headers = {}; + + while (true) { + let done = false; + let end = data.indexOf("\r\n", start); + if (end == -1) { + done = true; + end = data.length; + } + let line = data.substring(start, end); + start = end + 2; + if (line == "") + // empty line, we're done + break; + + //XXX: this doesn't handle multi-line headers. do we care? + let [name, value] = line.split(':'); + //XXX: not normalized, should probably use nsHttpHeaders or something + headers[name] = value.trimLeft(); + } + return [headers, start]; +} + +function parseMultipartForm(request) +{ + let boundary = null; + // See if this is a multipart/form-data request, and if so, find the + // boundary string + if (request.hasHeader("Content-Type")) { + var contenttype = request.getHeader("Content-Type"); + var bits = contenttype.split(";"); + if (bits[0] == "multipart/form-data") { + for (var i = 1; i < bits.length; i++) { + var b = bits[i].trimLeft(); + if (b.indexOf("boundary=") == 0) { + // grab everything after boundary= + boundary = "--" + b.substring(9); + break; + } + } + } + } + if (boundary == null) + return null; + + let body = new BinaryInputStream(request.bodyInputStream); + let avail; + let bytes = []; + while ((avail = body.available()) > 0) { + let readBytes = body.readByteArray(avail); + for (let b of readBytes) { + bytes.push(b); + } + } + let data = ""; + for (let b of bytes) { + data += String.fromCharCode(b); + } + let formData = {}; + let done = false; + let start = 0; + while (true) { + // read first line + let end = data.indexOf("\r\n", start); + if (end == -1) { + done = true; + end = data.length; + } + + let line = data.substring(start, end); + // look for closing boundary delimiter line + if (line == boundary + "--") { + break; + } + + if (line != boundary) { + dump("expected boundary line but didn't find it!"); + break; + } + + // parse headers + start = end + 2; + let headers = null; + [headers, start] = parseHeaders(data, start); + + // find next boundary string + end = data.indexOf("\r\n" + boundary, start); + if (end == -1) { + dump("couldn't find next boundary string\n"); + break; + } + + // read part data, stick in formData using Content-Disposition header + let part = data.substring(start, end); + start = end + 2; + + if ("Content-Disposition" in headers) { + let bits = headers["Content-Disposition"].split(';'); + if (bits[0] == 'form-data') { + for (let i = 0; i < bits.length; i++) { + let b = bits[i].trimLeft(); + if (b.indexOf('name=') == 0) { + //TODO: handle non-ascii here? + let name = b.substring(6, b.length - 1); + //TODO: handle multiple-value properties? + formData[name] = part; + } + //TODO: handle filename= ? + //TODO: handle multipart/mixed for multi-file uploads? + } + } + } + } + return formData; +} + +function handleRequest(request, response) +{ + if (request.method == "GET") { + let id = null; + for (let p of request.queryString.split('&')) { + let [key, value] = p.split('='); + if (key == 'id') + id = value; + } + if (id == null) { + response.setStatusLine(request.httpVersion, 400, "Bad Request"); + response.write("Missing id parameter"); + } + else { + let data = getState(id); + if (data == "") { + response.setStatusLine(request.httpVersion, 404, "Not Found"); + response.write("Not Found"); + } + else { + response.setHeader("Content-Type", "text/plain", false); + response.write(data); + } + } + } + else if (request.method == "POST") { + let formData = parseMultipartForm(request); + + if (formData && 'upload_file_minidump' in formData) { + response.setHeader("Content-Type", "text/plain", false); + + let uuidGenerator = Cc["@mozilla.org/uuid-generator;1"] + .getService(Ci.nsIUUIDGenerator); + let uuid = uuidGenerator.generateUUID().toString(); + // ditch the {}, add bp- prefix + uuid = 'bp-' + uuid.substring(1,uuid.length-2); + + let d = JSON.stringify(formData); + //dump('saving crash report ' + uuid + ': ' + d + '\n'); + setState(uuid, d); + + response.write("CrashID=" + uuid + "\n"); + } + else { + dump('*** crashreport.sjs: Malformed request?\n'); + response.setStatusLine(request.httpVersion, 400, "Bad Request"); + response.write("Missing minidump file"); + } + } + else { + response.setStatusLine(request.httpVersion, 405, "Method not allowed"); + response.write("Can't handle HTTP method " + request.method); + } +} diff --git a/toolkit/crashreporter/test/browser/head.js b/toolkit/crashreporter/test/browser/head.js new file mode 100644 index 000000000..f35edfe38 --- /dev/null +++ b/toolkit/crashreporter/test/browser/head.js @@ -0,0 +1,139 @@ +function create_subdir(dir, subdirname) { + let subdir = dir.clone(); + subdir.append(subdirname); + if (subdir.exists()) { + subdir.remove(true); + } + subdir.create(Ci.nsIFile.DIRECTORY_TYPE, 0o755); + return subdir; +} + +// need to hold on to this to unregister for cleanup +var _provider = null; + +function make_fake_appdir() { + // Create a directory inside the profile and register it as UAppData, so + // we can stick fake crash reports inside there. We put it inside the profile + // just because we know that will get cleaned up after the mochitest run. + let dirSvc = Cc["@mozilla.org/file/directory_service;1"] + .getService(Ci.nsIProperties); + let profD = dirSvc.get("ProfD", Ci.nsILocalFile); + // create a subdir just to keep our files out of the way + let appD = create_subdir(profD, "UAppData"); + + let crashesDir = create_subdir(appD, "Crash Reports"); + create_subdir(crashesDir, "pending"); + create_subdir(crashesDir, "submitted"); + + _provider = { + getFile: function(prop, persistent) { + persistent.value = true; + if (prop == "UAppData") { + return appD.clone(); + } + // Depending on timing we can get requests for other files. + // When we threw an exception here, in the world before bug 997440, this got lost + // because of the arbitrary JSContext being used in XPCWrappedJSClass::CallMethod. + // After bug 997440 this gets reported to our window and causes the tests to fail. + // So, we'll just dump out a message to the logs. + dump("WARNING: make_fake_appdir - fake nsIDirectoryServiceProvider - Unexpected getFile for: '" + prop + "'\n"); + return null; + }, + QueryInterface: function(iid) { + if (iid.equals(Ci.nsIDirectoryServiceProvider) || + iid.equals(Ci.nsISupports)) { + return this; + } + throw Components.results.NS_ERROR_NO_INTERFACE; + } + }; + // register our new provider + dirSvc.QueryInterface(Ci.nsIDirectoryService) + .registerProvider(_provider); + // and undefine the old value + try { + dirSvc.undefine("UAppData"); + } catch (ex) {} // it's ok if this fails, the value might not be cached yet + return appD.clone(); +} + +function cleanup_fake_appdir() { + let dirSvc = Cc["@mozilla.org/file/directory_service;1"] + .getService(Ci.nsIProperties); + dirSvc.QueryInterface(Ci.nsIDirectoryService) + .unregisterProvider(_provider); + // undefine our value so future calls get the real value + try { + dirSvc.undefine("UAppData"); + } catch (ex) { + dump("cleanup_fake_appdir: dirSvc.undefine failed: " + ex.message +"\n"); + } +} + +function add_fake_crashes(crD, count) { + let results = []; + let uuidGenerator = Cc["@mozilla.org/uuid-generator;1"] + .getService(Ci.nsIUUIDGenerator); + let submitdir = crD.clone(); + submitdir.append("submitted"); + // create them from oldest to newest, to ensure that about:crashes + // displays them in the correct order + let date = Date.now() - count * 60000; + for (let i = 0; i < count; i++) { + let uuid = uuidGenerator.generateUUID().toString(); + // ditch the {} + uuid = "bp-" + uuid.substring(1, uuid.length - 2); + let fn = uuid + ".txt"; + let file = submitdir.clone(); + file.append(fn); + file.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o666); + file.lastModifiedTime = date; + results.push({'id': uuid, 'date': date, 'pending': false}); + + date += 60000; + } + // we want them sorted newest to oldest, since that's the order + // that about:crashes lists them in + results.sort((a, b) => b.date - a.date); + return results; +} + +function writeDataToFile(file, data) { + var fstream = Cc["@mozilla.org/network/file-output-stream;1"] + .createInstance(Ci.nsIFileOutputStream); + // open, write, truncate + fstream.init(file, -1, -1, 0); + var os = Cc["@mozilla.org/intl/converter-output-stream;1"] + .createInstance(Ci.nsIConverterOutputStream); + os.init(fstream, "UTF-8", 0, 0x0000); + os.writeString(data); + os.close(); + fstream.close(); +} + +function addPendingCrashreport(crD, date, extra) { + let pendingdir = crD.clone(); + pendingdir.append("pending"); + let uuidGenerator = Cc["@mozilla.org/uuid-generator;1"] + .getService(Ci.nsIUUIDGenerator); + let uuid = uuidGenerator.generateUUID().toString(); + // ditch the {} + uuid = uuid.substring(1, uuid.length - 1); + let dumpfile = pendingdir.clone(); + dumpfile.append(uuid + ".dmp"); + writeDataToFile(dumpfile, "MDMP"); // that's the start of a valid minidump, anyway + let extrafile = pendingdir.clone(); + extrafile.append(uuid + ".extra"); + let extradata = ""; + for (let x in extra) { + extradata += x + "=" + extra[x] + "\n"; + } + writeDataToFile(extrafile, extradata); + let memoryfile = pendingdir.clone(); + memoryfile.append(uuid + ".memory.json.gz"); + writeDataToFile(memoryfile, "Let's pretend this is a memory report"); + dumpfile.lastModifiedTime = date; + extrafile.lastModifiedTime = date; + memoryfile.lastModifiedTime = date; + return {'id': uuid, 'date': date, 'pending': true, 'extra': extra}; +} |