electron/spec/api-web-request-spec.ts

568 lines
20 KiB
TypeScript
Raw Normal View History

2020-03-20 20:28:31 +00:00
import { expect } from 'chai';
import * as http from 'http';
import * as qs from 'querystring';
import * as path from 'path';
import * as url from 'url';
2020-03-20 20:28:31 +00:00
import * as WebSocket from 'ws';
import { ipcMain, protocol, session, WebContents, webContents } from 'electron/main';
import { Socket } from 'net';
import { listen } from './lib/spec-helpers';
import { once } from 'events';
2020-03-20 20:28:31 +00:00
const fixturesPath = path.resolve(__dirname, 'fixtures');
2017-11-23 22:22:43 +00:00
describe('webRequest module', () => {
2020-03-20 20:28:31 +00:00
const ses = session.defaultSession;
const server = http.createServer((req, res) => {
2016-06-29 16:37:10 +00:00
if (req.url === '/serverRedirect') {
2020-03-20 20:28:31 +00:00
res.statusCode = 301;
res.setHeader('Location', 'http://' + req.rawHeaders[1]);
res.end();
} else if (req.url === '/contentDisposition') {
res.setHeader('content-disposition', [' attachment; filename=aa%E4%B8%ADaa.txt']);
const content = req.url;
res.end(content);
} else {
2020-03-20 20:28:31 +00:00
res.setHeader('Custom', ['Header']);
let content = req.url;
if (req.headers.accept === '*/*;test/header') {
2020-03-20 20:28:31 +00:00
content += 'header/received';
}
if (req.headers.origin === 'http://new-origin') {
2020-03-20 20:28:31 +00:00
content += 'new/origin';
}
2020-03-20 20:28:31 +00:00
res.end(content);
2016-01-12 02:40:23 +00:00
}
2020-03-20 20:28:31 +00:00
});
let defaultURL: string;
before(async () => {
protocol.registerStringProtocol('cors', (req, cb) => cb(''));
defaultURL = (await listen(server)).url + '/';
2020-03-20 20:28:31 +00:00
});
after(() => {
2020-03-20 20:28:31 +00:00
server.close();
protocol.unregisterProtocol('cors');
2020-03-20 20:28:31 +00:00
});
let contents: WebContents;
// NB. sandbox: true is used because it makes navigations much (~8x) faster.
before(async () => {
contents = (webContents as typeof ElectronInternal.WebContents).create({ sandbox: true });
await contents.loadFile(path.join(fixturesPath, 'pages', 'fetch.html'));
2020-03-20 20:28:31 +00:00
});
after(() => contents.destroy());
async function ajax (url: string, options = {}) {
2020-03-20 20:28:31 +00:00
return contents.executeJavaScript(`ajax("${url}", ${JSON.stringify(options)})`);
}
describe('webRequest.onBeforeRequest', () => {
afterEach(() => {
2020-03-20 20:28:31 +00:00
ses.webRequest.onBeforeRequest(null);
});
const cancel = (details: Electron.OnBeforeRequestListenerDetails, callback: (response: Electron.CallbackResponse) => void) => {
callback({ cancel: true });
};
it('can cancel the request', async () => {
ses.webRequest.onBeforeRequest(cancel);
await expect(ajax(defaultURL)).to.eventually.be.rejected();
2020-03-20 20:28:31 +00:00
});
it('can filter URLs', async () => {
2020-03-20 20:28:31 +00:00
const filter = { urls: [defaultURL + 'filter/*'] };
ses.webRequest.onBeforeRequest(filter, cancel);
const { data } = await ajax(`${defaultURL}nofilter/test`);
expect(data).to.equal('/nofilter/test');
await expect(ajax(`${defaultURL}filter/test`)).to.eventually.be.rejected();
});
it('can filter URLs and types', async () => {
const filter1: Electron.WebRequestFilter = { urls: [defaultURL + 'filter/*'], types: ['xhr'] };
ses.webRequest.onBeforeRequest(filter1, cancel);
2020-03-20 20:28:31 +00:00
const { data } = await ajax(`${defaultURL}nofilter/test`);
expect(data).to.equal('/nofilter/test');
await expect(ajax(`${defaultURL}filter/test`)).to.eventually.be.rejected();
const filter2: Electron.WebRequestFilter = { urls: [defaultURL + 'filter/*'], types: ['stylesheet'] };
ses.webRequest.onBeforeRequest(filter2, cancel);
expect((await ajax(`${defaultURL}nofilter/test`)).data).to.equal('/nofilter/test');
expect((await ajax(`${defaultURL}filter/test`)).data).to.equal('/filter/test');
2020-03-20 20:28:31 +00:00
});
it('receives details object', async () => {
ses.webRequest.onBeforeRequest((details, callback) => {
2020-03-20 20:28:31 +00:00
expect(details.id).to.be.a('number');
expect(details.timestamp).to.be.a('number');
expect(details.webContentsId).to.be.a('number');
expect(details.webContents).to.be.an('object');
expect(details.webContents!.id).to.equal(details.webContentsId);
expect(details.frame).to.be.an('object');
2020-03-20 20:28:31 +00:00
expect(details.url).to.be.a('string').that.is.equal(defaultURL);
expect(details.method).to.be.a('string').that.is.equal('GET');
expect(details.resourceType).to.be.a('string').that.is.equal('xhr');
expect(details.uploadData).to.be.undefined();
callback({});
});
const { data } = await ajax(defaultURL);
expect(data).to.equal('/');
});
it('receives post data in details object', async () => {
const postData = {
name: 'post test',
type: 'string'
2020-03-20 20:28:31 +00:00
};
ses.webRequest.onBeforeRequest((details, callback) => {
2020-03-20 20:28:31 +00:00
expect(details.url).to.equal(defaultURL);
expect(details.method).to.equal('POST');
expect(details.uploadData).to.have.lengthOf(1);
const data = qs.parse(details.uploadData[0].bytes.toString());
expect(data).to.deep.equal(postData);
callback({ cancel: true });
});
await expect(ajax(defaultURL, {
method: 'POST',
body: qs.stringify(postData)
})).to.eventually.be.rejected();
2020-03-20 20:28:31 +00:00
});
it('can redirect the request', async () => {
ses.webRequest.onBeforeRequest((details, callback) => {
2016-01-12 02:40:23 +00:00
if (details.url === defaultURL) {
2020-03-20 20:28:31 +00:00
callback({ redirectURL: `${defaultURL}redirect` });
2016-01-12 02:40:23 +00:00
} else {
2020-03-20 20:28:31 +00:00
callback({});
2016-01-12 02:40:23 +00:00
}
2020-03-20 20:28:31 +00:00
});
const { data } = await ajax(defaultURL);
expect(data).to.equal('/redirect');
});
it('does not crash for redirects', async () => {
ses.webRequest.onBeforeRequest((details, callback) => {
2020-03-20 20:28:31 +00:00
callback({ cancel: false });
});
await ajax(defaultURL + 'serverRedirect');
await ajax(defaultURL + 'serverRedirect');
});
it('works with file:// protocol', async () => {
ses.webRequest.onBeforeRequest((details, callback) => {
callback({ cancel: true });
});
const fileURL = url.format({
pathname: path.join(fixturesPath, 'blank.html').replace(/\\/g, '/'),
protocol: 'file',
slashes: true
});
await expect(ajax(fileURL)).to.eventually.be.rejected();
});
2020-03-20 20:28:31 +00:00
});
describe('webRequest.onBeforeSendHeaders', () => {
afterEach(() => {
2020-03-20 20:28:31 +00:00
ses.webRequest.onBeforeSendHeaders(null);
ses.webRequest.onSendHeaders(null);
2020-03-20 20:28:31 +00:00
});
it('receives details object', async () => {
ses.webRequest.onBeforeSendHeaders((details, callback) => {
2020-03-20 20:28:31 +00:00
expect(details.requestHeaders).to.be.an('object');
expect(details.requestHeaders['Foo.Bar']).to.equal('baz');
callback({});
});
const { data } = await ajax(defaultURL, { headers: { 'Foo.Bar': 'baz' } });
expect(data).to.equal('/');
});
it('can change the request headers', async () => {
ses.webRequest.onBeforeSendHeaders((details, callback) => {
2020-03-20 20:28:31 +00:00
const requestHeaders = details.requestHeaders;
requestHeaders.Accept = '*/*;test/header';
callback({ requestHeaders: requestHeaders });
});
const { data } = await ajax(defaultURL);
expect(data).to.equal('/header/received');
});
it('can change the request headers on a custom protocol redirect', async () => {
protocol.registerStringProtocol('no-cors', (req, callback) => {
if (req.url === 'no-cors://fake-host/redirect') {
callback({
statusCode: 302,
headers: {
Location: 'no-cors://fake-host'
}
});
} else {
let content = '';
if (req.headers.Accept === '*/*;test/header') {
content = 'header-received';
}
callback(content);
}
});
// Note that we need to do navigation every time after a protocol is
// registered or unregistered, otherwise the new protocol won't be
// recognized by current page when NetworkService is used.
await contents.loadFile(path.join(__dirname, 'fixtures', 'pages', 'fetch.html'));
try {
ses.webRequest.onBeforeSendHeaders((details, callback) => {
const requestHeaders = details.requestHeaders;
requestHeaders.Accept = '*/*;test/header';
callback({ requestHeaders: requestHeaders });
});
const { data } = await ajax('no-cors://fake-host/redirect');
expect(data).to.equal('header-received');
} finally {
protocol.unregisterProtocol('no-cors');
}
});
it('can change request origin', async () => {
ses.webRequest.onBeforeSendHeaders((details, callback) => {
2020-03-20 20:28:31 +00:00
const requestHeaders = details.requestHeaders;
requestHeaders.Origin = 'http://new-origin';
callback({ requestHeaders: requestHeaders });
});
const { data } = await ajax(defaultURL);
expect(data).to.equal('/new/origin');
});
it('can capture CORS requests', async () => {
2020-03-20 20:28:31 +00:00
let called = false;
ses.webRequest.onBeforeSendHeaders((details, callback) => {
2020-03-20 20:28:31 +00:00
called = true;
callback({ requestHeaders: details.requestHeaders });
});
await ajax('cors://host');
2020-03-20 20:28:31 +00:00
expect(called).to.be.true();
});
it('resets the whole headers', async () => {
const requestHeaders = {
2016-01-12 02:40:23 +00:00
Test: 'header'
2020-03-20 20:28:31 +00:00
};
ses.webRequest.onBeforeSendHeaders((details, callback) => {
2020-03-20 20:28:31 +00:00
callback({ requestHeaders: requestHeaders });
});
ses.webRequest.onSendHeaders((details) => {
2020-03-20 20:28:31 +00:00
expect(details.requestHeaders).to.deep.equal(requestHeaders);
});
await ajax(defaultURL);
});
it('leaves headers unchanged when no requestHeaders in callback', async () => {
let originalRequestHeaders: Record<string, string>;
ses.webRequest.onBeforeSendHeaders((details, callback) => {
originalRequestHeaders = details.requestHeaders;
callback({});
});
ses.webRequest.onSendHeaders((details) => {
expect(details.requestHeaders).to.deep.equal(originalRequestHeaders);
});
2020-03-20 20:28:31 +00:00
await ajax(defaultURL);
});
it('works with file:// protocol', async () => {
const requestHeaders = {
Test: 'header'
};
let onSendHeadersCalled = false;
ses.webRequest.onBeforeSendHeaders((details, callback) => {
callback({ requestHeaders: requestHeaders });
});
ses.webRequest.onSendHeaders((details) => {
expect(details.requestHeaders).to.deep.equal(requestHeaders);
onSendHeadersCalled = true;
});
await ajax(url.format({
pathname: path.join(fixturesPath, 'blank.html').replace(/\\/g, '/'),
protocol: 'file',
slashes: true
}));
expect(onSendHeadersCalled).to.be.true();
});
2020-03-20 20:28:31 +00:00
});
describe('webRequest.onSendHeaders', () => {
afterEach(() => {
2020-03-20 20:28:31 +00:00
ses.webRequest.onSendHeaders(null);
});
it('receives details object', async () => {
ses.webRequest.onSendHeaders((details) => {
2020-03-20 20:28:31 +00:00
expect(details.requestHeaders).to.be.an('object');
});
const { data } = await ajax(defaultURL);
expect(data).to.equal('/');
});
});
describe('webRequest.onHeadersReceived', () => {
afterEach(() => {
2020-03-20 20:28:31 +00:00
ses.webRequest.onHeadersReceived(null);
});
it('receives details object', async () => {
ses.webRequest.onHeadersReceived((details, callback) => {
2020-03-20 20:28:31 +00:00
expect(details.statusLine).to.equal('HTTP/1.1 200 OK');
expect(details.statusCode).to.equal(200);
expect(details.responseHeaders!.Custom).to.deep.equal(['Header']);
callback({});
});
const { data } = await ajax(defaultURL);
expect(data).to.equal('/');
});
it('can change the response header', async () => {
ses.webRequest.onHeadersReceived((details, callback) => {
2020-03-20 20:28:31 +00:00
const responseHeaders = details.responseHeaders!;
responseHeaders.Custom = ['Changed'] as any;
callback({ responseHeaders: responseHeaders });
});
const { headers } = await ajax(defaultURL);
expect(headers).to.to.have.property('custom', 'Changed');
2020-03-20 20:28:31 +00:00
});
it('can change response origin', async () => {
ses.webRequest.onHeadersReceived((details, callback) => {
2020-03-20 20:28:31 +00:00
const responseHeaders = details.responseHeaders!;
responseHeaders['access-control-allow-origin'] = ['http://new-origin'] as any;
callback({ responseHeaders: responseHeaders });
});
const { headers } = await ajax(defaultURL);
expect(headers).to.to.have.property('access-control-allow-origin', 'http://new-origin');
2020-03-20 20:28:31 +00:00
});
it('can change headers of CORS responses', async () => {
ses.webRequest.onHeadersReceived((details, callback) => {
2020-03-20 20:28:31 +00:00
const responseHeaders = details.responseHeaders!;
responseHeaders.Custom = ['Changed'] as any;
callback({ responseHeaders: responseHeaders });
});
const { headers } = await ajax('cors://host');
expect(headers).to.to.have.property('custom', 'Changed');
2020-03-20 20:28:31 +00:00
});
it('does not change header by default', async () => {
ses.webRequest.onHeadersReceived((details, callback) => {
2020-03-20 20:28:31 +00:00
callback({});
});
const { data, headers } = await ajax(defaultURL);
expect(headers).to.to.have.property('custom', 'Header');
2020-03-20 20:28:31 +00:00
expect(data).to.equal('/');
});
it('does not change content-disposition header by default', async () => {
ses.webRequest.onHeadersReceived((details, callback) => {
expect(details.responseHeaders!['content-disposition']).to.deep.equal([' attachment; filename="aa中aa.txt"']);
callback({});
});
const { data, headers } = await ajax(defaultURL + 'contentDisposition');
expect(headers).to.to.have.property('content-disposition', 'attachment; filename=aa%E4%B8%ADaa.txt');
expect(data).to.equal('/contentDisposition');
});
it('follows server redirect', async () => {
ses.webRequest.onHeadersReceived((details, callback) => {
2020-03-20 20:28:31 +00:00
const responseHeaders = details.responseHeaders;
callback({ responseHeaders: responseHeaders });
});
const { headers } = await ajax(defaultURL + 'serverRedirect');
expect(headers).to.to.have.property('custom', 'Header');
2020-03-20 20:28:31 +00:00
});
2016-04-08 08:33:57 +00:00
it('can change the header status', async () => {
ses.webRequest.onHeadersReceived((details, callback) => {
2020-03-20 20:28:31 +00:00
const responseHeaders = details.responseHeaders;
2016-04-08 08:33:57 +00:00
callback({
responseHeaders: responseHeaders,
2016-06-29 16:37:10 +00:00
statusLine: 'HTTP/1.1 404 Not Found'
2020-03-20 20:28:31 +00:00
});
});
const { headers } = await ajax(defaultURL);
expect(headers).to.to.have.property('custom', 'Header');
2020-03-20 20:28:31 +00:00
});
});
describe('webRequest.onResponseStarted', () => {
afterEach(() => {
2020-03-20 20:28:31 +00:00
ses.webRequest.onResponseStarted(null);
});
it('receives details object', async () => {
ses.webRequest.onResponseStarted((details) => {
2020-03-20 20:28:31 +00:00
expect(details.fromCache).to.be.a('boolean');
expect(details.statusLine).to.equal('HTTP/1.1 200 OK');
expect(details.statusCode).to.equal(200);
expect(details.responseHeaders!.Custom).to.deep.equal(['Header']);
});
const { data, headers } = await ajax(defaultURL);
expect(headers).to.to.have.property('custom', 'Header');
2020-03-20 20:28:31 +00:00
expect(data).to.equal('/');
});
});
describe('webRequest.onBeforeRedirect', () => {
afterEach(() => {
2020-03-20 20:28:31 +00:00
ses.webRequest.onBeforeRedirect(null);
ses.webRequest.onBeforeRequest(null);
});
it('receives details object', async () => {
2020-03-20 20:28:31 +00:00
const redirectURL = defaultURL + 'redirect';
ses.webRequest.onBeforeRequest((details, callback) => {
2016-01-12 02:40:23 +00:00
if (details.url === defaultURL) {
2020-03-20 20:28:31 +00:00
callback({ redirectURL: redirectURL });
2016-01-12 02:40:23 +00:00
} else {
2020-03-20 20:28:31 +00:00
callback({});
2016-01-12 02:40:23 +00:00
}
2020-03-20 20:28:31 +00:00
});
ses.webRequest.onBeforeRedirect((details) => {
2020-03-20 20:28:31 +00:00
expect(details.fromCache).to.be.a('boolean');
expect(details.statusLine).to.equal('HTTP/1.1 307 Internal Redirect');
expect(details.statusCode).to.equal(307);
expect(details.redirectURL).to.equal(redirectURL);
});
const { data } = await ajax(defaultURL);
expect(data).to.equal('/redirect');
});
});
describe('webRequest.onCompleted', () => {
afterEach(() => {
2020-03-20 20:28:31 +00:00
ses.webRequest.onCompleted(null);
});
it('receives details object', async () => {
ses.webRequest.onCompleted((details) => {
2020-03-20 20:28:31 +00:00
expect(details.fromCache).to.be.a('boolean');
expect(details.statusLine).to.equal('HTTP/1.1 200 OK');
expect(details.statusCode).to.equal(200);
});
const { data } = await ajax(defaultURL);
expect(data).to.equal('/');
});
});
describe('webRequest.onErrorOccurred', () => {
afterEach(() => {
2020-03-20 20:28:31 +00:00
ses.webRequest.onErrorOccurred(null);
ses.webRequest.onBeforeRequest(null);
});
it('receives details object', async () => {
ses.webRequest.onBeforeRequest((details, callback) => {
2020-03-20 20:28:31 +00:00
callback({ cancel: true });
});
ses.webRequest.onErrorOccurred((details) => {
2020-03-20 20:28:31 +00:00
expect(details.error).to.equal('net::ERR_BLOCKED_BY_CLIENT');
});
await expect(ajax(defaultURL)).to.eventually.be.rejected();
2020-03-20 20:28:31 +00:00
});
});
describe('WebSocket connections', () => {
it('can be proxyed', async () => {
// Setup server.
2020-03-20 20:28:31 +00:00
const reqHeaders : { [key: string] : any } = {};
const server = http.createServer((req, res) => {
2020-03-20 20:28:31 +00:00
reqHeaders[req.url!] = req.headers;
res.setHeader('foo1', 'bar1');
res.end('ok');
});
const wss = new WebSocket.Server({ noServer: true });
wss.on('connection', function connection (ws) {
ws.on('message', function incoming (message) {
if (message === 'foo') {
2020-03-20 20:28:31 +00:00
ws.send('bar');
}
2020-03-20 20:28:31 +00:00
});
});
server.on('upgrade', function upgrade (request, socket, head) {
2020-03-20 20:28:31 +00:00
const pathname = require('url').parse(request.url).pathname;
if (pathname === '/websocket') {
reqHeaders[request.url!] = request.headers;
wss.handleUpgrade(request, socket as Socket, head, function done (ws) {
2020-03-20 20:28:31 +00:00
wss.emit('connection', ws, request);
});
}
2020-03-20 20:28:31 +00:00
});
// Start server.
const { port } = await listen(server);
// Use a separate session for testing.
2020-03-20 20:28:31 +00:00
const ses = session.fromPartition('WebRequestWebSocket');
// Setup listeners.
2020-03-20 20:28:31 +00:00
const receivedHeaders : { [key: string] : any } = {};
ses.webRequest.onBeforeSendHeaders((details, callback) => {
2020-03-20 20:28:31 +00:00
details.requestHeaders.foo = 'bar';
callback({ requestHeaders: details.requestHeaders });
});
ses.webRequest.onHeadersReceived((details, callback) => {
2020-03-20 20:28:31 +00:00
const pathname = require('url').parse(details.url).pathname;
receivedHeaders[pathname] = details.responseHeaders;
callback({ cancel: false });
});
ses.webRequest.onResponseStarted((details) => {
if (details.url.startsWith('ws://')) {
2020-03-20 20:28:31 +00:00
expect(details.responseHeaders!.Connection[0]).be.equal('Upgrade');
} else if (details.url.startsWith('http')) {
2020-03-20 20:28:31 +00:00
expect(details.responseHeaders!.foo1[0]).be.equal('bar1');
}
2020-03-20 20:28:31 +00:00
});
ses.webRequest.onSendHeaders((details) => {
if (details.url.startsWith('ws://')) {
2020-03-20 20:28:31 +00:00
expect(details.requestHeaders.foo).be.equal('bar');
expect(details.requestHeaders.Upgrade).be.equal('websocket');
} else if (details.url.startsWith('http')) {
2020-03-20 20:28:31 +00:00
expect(details.requestHeaders.foo).be.equal('bar');
}
2020-03-20 20:28:31 +00:00
});
ses.webRequest.onCompleted((details) => {
if (details.url.startsWith('ws://')) {
2020-03-20 20:28:31 +00:00
expect(details.error).be.equal('net::ERR_WS_UPGRADE');
} else if (details.url.startsWith('http')) {
2020-03-20 20:28:31 +00:00
expect(details.error).be.equal('net::OK');
}
2020-03-20 20:28:31 +00:00
});
const contents = (webContents as typeof ElectronInternal.WebContents).create({
session: ses,
nodeIntegration: true,
webSecurity: false,
contextIsolation: false
2020-03-20 20:28:31 +00:00
});
// Cleanup.
after(() => {
2020-03-20 20:28:31 +00:00
contents.destroy();
server.close();
ses.webRequest.onBeforeRequest(null);
ses.webRequest.onBeforeSendHeaders(null);
ses.webRequest.onHeadersReceived(null);
ses.webRequest.onResponseStarted(null);
ses.webRequest.onSendHeaders(null);
ses.webRequest.onCompleted(null);
});
contents.loadFile(path.join(fixturesPath, 'api', 'webrequest.html'), { query: { port: `${port}` } });
await once(ipcMain, 'websocket-success');
2020-03-20 20:28:31 +00:00
expect(receivedHeaders['/websocket'].Upgrade[0]).to.equal('websocket');
expect(receivedHeaders['/'].foo1[0]).to.equal('bar1');
expect(reqHeaders['/websocket'].foo).to.equal('bar');
expect(reqHeaders['/'].foo).to.equal('bar');
});
});
});