777 lines
32 KiB
TypeScript
777 lines
32 KiB
TypeScript
import { expect } from 'chai';
|
|
import { app, session, BrowserWindow, ipcMain, WebContents, Extension } from 'electron';
|
|
import { closeAllWindows, closeWindow } from './window-helpers';
|
|
import * as http from 'http';
|
|
import { AddressInfo } from 'net';
|
|
import * as path from 'path';
|
|
import * as fs from 'fs';
|
|
import { ifdescribe } from './spec-helpers';
|
|
import { emittedOnce, emittedNTimes } from './events-helpers';
|
|
|
|
const fixtures = path.join(__dirname, 'fixtures');
|
|
|
|
ifdescribe(process.electronBinding('features').isExtensionsEnabled())('chrome extensions', () => {
|
|
// NB. extensions are only allowed on http://, https:// and ftp:// (!) urls by default.
|
|
let server: http.Server;
|
|
let url: string;
|
|
before(async () => {
|
|
server = http.createServer((req, res) => res.end());
|
|
await new Promise(resolve => server.listen(0, '127.0.0.1', () => {
|
|
url = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
|
|
resolve();
|
|
}));
|
|
});
|
|
after(() => {
|
|
server.close();
|
|
});
|
|
afterEach(closeAllWindows);
|
|
afterEach(() => {
|
|
session.defaultSession.getAllExtensions().forEach((e: any) => {
|
|
session.defaultSession.removeExtension(e.id);
|
|
});
|
|
});
|
|
|
|
it('loads an extension', async () => {
|
|
// NB. we have to use a persist: session (i.e. non-OTR) because the
|
|
// extension registry is redirected to the main session. so installing an
|
|
// extension in an in-memory session results in it being installed in the
|
|
// default session.
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
await customSession.loadExtension(path.join(fixtures, 'extensions', 'red-bg'));
|
|
const w = new BrowserWindow({ show: false, webPreferences: { session: customSession } });
|
|
await w.loadURL(url);
|
|
const bg = await w.webContents.executeJavaScript('document.documentElement.style.backgroundColor');
|
|
expect(bg).to.equal('red');
|
|
});
|
|
|
|
it('serializes a loaded extension', async () => {
|
|
const extensionPath = path.join(fixtures, 'extensions', 'red-bg');
|
|
const manifest = JSON.parse(fs.readFileSync(path.join(extensionPath, 'manifest.json'), 'utf-8'));
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
const extension = await customSession.loadExtension(extensionPath);
|
|
expect(extension.id).to.be.a('string');
|
|
expect(extension.name).to.be.a('string');
|
|
expect(extension.path).to.be.a('string');
|
|
expect(extension.version).to.be.a('string');
|
|
expect(extension.url).to.be.a('string');
|
|
expect(extension.manifest).to.deep.equal(manifest);
|
|
});
|
|
|
|
it('removes an extension', async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
const { id } = await customSession.loadExtension(path.join(fixtures, 'extensions', 'red-bg'));
|
|
{
|
|
const w = new BrowserWindow({ show: false, webPreferences: { session: customSession } });
|
|
await w.loadURL(url);
|
|
const bg = await w.webContents.executeJavaScript('document.documentElement.style.backgroundColor');
|
|
expect(bg).to.equal('red');
|
|
}
|
|
customSession.removeExtension(id);
|
|
{
|
|
const w = new BrowserWindow({ show: false, webPreferences: { session: customSession } });
|
|
await w.loadURL(url);
|
|
const bg = await w.webContents.executeJavaScript('document.documentElement.style.backgroundColor');
|
|
expect(bg).to.equal('');
|
|
}
|
|
});
|
|
|
|
it('lists loaded extensions in getAllExtensions', async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
const e = await customSession.loadExtension(path.join(fixtures, 'extensions', 'red-bg'));
|
|
expect(customSession.getAllExtensions()).to.deep.equal([e]);
|
|
customSession.removeExtension(e.id);
|
|
expect(customSession.getAllExtensions()).to.deep.equal([]);
|
|
});
|
|
|
|
it('gets an extension by id', async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
const e = await customSession.loadExtension(path.join(fixtures, 'extensions', 'red-bg'));
|
|
expect(customSession.getExtension(e.id)).to.deep.equal(e);
|
|
});
|
|
|
|
it('confines an extension to the session it was loaded in', async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
await customSession.loadExtension(path.join(fixtures, 'extensions', 'red-bg'));
|
|
const w = new BrowserWindow({ show: false }); // not in the session
|
|
await w.loadURL(url);
|
|
const bg = await w.webContents.executeJavaScript('document.documentElement.style.backgroundColor');
|
|
expect(bg).to.equal('');
|
|
});
|
|
|
|
it('loading an extension in a temporary session throws an error', async () => {
|
|
const customSession = session.fromPartition(require('uuid').v4());
|
|
await expect(customSession.loadExtension(path.join(fixtures, 'extensions', 'red-bg'))).to.eventually.be.rejectedWith('Extensions cannot be loaded in a temporary session');
|
|
});
|
|
|
|
describe('chrome.i18n', () => {
|
|
let w: BrowserWindow;
|
|
let extension: Extension;
|
|
const exec = async (name: string) => {
|
|
const p = emittedOnce(ipcMain, 'success');
|
|
await w.webContents.executeJavaScript(`exec('${name}')`);
|
|
const [, result] = await p;
|
|
return result;
|
|
};
|
|
beforeEach(async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
extension = await customSession.loadExtension(path.join(fixtures, 'extensions', 'chrome-i18n'));
|
|
w = new BrowserWindow({ show: false, webPreferences: { session: customSession, nodeIntegration: true } });
|
|
await w.loadURL(url);
|
|
});
|
|
it('getAcceptLanguages()', async () => {
|
|
const result = await exec('getAcceptLanguages');
|
|
expect(result).to.be.an('array').and.deep.equal(['en-US']);
|
|
});
|
|
it('getMessage()', async () => {
|
|
const result = await exec('getMessage');
|
|
expect(result.id).to.be.a('string').and.equal(extension.id);
|
|
expect(result.name).to.be.a('string').and.equal('chrome-i18n');
|
|
});
|
|
});
|
|
|
|
describe('chrome.runtime', () => {
|
|
let content: any;
|
|
before(async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
customSession.loadExtension(path.join(fixtures, 'extensions', 'chrome-runtime'));
|
|
const w = new BrowserWindow({ show: false, webPreferences: { session: customSession } });
|
|
try {
|
|
await w.loadURL(url);
|
|
content = JSON.parse(await w.webContents.executeJavaScript('document.documentElement.textContent'));
|
|
expect(content).to.be.an('object');
|
|
} finally {
|
|
w.destroy();
|
|
}
|
|
});
|
|
it('getManifest()', () => {
|
|
expect(content.manifest).to.be.an('object').with.property('name', 'chrome-runtime');
|
|
});
|
|
it('id', () => {
|
|
expect(content.id).to.be.a('string').with.lengthOf(32);
|
|
});
|
|
it('getURL()', () => {
|
|
expect(content.url).to.be.a('string').and.match(/^chrome-extension:\/\/.*main.js$/);
|
|
});
|
|
});
|
|
|
|
describe('chrome.storage', () => {
|
|
it('stores and retrieves a key', async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
await customSession.loadExtension(path.join(fixtures, 'extensions', 'chrome-storage'));
|
|
const w = new BrowserWindow({ show: false, webPreferences: { session: customSession, nodeIntegration: true } });
|
|
try {
|
|
const p = emittedOnce(ipcMain, 'storage-success');
|
|
await w.loadURL(url);
|
|
const [, v] = await p;
|
|
expect(v).to.equal('value');
|
|
} finally {
|
|
w.destroy();
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('chrome.tabs', () => {
|
|
it('executeScript', async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
await customSession.loadExtension(path.join(fixtures, 'extensions', 'chrome-api'));
|
|
const w = new BrowserWindow({ show: false, webPreferences: { session: customSession, nodeIntegration: true } });
|
|
await w.loadURL(url);
|
|
|
|
const message = { method: 'executeScript', args: ['1 + 2'] };
|
|
w.webContents.executeJavaScript(`window.postMessage('${JSON.stringify(message)}', '*')`);
|
|
|
|
const [,, responseString] = await emittedOnce(w.webContents, 'console-message');
|
|
const response = JSON.parse(responseString);
|
|
|
|
expect(response).to.equal(3);
|
|
});
|
|
|
|
it('connect', async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
await customSession.loadExtension(path.join(fixtures, 'extensions', 'chrome-api'));
|
|
const w = new BrowserWindow({ show: false, webPreferences: { session: customSession, nodeIntegration: true } });
|
|
await w.loadURL(url);
|
|
|
|
const portName = require('uuid').v4();
|
|
const message = { method: 'connectTab', args: [portName] };
|
|
w.webContents.executeJavaScript(`window.postMessage('${JSON.stringify(message)}', '*')`);
|
|
|
|
const [,, responseString] = await emittedOnce(w.webContents, 'console-message');
|
|
const response = responseString.split(',');
|
|
expect(response[0]).to.equal(portName);
|
|
expect(response[1]).to.equal('howdy');
|
|
});
|
|
|
|
it('sendMessage receives the response', async function () {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
await customSession.loadExtension(path.join(fixtures, 'extensions', 'chrome-api'));
|
|
const w = new BrowserWindow({ show: false, webPreferences: { session: customSession, nodeIntegration: true } });
|
|
await w.loadURL(url);
|
|
|
|
const message = { method: 'sendMessage', args: ['Hello World!'] };
|
|
w.webContents.executeJavaScript(`window.postMessage('${JSON.stringify(message)}', '*')`);
|
|
|
|
const [,, responseString] = await emittedOnce(w.webContents, 'console-message');
|
|
const response = JSON.parse(responseString);
|
|
|
|
expect(response.message).to.equal('Hello World!');
|
|
expect(response.tabId).to.equal(w.webContents.id);
|
|
});
|
|
});
|
|
|
|
describe('background pages', () => {
|
|
it('loads a lazy background page when sending a message', async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
await customSession.loadExtension(path.join(fixtures, 'extensions', 'lazy-background-page'));
|
|
const w = new BrowserWindow({ show: false, webPreferences: { session: customSession, nodeIntegration: true } });
|
|
try {
|
|
w.loadURL(url);
|
|
const [, resp] = await emittedOnce(ipcMain, 'bg-page-message-response');
|
|
expect(resp.message).to.deep.equal({ some: 'message' });
|
|
expect(resp.sender.id).to.be.a('string');
|
|
expect(resp.sender.origin).to.equal(url);
|
|
expect(resp.sender.url).to.equal(url + '/');
|
|
} finally {
|
|
w.destroy();
|
|
}
|
|
});
|
|
|
|
it('can use extension.getBackgroundPage from a ui page', async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
const { id } = await customSession.loadExtension(path.join(fixtures, 'extensions', 'lazy-background-page'));
|
|
const w = new BrowserWindow({ show: false, webPreferences: { session: customSession } });
|
|
await w.loadURL(`chrome-extension://${id}/page-get-background.html`);
|
|
const receivedMessage = await w.webContents.executeJavaScript('window.completionPromise');
|
|
expect(receivedMessage).to.deep.equal({ some: 'message' });
|
|
});
|
|
|
|
it('can use extension.getBackgroundPage from a ui page', async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
const { id } = await customSession.loadExtension(path.join(fixtures, 'extensions', 'lazy-background-page'));
|
|
const w = new BrowserWindow({ show: false, webPreferences: { session: customSession } });
|
|
await w.loadURL(`chrome-extension://${id}/page-get-background.html`);
|
|
const receivedMessage = await w.webContents.executeJavaScript('window.completionPromise');
|
|
expect(receivedMessage).to.deep.equal({ some: 'message' });
|
|
});
|
|
|
|
it('can use runtime.getBackgroundPage from a ui page', async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
const { id } = await customSession.loadExtension(path.join(fixtures, 'extensions', 'lazy-background-page'));
|
|
const w = new BrowserWindow({ show: false, webPreferences: { session: customSession } });
|
|
await w.loadURL(`chrome-extension://${id}/page-runtime-get-background.html`);
|
|
const receivedMessage = await w.webContents.executeJavaScript('window.completionPromise');
|
|
expect(receivedMessage).to.deep.equal({ some: 'message' });
|
|
});
|
|
});
|
|
|
|
describe('devtools extensions', () => {
|
|
let showPanelTimeoutId: any = null;
|
|
afterEach(() => {
|
|
if (showPanelTimeoutId) clearTimeout(showPanelTimeoutId);
|
|
});
|
|
const showLastDevToolsPanel = (w: BrowserWindow) => {
|
|
w.webContents.once('devtools-opened', () => {
|
|
const show = () => {
|
|
if (w == null || w.isDestroyed()) return;
|
|
const { devToolsWebContents } = w as unknown as { devToolsWebContents: WebContents | undefined };
|
|
if (devToolsWebContents == null || devToolsWebContents.isDestroyed()) {
|
|
return;
|
|
}
|
|
|
|
const showLastPanel = () => {
|
|
// this is executed in the devtools context, where UI is a global
|
|
const { UI } = (window as any);
|
|
const lastPanelId = UI.inspectorView._tabbedPane._tabs.peekLast().id;
|
|
UI.inspectorView.showPanel(lastPanelId);
|
|
};
|
|
devToolsWebContents.executeJavaScript(`(${showLastPanel})()`, false).then(() => {
|
|
showPanelTimeoutId = setTimeout(show, 100);
|
|
});
|
|
};
|
|
showPanelTimeoutId = setTimeout(show, 100);
|
|
});
|
|
};
|
|
|
|
it('loads a devtools extension', async () => {
|
|
const customSession = session.fromPartition(`persist:${require('uuid').v4()}`);
|
|
customSession.loadExtension(path.join(fixtures, 'extensions', 'devtools-extension'));
|
|
const w = new BrowserWindow({ show: true, webPreferences: { session: customSession, nodeIntegration: true } });
|
|
await w.loadURL('data:text/html,hello');
|
|
w.webContents.openDevTools();
|
|
showLastDevToolsPanel(w);
|
|
await emittedOnce(ipcMain, 'winning');
|
|
});
|
|
});
|
|
|
|
describe('deprecation shims', () => {
|
|
it('loads an extension through BrowserWindow.addExtension', async () => {
|
|
BrowserWindow.addExtension(path.join(fixtures, 'extensions', 'red-bg'));
|
|
const w = new BrowserWindow({ show: false });
|
|
await w.loadURL(url);
|
|
const bg = await w.webContents.executeJavaScript('document.documentElement.style.backgroundColor');
|
|
expect(bg).to.equal('red');
|
|
});
|
|
|
|
it('loads an extension through BrowserWindow.addDevToolsExtension', async () => {
|
|
BrowserWindow.addDevToolsExtension(path.join(fixtures, 'extensions', 'red-bg'));
|
|
const w = new BrowserWindow({ show: false });
|
|
await w.loadURL(url);
|
|
const bg = await w.webContents.executeJavaScript('document.documentElement.style.backgroundColor');
|
|
expect(bg).to.equal('red');
|
|
});
|
|
|
|
it('removes an extension through BrowserWindow.removeExtension', async () => {
|
|
await (BrowserWindow.addExtension(path.join(fixtures, 'extensions', 'red-bg')) as any);
|
|
BrowserWindow.removeExtension('red-bg');
|
|
const w = new BrowserWindow({ show: false });
|
|
await w.loadURL(url);
|
|
const bg = await w.webContents.executeJavaScript('document.documentElement.style.backgroundColor');
|
|
expect(bg).to.equal('');
|
|
});
|
|
});
|
|
|
|
describe('chrome extension content scripts', () => {
|
|
const fixtures = path.resolve(__dirname, 'fixtures');
|
|
const extensionPath = path.resolve(fixtures, 'extensions');
|
|
|
|
const addExtension = (name: string) => session.defaultSession.loadExtension(path.resolve(extensionPath, name));
|
|
const removeAllExtensions = () => {
|
|
Object.keys(session.defaultSession.getAllExtensions()).map(extName => {
|
|
session.defaultSession.removeExtension(extName);
|
|
});
|
|
};
|
|
|
|
let responseIdCounter = 0;
|
|
const executeJavaScriptInFrame = (webContents: WebContents, frameRoutingId: number, code: string) => {
|
|
return new Promise(resolve => {
|
|
const responseId = responseIdCounter++;
|
|
ipcMain.once(`executeJavaScriptInFrame_${responseId}`, (event, result) => {
|
|
resolve(result);
|
|
});
|
|
webContents.send('executeJavaScriptInFrame', frameRoutingId, code, responseId);
|
|
});
|
|
};
|
|
|
|
const generateTests = (sandboxEnabled: boolean, contextIsolationEnabled: boolean) => {
|
|
describe(`with sandbox ${sandboxEnabled ? 'enabled' : 'disabled'} and context isolation ${contextIsolationEnabled ? 'enabled' : 'disabled'}`, () => {
|
|
let w: BrowserWindow;
|
|
|
|
describe('supports "run_at" option', () => {
|
|
beforeEach(async () => {
|
|
await closeWindow(w);
|
|
w = new BrowserWindow({
|
|
show: false,
|
|
width: 400,
|
|
height: 400,
|
|
webPreferences: {
|
|
contextIsolation: contextIsolationEnabled,
|
|
sandbox: sandboxEnabled
|
|
}
|
|
});
|
|
});
|
|
|
|
afterEach(() => {
|
|
removeAllExtensions();
|
|
return closeWindow(w).then(() => { w = null as unknown as BrowserWindow; });
|
|
});
|
|
|
|
it('should run content script at document_start', async () => {
|
|
await addExtension('content-script-document-start');
|
|
w.webContents.once('dom-ready', async () => {
|
|
const result = await w.webContents.executeJavaScript('document.documentElement.style.backgroundColor');
|
|
expect(result).to.equal('red');
|
|
});
|
|
w.loadURL(url);
|
|
});
|
|
|
|
it('should run content script at document_idle', async () => {
|
|
await addExtension('content-script-document-idle');
|
|
w.loadURL(url);
|
|
const result = await w.webContents.executeJavaScript('document.body.style.backgroundColor');
|
|
expect(result).to.equal('red');
|
|
});
|
|
|
|
it('should run content script at document_end', async () => {
|
|
await addExtension('content-script-document-end');
|
|
w.webContents.once('did-finish-load', async () => {
|
|
const result = await w.webContents.executeJavaScript('document.documentElement.style.backgroundColor');
|
|
expect(result).to.equal('red');
|
|
});
|
|
w.loadURL(url);
|
|
});
|
|
});
|
|
|
|
// TODO(nornagon): real extensions don't load on file: urls, so this
|
|
// test needs to be updated to serve its content over http.
|
|
describe.skip('supports "all_frames" option', () => {
|
|
const contentScript = path.resolve(fixtures, 'extensions/content-script');
|
|
|
|
// Computed style values
|
|
const COLOR_RED = 'rgb(255, 0, 0)';
|
|
const COLOR_BLUE = 'rgb(0, 0, 255)';
|
|
const COLOR_TRANSPARENT = 'rgba(0, 0, 0, 0)';
|
|
|
|
before(() => {
|
|
BrowserWindow.addExtension(contentScript);
|
|
});
|
|
|
|
after(() => {
|
|
BrowserWindow.removeExtension('content-script-test');
|
|
});
|
|
|
|
beforeEach(() => {
|
|
w = new BrowserWindow({
|
|
show: false,
|
|
webPreferences: {
|
|
// enable content script injection in subframes
|
|
nodeIntegrationInSubFrames: true,
|
|
preload: path.join(contentScript, 'all_frames-preload.js')
|
|
}
|
|
});
|
|
});
|
|
|
|
afterEach(() =>
|
|
closeWindow(w).then(() => {
|
|
w = null as unknown as BrowserWindow;
|
|
})
|
|
);
|
|
|
|
it('applies matching rules in subframes', async () => {
|
|
const detailsPromise = emittedNTimes(w.webContents, 'did-frame-finish-load', 2);
|
|
w.loadFile(path.join(contentScript, 'frame-with-frame.html'));
|
|
const frameEvents = await detailsPromise;
|
|
await Promise.all(
|
|
frameEvents.map(async frameEvent => {
|
|
const [, isMainFrame, , frameRoutingId] = frameEvent;
|
|
const result: any = await executeJavaScriptInFrame(
|
|
w.webContents,
|
|
frameRoutingId,
|
|
`(() => {
|
|
const a = document.getElementById('all_frames_enabled')
|
|
const b = document.getElementById('all_frames_disabled')
|
|
return {
|
|
enabledColor: getComputedStyle(a).backgroundColor,
|
|
disabledColor: getComputedStyle(b).backgroundColor
|
|
}
|
|
})()`
|
|
);
|
|
expect(result.enabledColor).to.equal(COLOR_RED);
|
|
if (isMainFrame) {
|
|
expect(result.disabledColor).to.equal(COLOR_BLUE);
|
|
} else {
|
|
expect(result.disabledColor).to.equal(COLOR_TRANSPARENT); // null color
|
|
}
|
|
})
|
|
);
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
generateTests(false, false);
|
|
generateTests(false, true);
|
|
generateTests(true, false);
|
|
generateTests(true, true);
|
|
});
|
|
|
|
describe('extension ui pages', () => {
|
|
afterEach(() => {
|
|
session.defaultSession.getAllExtensions().forEach(e => {
|
|
session.defaultSession.removeExtension(e.id);
|
|
});
|
|
});
|
|
|
|
it('loads a ui page of an extension', async () => {
|
|
const { id } = await session.defaultSession.loadExtension(path.join(fixtures, 'extensions', 'ui-page'));
|
|
const w = new BrowserWindow({ show: false });
|
|
await w.loadURL(`chrome-extension://${id}/bare-page.html`);
|
|
const textContent = await w.webContents.executeJavaScript('document.body.textContent');
|
|
expect(textContent).to.equal('ui page loaded ok\n');
|
|
});
|
|
|
|
it('can load resources', async () => {
|
|
const { id } = await session.defaultSession.loadExtension(path.join(fixtures, 'extensions', 'ui-page'));
|
|
const w = new BrowserWindow({ show: false });
|
|
await w.loadURL(`chrome-extension://${id}/page-script-load.html`);
|
|
const textContent = await w.webContents.executeJavaScript('document.body.textContent');
|
|
expect(textContent).to.equal('script loaded ok\n');
|
|
});
|
|
});
|
|
});
|
|
|
|
ifdescribe(!process.electronBinding('features').isExtensionsEnabled())('chrome extensions', () => {
|
|
const fixtures = path.resolve(__dirname, 'fixtures');
|
|
let w: BrowserWindow;
|
|
|
|
before(() => {
|
|
BrowserWindow.addExtension(path.join(fixtures, 'extensions/chrome-api'));
|
|
});
|
|
|
|
after(() => {
|
|
BrowserWindow.removeExtension('chrome-api');
|
|
});
|
|
|
|
beforeEach(() => {
|
|
w = new BrowserWindow({ show: false });
|
|
});
|
|
|
|
afterEach(() => closeWindow(w).then(() => { w = null as unknown as BrowserWindow; }));
|
|
|
|
it('chrome.runtime.connect parses arguments properly', async function () {
|
|
await w.loadURL('about:blank');
|
|
|
|
const promise = emittedOnce(w.webContents, 'console-message');
|
|
|
|
const message = { method: 'connect' };
|
|
w.webContents.executeJavaScript(`window.postMessage('${JSON.stringify(message)}', '*')`);
|
|
|
|
const [,, responseString] = await promise;
|
|
const response = JSON.parse(responseString);
|
|
|
|
expect(response).to.be.true();
|
|
});
|
|
|
|
it('runtime.getManifest returns extension manifest', async () => {
|
|
const actualManifest = (() => {
|
|
const data = fs.readFileSync(path.join(fixtures, 'extensions/chrome-api/manifest.json'), 'utf-8');
|
|
return JSON.parse(data);
|
|
})();
|
|
|
|
await w.loadURL('about:blank');
|
|
|
|
const promise = emittedOnce(w.webContents, 'console-message');
|
|
|
|
const message = { method: 'getManifest' };
|
|
w.webContents.executeJavaScript(`window.postMessage('${JSON.stringify(message)}', '*')`);
|
|
|
|
const [,, manifestString] = await promise;
|
|
const manifest = JSON.parse(manifestString);
|
|
|
|
expect(manifest.name).to.equal(actualManifest.name);
|
|
expect(manifest.content_scripts).to.have.lengthOf(actualManifest.content_scripts.length);
|
|
});
|
|
|
|
it('chrome.tabs.sendMessage receives the response', async function () {
|
|
await w.loadURL('about:blank');
|
|
|
|
const promise = emittedOnce(w.webContents, 'console-message');
|
|
|
|
const message = { method: 'sendMessage', args: ['Hello World!'] };
|
|
w.webContents.executeJavaScript(`window.postMessage('${JSON.stringify(message)}', '*')`);
|
|
|
|
const [,, responseString] = await promise;
|
|
const response = JSON.parse(responseString);
|
|
|
|
expect(response.message).to.equal('Hello World!');
|
|
expect(response.tabId).to.equal(w.webContents.id);
|
|
});
|
|
|
|
it('chrome.tabs.executeScript receives the response', async function () {
|
|
await w.loadURL('about:blank');
|
|
|
|
const promise = emittedOnce(w.webContents, 'console-message');
|
|
|
|
const message = { method: 'executeScript', args: ['1 + 2'] };
|
|
w.webContents.executeJavaScript(`window.postMessage('${JSON.stringify(message)}', '*')`);
|
|
|
|
const [,, responseString] = await promise;
|
|
const response = JSON.parse(responseString);
|
|
|
|
expect(response).to.equal(3);
|
|
});
|
|
|
|
describe('extensions and dev tools extensions', () => {
|
|
let showPanelTimeoutId: NodeJS.Timeout | null = null;
|
|
|
|
const showLastDevToolsPanel = (w: BrowserWindow) => {
|
|
w.webContents.once('devtools-opened', () => {
|
|
const show = () => {
|
|
if (w == null || w.isDestroyed()) return;
|
|
const { devToolsWebContents } = w as unknown as { devToolsWebContents: WebContents | undefined };
|
|
if (devToolsWebContents == null || devToolsWebContents.isDestroyed()) {
|
|
return;
|
|
}
|
|
|
|
const showLastPanel = () => {
|
|
// this is executed in the devtools context, where UI is a global
|
|
const { UI } = (window as any);
|
|
const lastPanelId = UI.inspectorView._tabbedPane._tabs.peekLast().id;
|
|
UI.inspectorView.showPanel(lastPanelId);
|
|
};
|
|
devToolsWebContents.executeJavaScript(`(${showLastPanel})()`, false).then(() => {
|
|
showPanelTimeoutId = setTimeout(show, 100);
|
|
});
|
|
};
|
|
showPanelTimeoutId = setTimeout(show, 100);
|
|
});
|
|
};
|
|
|
|
afterEach(() => {
|
|
if (showPanelTimeoutId != null) {
|
|
clearTimeout(showPanelTimeoutId);
|
|
showPanelTimeoutId = null;
|
|
}
|
|
});
|
|
|
|
describe('BrowserWindow.addDevToolsExtension', () => {
|
|
describe('for invalid extensions', () => {
|
|
it('throws errors for missing manifest.json files', () => {
|
|
const nonexistentExtensionPath = path.join(__dirname, 'does-not-exist');
|
|
expect(() => {
|
|
BrowserWindow.addDevToolsExtension(nonexistentExtensionPath);
|
|
}).to.throw(/ENOENT: no such file or directory/);
|
|
});
|
|
|
|
it('throws errors for invalid manifest.json files', () => {
|
|
const badManifestExtensionPath = path.join(__dirname, 'fixtures', 'devtools-extensions', 'bad-manifest');
|
|
expect(() => {
|
|
BrowserWindow.addDevToolsExtension(badManifestExtensionPath);
|
|
}).to.throw(/Unexpected token }/);
|
|
});
|
|
});
|
|
|
|
describe('for a valid extension', () => {
|
|
const extensionName = 'foo';
|
|
|
|
before(() => {
|
|
const extensionPath = path.join(__dirname, 'fixtures', 'devtools-extensions', 'foo');
|
|
BrowserWindow.addDevToolsExtension(extensionPath);
|
|
expect(BrowserWindow.getDevToolsExtensions()).to.have.property(extensionName);
|
|
});
|
|
|
|
after(() => {
|
|
BrowserWindow.removeDevToolsExtension('foo');
|
|
expect(BrowserWindow.getDevToolsExtensions()).to.not.have.property(extensionName);
|
|
});
|
|
|
|
describe('when the devtools is docked', () => {
|
|
let message: any;
|
|
let w: BrowserWindow;
|
|
before(async () => {
|
|
w = new BrowserWindow({ show: false, webPreferences: { nodeIntegration: true } });
|
|
const p = new Promise(resolve => ipcMain.once('answer', (event, message) => {
|
|
resolve(message);
|
|
}));
|
|
showLastDevToolsPanel(w);
|
|
w.loadURL('about:blank');
|
|
w.webContents.openDevTools({ mode: 'bottom' });
|
|
message = await p;
|
|
});
|
|
after(closeAllWindows);
|
|
|
|
describe('created extension info', function () {
|
|
it('has proper "runtimeId"', async function () {
|
|
expect(message).to.have.ownProperty('runtimeId');
|
|
expect(message.runtimeId).to.equal(extensionName);
|
|
});
|
|
it('has "tabId" matching webContents id', function () {
|
|
expect(message).to.have.ownProperty('tabId');
|
|
expect(message.tabId).to.equal(w.webContents.id);
|
|
});
|
|
it('has "i18nString" with proper contents', function () {
|
|
expect(message).to.have.ownProperty('i18nString');
|
|
expect(message.i18nString).to.equal('foo - bar (baz)');
|
|
});
|
|
it('has "storageItems" with proper contents', function () {
|
|
expect(message).to.have.ownProperty('storageItems');
|
|
expect(message.storageItems).to.deep.equal({
|
|
local: {
|
|
set: { hello: 'world', world: 'hello' },
|
|
remove: { world: 'hello' },
|
|
clear: {}
|
|
},
|
|
sync: {
|
|
set: { foo: 'bar', bar: 'foo' },
|
|
remove: { foo: 'bar' },
|
|
clear: {}
|
|
}
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('when the devtools is undocked', () => {
|
|
let message: any;
|
|
let w: BrowserWindow;
|
|
before(async () => {
|
|
w = new BrowserWindow({ show: false, webPreferences: { nodeIntegration: true } });
|
|
showLastDevToolsPanel(w);
|
|
w.loadURL('about:blank');
|
|
w.webContents.openDevTools({ mode: 'undocked' });
|
|
message = await new Promise(resolve => ipcMain.once('answer', (event, message) => {
|
|
resolve(message);
|
|
}));
|
|
});
|
|
after(closeAllWindows);
|
|
|
|
describe('created extension info', function () {
|
|
it('has proper "runtimeId"', function () {
|
|
expect(message).to.have.ownProperty('runtimeId');
|
|
expect(message.runtimeId).to.equal(extensionName);
|
|
});
|
|
it('has "tabId" matching webContents id', function () {
|
|
expect(message).to.have.ownProperty('tabId');
|
|
expect(message.tabId).to.equal(w.webContents.id);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
it('works when used with partitions', async () => {
|
|
const w = new BrowserWindow({
|
|
show: false,
|
|
webPreferences: {
|
|
nodeIntegration: true,
|
|
partition: 'temp'
|
|
}
|
|
});
|
|
|
|
const extensionPath = path.join(__dirname, 'fixtures', 'devtools-extensions', 'foo');
|
|
BrowserWindow.addDevToolsExtension(extensionPath);
|
|
try {
|
|
showLastDevToolsPanel(w);
|
|
|
|
const p: Promise<any> = new Promise(resolve => ipcMain.once('answer', function (event, message) {
|
|
resolve(message);
|
|
}));
|
|
|
|
w.loadURL('about:blank');
|
|
w.webContents.openDevTools({ mode: 'bottom' });
|
|
const message = await p;
|
|
expect(message.runtimeId).to.equal('foo');
|
|
} finally {
|
|
BrowserWindow.removeDevToolsExtension('foo');
|
|
await closeAllWindows();
|
|
}
|
|
});
|
|
|
|
it('serializes the registered extensions on quit', () => {
|
|
const extensionName = 'foo';
|
|
const extensionPath = path.join(__dirname, 'fixtures', 'devtools-extensions', extensionName);
|
|
const serializedPath = path.join(app.getPath('userData'), 'DevTools Extensions');
|
|
|
|
BrowserWindow.addDevToolsExtension(extensionPath);
|
|
app.emit('will-quit');
|
|
expect(JSON.parse(fs.readFileSync(serializedPath, 'utf8'))).to.deep.equal([extensionPath]);
|
|
|
|
BrowserWindow.removeDevToolsExtension(extensionName);
|
|
app.emit('will-quit');
|
|
expect(fs.existsSync(serializedPath)).to.be.false('file exists');
|
|
});
|
|
|
|
describe('BrowserWindow.addExtension', () => {
|
|
it('throws errors for missing manifest.json files', () => {
|
|
expect(() => {
|
|
BrowserWindow.addExtension(path.join(__dirname, 'does-not-exist'));
|
|
}).to.throw('ENOENT: no such file or directory');
|
|
});
|
|
|
|
it('throws errors for invalid manifest.json files', () => {
|
|
expect(() => {
|
|
BrowserWindow.addExtension(path.join(__dirname, 'fixtures', 'devtools-extensions', 'bad-manifest'));
|
|
}).to.throw('Unexpected token }');
|
|
});
|
|
});
|
|
});
|
|
});
|