mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

build: enable JS semicolons (#22783)

Browse source
This commit is contained in:
Samuel Attard 2020-03-20 13:28:31 -07:00 • committed by GitHub
parent 24e21467b9
commit 5d657dece4
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
354 changed files with 21512 additions and 21510 deletions
Download patch file Download diff file Expand all files Collapse all files

128
spec-main/api-content-tracing-spec.ts
View file

@ -1,76 +1,76 @@
import { expect } from 'chai'
import { app, contentTracing, TraceConfig, TraceCategoriesAndOptions } from 'electron'
import * as fs from 'fs'
import * as path from 'path'
import { ifdescribe } from './spec-helpers'
import { expect } from 'chai';
import { app, contentTracing, TraceConfig, TraceCategoriesAndOptions } from 'electron';
import * as fs from 'fs';
import * as path from 'path';
import { ifdescribe } from './spec-helpers';
const timeout = async (milliseconds: number) => {
return new Promise((resolve) => {
setTimeout(resolve, milliseconds)
})
}
setTimeout(resolve, milliseconds);
});
};
// FIXME: The tests are skipped on arm/arm64.
ifdescribe(!(process.platform === 'linux' && ['arm', 'arm64'].includes(process.arch)))('contentTracing', () => {
const record = async (options: TraceConfig | TraceCategoriesAndOptions, outputFilePath: string | undefined, recordTimeInMilliseconds = 1e1) => {
await app.whenReady()
await app.whenReady();
await contentTracing.startRecording(options)
await timeout(recordTimeInMilliseconds)
const resultFilePath = await contentTracing.stopRecording(outputFilePath)
await contentTracing.startRecording(options);
await timeout(recordTimeInMilliseconds);
const resultFilePath = await contentTracing.stopRecording(outputFilePath);
return resultFilePath
}
return resultFilePath;
};
const outputFilePath = path.join(app.getPath('temp'), 'trace.json')
const outputFilePath = path.join(app.getPath('temp'), 'trace.json');
beforeEach(() => {
if (fs.existsSync(outputFilePath)) {
fs.unlinkSync(outputFilePath)
fs.unlinkSync(outputFilePath);
}
})
});
describe('startRecording', function () {
this.timeout(5e3)
this.timeout(5e3);
const getFileSizeInKiloBytes = (filePath: string) => {
const stats = fs.statSync(filePath)
const fileSizeInBytes = stats.size
const fileSizeInKiloBytes = fileSizeInBytes / 1024
return fileSizeInKiloBytes
}
const stats = fs.statSync(filePath);
const fileSizeInBytes = stats.size;
const fileSizeInKiloBytes = fileSizeInBytes / 1024;
return fileSizeInKiloBytes;
};
it('accepts an empty config', async () => {
const config = {}
await record(config, outputFilePath)
const config = {};
await record(config, outputFilePath);
expect(fs.existsSync(outputFilePath)).to.be.true('output exists')
expect(fs.existsSync(outputFilePath)).to.be.true('output exists');
const fileSizeInKiloBytes = getFileSizeInKiloBytes(outputFilePath)
const fileSizeInKiloBytes = getFileSizeInKiloBytes(outputFilePath);
expect(fileSizeInKiloBytes).to.be.above(0,
`the trace output file is empty, check "${outputFilePath}"`)
})
`the trace output file is empty, check "${outputFilePath}"`);
});
it('accepts a trace config', async () => {
// (alexeykuzmin): All categories are excluded on purpose,
// so only metadata gets into the output file.
const config = {
excluded_categories: ['*']
}
await record(config, outputFilePath)
};
await record(config, outputFilePath);
expect(fs.existsSync(outputFilePath)).to.be.true('output exists')
expect(fs.existsSync(outputFilePath)).to.be.true('output exists');
// If the `excluded_categories` param above is not respected
// the file size will be above 50KB.
const fileSizeInKiloBytes = getFileSizeInKiloBytes(outputFilePath)
const expectedMaximumFileSize = 10 // Depends on a platform.
const fileSizeInKiloBytes = getFileSizeInKiloBytes(outputFilePath);
const expectedMaximumFileSize = 10; // Depends on a platform.
expect(fileSizeInKiloBytes).to.be.above(0,
`the trace output file is empty, check "${outputFilePath}"`)
`the trace output file is empty, check "${outputFilePath}"`);
expect(fileSizeInKiloBytes).to.be.below(expectedMaximumFileSize,
`the trace output file is suspiciously large (${fileSizeInKiloBytes}KB),
check "${outputFilePath}"`)
})
check "${outputFilePath}"`);
});
it('accepts "categoryFilter" and "traceOptions" as a config', async () => {
// (alexeykuzmin): All categories are excluded on purpose,
@ -78,52 +78,52 @@ ifdescribe(!(process.platform === 'linux' && ['arm', 'arm64'].includes(process.a
const config = {
categoryFilter: '__ThisIsANonexistentCategory__',
traceOptions: ''
}
await record(config, outputFilePath)
};
await record(config, outputFilePath);
expect(fs.existsSync(outputFilePath)).to.be.true('output exists')
expect(fs.existsSync(outputFilePath)).to.be.true('output exists');
// If the `categoryFilter` param above is not respected
// the file size will be above 50KB.
const fileSizeInKiloBytes = getFileSizeInKiloBytes(outputFilePath)
const expectedMaximumFileSize = 10 // Depends on a platform.
const fileSizeInKiloBytes = getFileSizeInKiloBytes(outputFilePath);
const expectedMaximumFileSize = 10; // Depends on a platform.
expect(fileSizeInKiloBytes).to.be.above(0,
`the trace output file is empty, check "${outputFilePath}"`)
`the trace output file is empty, check "${outputFilePath}"`);
expect(fileSizeInKiloBytes).to.be.below(expectedMaximumFileSize,
`the trace output file is suspiciously large (${fileSizeInKiloBytes}KB),
check "${outputFilePath}"`)
})
})
check "${outputFilePath}"`);
});
});
describe('stopRecording', function () {
this.timeout(5e3)
this.timeout(5e3);
it('does not crash on empty string', async () => {
const options = {
categoryFilter: '*',
traceOptions: 'record-until-full,enable-sampling'
}
};
await contentTracing.startRecording(options)
const path = await contentTracing.stopRecording('')
expect(path).to.be.a('string').that.is.not.empty('result path')
expect(fs.statSync(path).isFile()).to.be.true('output exists')
})
await contentTracing.startRecording(options);
const path = await contentTracing.stopRecording('');
expect(path).to.be.a('string').that.is.not.empty('result path');
expect(fs.statSync(path).isFile()).to.be.true('output exists');
});
it('calls its callback with a result file path', async () => {
const resultFilePath = await record(/* options */ {}, outputFilePath)
expect(resultFilePath).to.be.a('string').and.be.equal(outputFilePath)
})
const resultFilePath = await record(/* options */ {}, outputFilePath);
expect(resultFilePath).to.be.a('string').and.be.equal(outputFilePath);
});
it('creates a temporary file when an empty string is passed', async function () {
const resultFilePath = await record(/* options */ {}, /* outputFilePath */ '')
expect(resultFilePath).to.be.a('string').that.is.not.empty('result path')
})
const resultFilePath = await record(/* options */ {}, /* outputFilePath */ '');
expect(resultFilePath).to.be.a('string').that.is.not.empty('result path');
});
it('creates a temporary file when no path is passed', async function () {
const resultFilePath = await record(/* options */ {}, /* outputFilePath */ undefined)
expect(resultFilePath).to.be.a('string').that.is.not.empty('result path')
})
})
})
const resultFilePath = await record(/* options */ {}, /* outputFilePath */ undefined);
expect(resultFilePath).to.be.a('string').that.is.not.empty('result path');
});
});
});