electron/spec/api-crash-reporter-spec.js

499 lines
16 KiB
JavaScript
Raw Normal View History

2016-03-25 20:03:49 +00:00
const assert = require('assert')
2017-01-24 21:49:45 +00:00
const childProcess = require('child_process')
2018-09-13 16:10:51 +00:00
const { expect } = require('chai')
2017-03-30 14:11:49 +00:00
const fs = require('fs')
2016-03-25 20:03:49 +00:00
const http = require('http')
const multiparty = require('multiparty')
const path = require('path')
const temp = require('temp').track()
2016-03-25 20:03:49 +00:00
const url = require('url')
2018-09-13 16:10:51 +00:00
const { closeWindow } = require('./window-helpers')
2016-01-12 02:40:23 +00:00
2018-09-13 16:10:51 +00:00
const { remote } = require('electron')
const { app, BrowserWindow, crashReporter } = remote
2016-01-12 02:40:23 +00:00
2017-11-02 02:23:33 +00:00
describe('crashReporter module', () => {
2017-10-27 00:21:36 +00:00
if (process.mas || process.env.DISABLE_CRASH_REPORTER_TESTS) return
2018-06-12 16:40:15 +00:00
// TODO(alexeykuzmin): [Ch66] Fails. Fix it and enable back.
if (process.platform === 'linux') return
2017-10-27 00:21:36 +00:00
let originalTempDirectory = null
let tempDirectory = null
2017-10-27 00:21:36 +00:00
before(() => {
tempDirectory = temp.mkdirSync('electronCrashReporterSpec-')
originalTempDirectory = app.getPath('temp')
app.setPath('temp', tempDirectory)
})
2017-10-27 00:21:36 +00:00
after(() => {
app.setPath('temp', originalTempDirectory)
})
2017-10-27 00:21:36 +00:00
const fixtures = path.resolve(__dirname, 'fixtures')
const generateSpecs = (description, browserWindowOpts) => {
2017-10-27 00:21:36 +00:00
describe(description, () => {
let w = null
let stopServer = null
2017-10-27 00:21:36 +00:00
beforeEach(() => {
stopServer = null
2017-10-31 02:51:22 +00:00
w = new BrowserWindow(Object.assign({ show: false }, browserWindowOpts))
})
2017-10-27 00:21:36 +00:00
afterEach(() => closeWindow(w).then(() => { w = null }))
2017-10-27 00:21:36 +00:00
afterEach(() => {
2017-04-19 23:32:43 +00:00
stopCrashService()
})
2017-10-27 00:21:36 +00:00
afterEach((done) => {
if (stopServer != null) {
stopServer(done)
} else {
done()
}
})
it('should send minidump when renderer crashes', function (done) {
// TODO(alexeykuzmin): Skip the test instead of marking it as passed.
if (process.env.APPVEYOR === 'True') return done()
this.timeout(180000)
stopServer = startServer({
callback (port) {
2018-09-13 16:10:51 +00:00
w.loadFile(path.join(fixtures, 'api', 'crash.html'), { query: { port } })
},
processType: 'renderer',
done: done
2016-08-09 22:41:46 +00:00
})
})
2018-06-18 09:00:59 +00:00
it('should send minidump when node processes crash', function (done) {
// TODO(alexeykuzmin): Skip the test instead of marking it as passed.
if (process.env.APPVEYOR === 'True') return done()
this.timeout(180000)
stopServer = startServer({
callback (port) {
const crashesDir = path.join(app.getPath('temp'), `${process.platform === 'win32' ? 'Zombies' : app.name} Crashes`)
const version = app.getVersion()
const crashPath = path.join(fixtures, 'module', 'crash.js')
2017-04-19 23:32:43 +00:00
if (process.platform === 'win32') {
const crashServiceProcess = childProcess.spawn(process.execPath, [
`--reporter-url=http://127.0.0.1:${port}`,
'--application-name=Zombies',
`--crashes-directory=${crashesDir}`
], {
2017-04-19 23:44:31 +00:00
env: {
ELECTRON_INTERNAL_CRASH_SERVICE: 1
},
detached: true
2017-04-19 23:32:43 +00:00
})
remote.process.crashServicePid = crashServiceProcess.pid
}
2018-09-13 16:10:51 +00:00
childProcess.fork(crashPath, [port, version, crashesDir], { silent: true })
},
processType: 'browser',
done: done
})
})
it('should not send minidump if uploadToServer is false', function (done) {
this.timeout(180000)
2017-03-30 14:11:49 +00:00
let dumpFile
let crashesDir = crashReporter.getCrashesDirectory()
const existingDumpFiles = new Set()
2017-03-30 14:11:49 +00:00
if (process.platform === 'darwin') {
// crashpad puts the dump files in the "completed" subdirectory
crashesDir = path.join(crashesDir, 'completed')
2017-03-30 14:11:49 +00:00
crashReporter.setUploadToServer(false)
}
const testDone = (uploaded) => {
2017-10-27 00:21:36 +00:00
if (uploaded) return done(new Error('Uploaded crash report'))
if (process.platform === 'darwin') crashReporter.setUploadToServer(true)
2017-03-30 14:11:49 +00:00
assert(fs.existsSync(dumpFile))
done()
}
let pollInterval
const pollDumpFile = () => {
fs.readdir(crashesDir, (err, files) => {
2017-10-27 00:21:36 +00:00
if (err) return
const dumps = files.filter((file) => /\.dmp$/.test(file) && !existingDumpFiles.has(file))
2017-10-27 00:21:36 +00:00
if (!dumps.length) return
2018-09-13 16:10:51 +00:00
assert.strictEqual(1, dumps.length)
2017-03-30 14:11:49 +00:00
dumpFile = path.join(crashesDir, dumps[0])
clearInterval(pollInterval)
// dump file should not be deleted when not uploading, so we wait
// 1s and assert it still exists in `testDone`
setTimeout(testDone, 1000)
2017-03-30 14:11:49 +00:00
})
}
remote.ipcMain.once('list-existing-dumps', (event) => {
2017-03-30 14:11:49 +00:00
fs.readdir(crashesDir, (err, files) => {
if (!err) {
2017-03-31 17:42:43 +00:00
for (const file of files) {
2017-03-30 14:11:49 +00:00
if (/\.dmp$/.test(file)) {
existingDumpFiles.add(file)
2017-03-30 14:11:49 +00:00
}
}
}
2018-09-13 16:10:51 +00:00
event.returnValue = null // allow the renderer to crash
2017-03-30 14:11:49 +00:00
pollInterval = setInterval(pollDumpFile, 100)
})
})
stopServer = startServer({
2017-03-30 14:11:49 +00:00
callback (port) {
const crashUrl = url.format({
protocol: 'file',
pathname: path.join(fixtures, 'api', 'crash.html'),
search: `?port=${port}&skipUpload=1`
})
w.loadURL(crashUrl)
},
processType: 'renderer',
done: testDone.bind(null, true)
})
})
it('should send minidump with updated extra parameters', function (done) {
// TODO(alexeykuzmin): Skip the test instead of marking it as passed.
if (process.env.APPVEYOR === 'True') return done()
this.timeout(180000)
stopServer = startServer({
callback (port) {
const crashUrl = url.format({
protocol: 'file',
pathname: path.join(fixtures, 'api', 'crash-restart.html'),
search: `?port=${port}`
})
w.loadURL(crashUrl)
},
processType: 'renderer',
done: done
2017-02-13 18:46:19 +00:00
})
})
2017-02-13 18:46:19 +00:00
})
}
generateSpecs('without sandbox', {
webPreferences: {
nodeIntegration: true
}
})
2017-04-19 16:28:52 +00:00
generateSpecs('with sandbox', {
webPreferences: {
sandbox: true,
preload: path.join(fixtures, 'module', 'preload-sandbox.js')
}
})
generateSpecs('with remote module disabled', {
webPreferences: {
nodeIntegration: true,
enableRemoteModule: false
}
})
2017-02-13 18:46:19 +00:00
2017-10-31 02:51:22 +00:00
describe('getProductName', () => {
it('returns the product name if one is specified', () => {
const name = crashReporter.getProductName()
const expectedName = (process.platform === 'darwin') ? 'Electron Test' : 'Zombies'
2018-09-13 16:10:51 +00:00
assert.strictEqual(name, expectedName)
2017-10-31 02:51:22 +00:00
})
})
describe('start(options)', () => {
2017-10-27 00:21:36 +00:00
it('requires that the companyName and submitURL options be specified', () => {
assert.throws(() => {
2018-09-13 16:10:51 +00:00
crashReporter.start({ companyName: 'Missing submitURL' })
}, /submitURL is a required option to crashReporter\.start/)
2017-10-27 00:21:36 +00:00
assert.throws(() => {
2018-09-13 16:10:51 +00:00
crashReporter.start({ submitURL: 'Missing companyName' })
}, /companyName is a required option to crashReporter\.start/)
2016-03-25 20:03:49 +00:00
})
2017-10-27 00:21:36 +00:00
it('can be called multiple times', () => {
assert.doesNotThrow(() => {
crashReporter.start({
companyName: 'Umbrella Corporation',
submitURL: 'http://127.0.0.1/crashes'
})
crashReporter.start({
companyName: 'Umbrella Corporation 2',
submitURL: 'http://127.0.0.1/more-crashes'
})
})
})
2016-03-25 20:03:49 +00:00
})
2017-10-31 03:15:57 +00:00
2017-10-31 02:51:22 +00:00
describe('getCrashesDirectory', () => {
it('correctly returns the directory', () => {
const crashesDir = crashReporter.getCrashesDirectory()
2017-10-31 03:15:57 +00:00
let dir
if (process.platform === 'win32') {
dir = `${app.getPath('temp')}/Zombies Crashes`
} else {
dir = `${app.getPath('temp')}/Electron Test Crashes`
}
2018-09-13 16:10:51 +00:00
assert.strictEqual(crashesDir, dir)
2017-10-31 02:51:22 +00:00
})
})
describe('getUploadedReports', () => {
it('returns an array of reports', () => {
const reports = crashReporter.getUploadedReports()
assert(typeof reports === 'object')
})
})
2016-11-28 23:01:38 +00:00
// TODO(alexeykuzmin): This suite should explicitly
// generate several crash reports instead of hoping
// that there will be enough of them already.
2017-10-31 02:51:22 +00:00
describe('getLastCrashReport', () => {
it('correctly returns the most recent report', () => {
2017-11-30 20:39:32 +00:00
const reports = crashReporter.getUploadedReports()
expect(reports).to.be.an('array')
expect(reports).to.have.lengthOf.at.least(2,
2018-09-13 16:10:51 +00:00
'There are not enough reports for this test')
2018-03-13 23:51:20 +00:00
const lastReport = crashReporter.getLastCrashReport()
expect(lastReport).to.be.an('object').that.includes.a.key('date')
2018-03-13 23:51:20 +00:00
// Let's find the newest report.
2018-09-13 16:10:51 +00:00
const { report: newestReport } = reports.reduce((acc, cur) => {
2018-03-14 00:40:41 +00:00
const timestamp = new Date(cur.date).getTime()
2018-03-14 00:28:15 +00:00
return (timestamp > acc.timestamp)
? { report: cur, timestamp: timestamp }
: acc
}, { timestamp: -Infinity })
assert(newestReport, 'Hey!')
2018-03-14 00:28:15 +00:00
expect(lastReport.date.getTime()).to.be.equal(
2018-09-13 16:10:51 +00:00
newestReport.date.getTime(),
'Last report is not the newest.')
2017-10-31 02:51:22 +00:00
})
})
describe('getUploadToServer()', () => {
2017-10-27 00:21:36 +00:00
it('throws an error when called from the renderer process', () => {
2016-11-28 23:01:38 +00:00
assert.throws(() => require('electron').crashReporter.getUploadToServer())
})
it('returns true when uploadToServer is set to true', function () {
if (process.platform !== 'darwin') {
// FIXME(alexeykuzmin): Skip the test.
// this.skip()
return
2017-10-31 02:51:22 +00:00
}
crashReporter.start({
companyName: 'Umbrella Corporation',
submitURL: 'http://127.0.0.1/crashes',
uploadToServer: true
})
2018-09-13 16:10:51 +00:00
assert.strictEqual(crashReporter.getUploadToServer(), true)
2017-10-31 02:51:22 +00:00
})
it('returns false when uploadToServer is set to false', function () {
if (process.platform !== 'darwin') {
// FIXME(alexeykuzmin): Skip the test.
// this.skip()
return
2017-10-31 02:51:22 +00:00
}
crashReporter.start({
companyName: 'Umbrella Corporation',
submitURL: 'http://127.0.0.1/crashes',
uploadToServer: true
})
crashReporter.setUploadToServer(false)
2018-09-13 16:10:51 +00:00
assert.strictEqual(crashReporter.getUploadToServer(), false)
2017-10-31 02:51:22 +00:00
})
})
describe('setUploadToServer(uploadToServer)', () => {
it('throws an error when called from the renderer process', () => {
assert.throws(() => require('electron').crashReporter.setUploadToServer('arg'))
})
it('sets uploadToServer false when called with false', function () {
if (process.platform !== 'darwin') {
// FIXME(alexeykuzmin): Skip the test.
// this.skip()
return
2017-10-31 02:51:22 +00:00
}
crashReporter.start({
companyName: 'Umbrella Corporation',
submitURL: 'http://127.0.0.1/crashes',
uploadToServer: true
})
crashReporter.setUploadToServer(false)
2018-09-13 16:10:51 +00:00
assert.strictEqual(crashReporter.getUploadToServer(), false)
2017-10-31 02:51:22 +00:00
})
it('sets uploadToServer true when called with true', function () {
if (process.platform !== 'darwin') {
// FIXME(alexeykuzmin): Skip the test.
// this.skip()
return
2016-11-28 23:01:38 +00:00
}
crashReporter.start({
companyName: 'Umbrella Corporation',
submitURL: 'http://127.0.0.1/crashes',
uploadToServer: false
})
crashReporter.setUploadToServer(true)
2018-09-13 16:10:51 +00:00
assert.strictEqual(crashReporter.getUploadToServer(), true)
2016-11-28 23:01:38 +00:00
})
})
2017-10-31 02:51:22 +00:00
describe('Parameters', () => {
2017-10-31 14:38:48 +00:00
it('returns all of the current parameters', () => {
2017-10-31 17:51:44 +00:00
crashReporter.start({
companyName: 'Umbrella Corporation',
submitURL: 'http://127.0.0.1/crashes'
})
2017-10-31 14:38:48 +00:00
const parameters = crashReporter.getParameters()
2017-10-31 17:51:44 +00:00
assert(typeof parameters === 'object')
2017-10-31 14:38:48 +00:00
})
it('adds a parameter to current parameters', function () {
if (process.platform !== 'darwin') {
// FIXME(alexeykuzmin): Skip the test.
// this.skip()
return
}
crashReporter.start({
companyName: 'Umbrella Corporation',
submitURL: 'http://127.0.0.1/crashes'
})
crashReporter.addExtraParameter('hello', 'world')
assert('hello' in crashReporter.getParameters())
})
it('removes a parameter from current parameters', function () {
if (process.platform !== 'darwin') {
// FIXME(alexeykuzmin): Skip the test.
// this.skip()
return
}
2017-10-31 14:38:48 +00:00
2017-10-31 17:51:44 +00:00
crashReporter.start({
companyName: 'Umbrella Corporation',
submitURL: 'http://127.0.0.1/crashes'
})
crashReporter.addExtraParameter('hello', 'world')
assert('hello' in crashReporter.getParameters())
2017-10-31 14:38:48 +00:00
crashReporter.removeExtraParameter('hello')
assert(!('hello' in crashReporter.getParameters()))
2017-10-31 14:38:48 +00:00
})
2017-10-31 02:51:22 +00:00
})
2016-03-25 20:03:49 +00:00
})
const waitForCrashReport = () => {
return new Promise((resolve, reject) => {
let times = 0
const checkForReport = () => {
if (crashReporter.getLastCrashReport() != null) {
resolve()
} else if (times >= 10) {
reject(new Error('No crash report available'))
} else {
times++
setTimeout(checkForReport, 100)
}
}
checkForReport()
})
}
2017-01-24 21:49:45 +00:00
2018-09-13 16:10:51 +00:00
const startServer = ({ callback, processType, done }) => {
2017-10-27 00:21:36 +00:00
let called = false
const server = http.createServer((req, res) => {
2017-10-27 00:21:36 +00:00
const form = new multiparty.Form()
2017-01-24 21:49:45 +00:00
form.parse(req, (error, fields) => {
if (error) throw error
if (called) return
called = true
assert.deepStrictEqual(String(fields.prod), 'Electron')
assert.strictEqual(String(fields.ver), process.versions.electron)
assert.strictEqual(String(fields.process_type), processType)
assert.strictEqual(String(fields.platform), process.platform)
assert.strictEqual(String(fields.extra1), 'extra1')
assert.strictEqual(String(fields.extra2), 'extra2')
2018-09-13 16:10:51 +00:00
assert.strictEqual(fields.extra3, undefined)
assert.strictEqual(String(fields._productName), 'Zombies')
assert.strictEqual(String(fields._companyName), 'Umbrella Corporation')
assert.strictEqual(String(fields._version), app.getVersion())
2017-01-24 21:49:45 +00:00
const reportId = 'abc-123-def-456-abc-789-abc-123-abcd'
res.end(reportId, () => {
waitForCrashReport().then(() => {
2018-09-13 16:10:51 +00:00
assert.strictEqual(crashReporter.getLastCrashReport().id, reportId)
assert.notStrictEqual(crashReporter.getUploadedReports().length, 0)
assert.strictEqual(crashReporter.getUploadedReports()[0].id, reportId)
2017-02-13 18:46:19 +00:00
req.socket.destroy()
2017-01-24 21:49:45 +00:00
done()
}, done)
})
})
})
const activeConnections = new Set()
server.on('connection', (connection) => {
activeConnections.add(connection)
connection.once('close', () => {
activeConnections.delete(connection)
})
})
2018-09-13 16:10:51 +00:00
let { port } = remote.process
2017-01-24 21:49:45 +00:00
server.listen(port, '127.0.0.1', () => {
port = server.address().port
remote.process.port = port
if (process.platform === 'darwin') {
crashReporter.start({
companyName: 'Umbrella Corporation',
submitURL: 'http://127.0.0.1:' + port
})
}
callback(port)
})
return function stopServer (done) {
for (const connection of activeConnections) {
connection.destroy()
}
2017-10-27 00:21:36 +00:00
server.close(() => {
done()
})
}
2017-01-24 21:49:45 +00:00
}
2017-04-19 23:32:43 +00:00
const stopCrashService = () => {
2018-09-13 16:10:51 +00:00
const { crashServicePid } = remote.process
2017-04-19 23:32:43 +00:00
if (crashServicePid) {
remote.process.crashServicePid = 0
try {
process.kill(crashServicePid)
} catch (error) {
if (error.code !== 'ESRCH') {
throw error
}
}
}
}