forked from adamlaska/electron
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathapi-ipc-renderer-spec.ts
More file actions
205 lines (177 loc) · 7.31 KB
/
api-ipc-renderer-spec.ts
File metadata and controls
205 lines (177 loc) · 7.31 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
import { expect } from 'chai';
import * as path from 'path';
import { ipcMain, BrowserWindow, WebContents, WebPreferences, webContents } from 'electron/main';
import { emittedOnce } from './events-helpers';
import { closeWindow } from './window-helpers';
describe('ipcRenderer module', () => {
const fixtures = path.join(__dirname, '..', 'spec', 'fixtures');
let w: BrowserWindow;
before(async () => {
w = new BrowserWindow({ show: false, webPreferences: { nodeIntegration: true, contextIsolation: false } });
await w.loadURL('about:blank');
});
after(async () => {
await closeWindow(w);
w = null as unknown as BrowserWindow;
});
describe('send()', () => {
it('should work when sending an object containing id property', async () => {
const obj = {
id: 1,
name: 'ly'
};
w.webContents.executeJavaScript(`{
const { ipcRenderer } = require('electron')
ipcRenderer.send('message', ${JSON.stringify(obj)})
}`);
const [, received] = await emittedOnce(ipcMain, 'message');
expect(received).to.deep.equal(obj);
});
it('can send instances of Date as Dates', async () => {
const isoDate = new Date().toISOString();
w.webContents.executeJavaScript(`{
const { ipcRenderer } = require('electron')
ipcRenderer.send('message', new Date(${JSON.stringify(isoDate)}))
}`);
const [, received] = await emittedOnce(ipcMain, 'message');
expect(received.toISOString()).to.equal(isoDate);
});
it('can send instances of Buffer', async () => {
const data = 'hello';
w.webContents.executeJavaScript(`{
const { ipcRenderer } = require('electron')
ipcRenderer.send('message', Buffer.from(${JSON.stringify(data)}))
}`);
const [, received] = await emittedOnce(ipcMain, 'message');
expect(received).to.be.an.instanceOf(Uint8Array);
expect(Buffer.from(data).equals(received)).to.be.true();
});
it('throws when sending objects with DOM class prototypes', async () => {
await expect(w.webContents.executeJavaScript(`{
const { ipcRenderer } = require('electron')
ipcRenderer.send('message', document.location)
}`)).to.eventually.be.rejected();
});
it('does not crash when sending external objects', async () => {
await expect(w.webContents.executeJavaScript(`{
const { ipcRenderer } = require('electron')
const http = require('http')
const request = http.request({ port: 5000, hostname: '127.0.0.1', method: 'GET', path: '/' })
const stream = request.agent.sockets['127.0.0.1:5000:'][0]._handle._externalStream
ipcRenderer.send('message', stream)
}`)).to.eventually.be.rejected();
});
it('can send objects that both reference the same object', async () => {
w.webContents.executeJavaScript(`{
const { ipcRenderer } = require('electron')
const child = { hello: 'world' }
const foo = { name: 'foo', child: child }
const bar = { name: 'bar', child: child }
const array = [foo, bar]
ipcRenderer.send('message', array, foo, bar, child)
}`);
const child = { hello: 'world' };
const foo = { name: 'foo', child: child };
const bar = { name: 'bar', child: child };
const array = [foo, bar];
const [, arrayValue, fooValue, barValue, childValue] = await emittedOnce(ipcMain, 'message');
expect(arrayValue).to.deep.equal(array);
expect(fooValue).to.deep.equal(foo);
expect(barValue).to.deep.equal(bar);
expect(childValue).to.deep.equal(child);
});
it('can handle cyclic references', async () => {
w.webContents.executeJavaScript(`{
const { ipcRenderer } = require('electron')
const array = [5]
array.push(array)
const child = { hello: 'world' }
child.child = child
ipcRenderer.send('message', array, child)
}`);
const [, arrayValue, childValue] = await emittedOnce(ipcMain, 'message');
expect(arrayValue[0]).to.equal(5);
expect(arrayValue[1]).to.equal(arrayValue);
expect(childValue.hello).to.equal('world');
expect(childValue.child).to.equal(childValue);
});
});
describe('sendSync()', () => {
it('can be replied to by setting event.returnValue', async () => {
ipcMain.once('echo', (event, msg) => {
event.returnValue = msg;
});
const msg = await w.webContents.executeJavaScript(`new Promise(resolve => {
const { ipcRenderer } = require('electron')
resolve(ipcRenderer.sendSync('echo', 'test'))
})`);
expect(msg).to.equal('test');
});
});
describe('sendTo()', () => {
const generateSpecs = (description: string, webPreferences: WebPreferences) => {
describe(description, () => {
let contents: WebContents;
const payload = 'Hello World!';
before(async () => {
contents = (webContents as any).create({
preload: path.join(fixtures, 'module', 'preload-ipc-ping-pong.js'),
...webPreferences
});
await contents.loadURL('about:blank');
});
after(() => {
(contents as any).destroy();
contents = null as unknown as WebContents;
});
it('sends message to WebContents', async () => {
const data = await w.webContents.executeJavaScript(`new Promise(resolve => {
const { ipcRenderer } = require('electron')
ipcRenderer.sendTo(${contents.id}, 'ping', ${JSON.stringify(payload)})
ipcRenderer.once('pong', (event, data) => resolve(data))
})`);
expect(data).to.equal(payload);
});
it('sends message on channel with non-ASCII characters to WebContents', async () => {
const data = await w.webContents.executeJavaScript(`new Promise(resolve => {
const { ipcRenderer } = require('electron')
ipcRenderer.sendTo(${contents.id}, 'ping-æøåü', ${JSON.stringify(payload)})
ipcRenderer.once('pong-æøåü', (event, data) => resolve(data))
})`);
expect(data).to.equal(payload);
});
});
};
generateSpecs('without sandbox', {});
generateSpecs('with sandbox', { sandbox: true });
generateSpecs('with contextIsolation', { contextIsolation: true });
generateSpecs('with contextIsolation + sandbox', { contextIsolation: true, sandbox: true });
});
describe('ipcRenderer.on', () => {
it('is not used for internals', async () => {
const result = await w.webContents.executeJavaScript(`
require('electron').ipcRenderer.eventNames()
`);
expect(result).to.deep.equal([]);
});
});
describe('after context is released', () => {
it('throws an exception', async () => {
const error = await w.webContents.executeJavaScript(`(${() => {
const child = window.open('', 'child', 'show=no,nodeIntegration=yes')! as any;
const childIpc = child.require('electron').ipcRenderer;
child.close();
return new Promise(resolve => {
setInterval(() => {
try {
childIpc.send('hello');
} catch (e) {
resolve(e);
}
}, 16);
});
}})()`);
expect(error).to.have.property('message', 'IPC method called after context was released');
});
});
});