2024-10-03 22:21:54 +00:00
|
|
|
import { BaseWindow, BrowserWindow, BrowserWindowConstructorOptions, ipcMain, WebContents, WebContentsView } from 'electron/main';
|
|
|
|
|
2019-09-05 17:56:06 +00:00
|
|
|
import { expect } from 'chai';
|
2024-10-03 22:21:54 +00:00
|
|
|
|
2023-06-15 14:42:27 +00:00
|
|
|
import * as cp from 'node:child_process';
|
2024-10-03 22:21:54 +00:00
|
|
|
import { once } from 'node:events';
|
2023-06-15 14:42:27 +00:00
|
|
|
import * as path from 'node:path';
|
2024-10-03 22:21:54 +00:00
|
|
|
import { setTimeout } from 'node:timers/promises';
|
2019-09-05 17:56:06 +00:00
|
|
|
|
2023-02-23 23:53:53 +00:00
|
|
|
import { ifdescribe } from './lib/spec-helpers';
|
2024-10-03 22:21:54 +00:00
|
|
|
import { closeWindow } from './lib/window-helpers';
|
2019-09-05 17:56:06 +00:00
|
|
|
|
|
|
|
// visibilityState specs pass on linux with a real window manager but on CI
|
|
|
|
// the environment does not let these specs pass
|
2019-10-30 23:38:21 +00:00
|
|
|
ifdescribe(process.platform !== 'linux')('document.visibilityState', () => {
|
2023-12-13 21:01:03 +00:00
|
|
|
let w: BaseWindow & {webContents: WebContents};
|
2019-09-05 17:56:06 +00:00
|
|
|
|
|
|
|
afterEach(() => {
|
|
|
|
return closeWindow(w);
|
|
|
|
});
|
|
|
|
|
2023-12-13 21:01:03 +00:00
|
|
|
const load = () => w.webContents.loadFile(path.resolve(__dirname, 'fixtures', 'chromium', 'visibilitystate.html'));
|
2019-09-05 17:56:06 +00:00
|
|
|
|
|
|
|
const itWithOptions = (name: string, options: BrowserWindowConstructorOptions, fn: Mocha.Func) => {
|
2023-12-13 21:01:03 +00:00
|
|
|
it(name, async function (...args) {
|
2019-09-05 17:56:06 +00:00
|
|
|
w = new BrowserWindow({
|
|
|
|
...options,
|
|
|
|
paintWhenInitiallyHidden: false,
|
|
|
|
webPreferences: {
|
|
|
|
...(options.webPreferences || {}),
|
2021-03-01 21:52:29 +00:00
|
|
|
nodeIntegration: true,
|
|
|
|
contextIsolation: false
|
2019-09-05 17:56:06 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
await Promise.resolve(fn.apply(this, args));
|
|
|
|
});
|
2023-12-13 21:01:03 +00:00
|
|
|
|
|
|
|
it(name + ' with BaseWindow', async function (...args) {
|
|
|
|
const baseWindow = new BaseWindow({
|
|
|
|
...options
|
|
|
|
});
|
|
|
|
const wcv = new WebContentsView({ webPreferences: { ...(options.webPreferences ?? {}), nodeIntegration: true, contextIsolation: false } });
|
|
|
|
baseWindow.contentView = wcv;
|
|
|
|
w = Object.assign(baseWindow, { webContents: wcv.webContents });
|
|
|
|
await Promise.resolve(fn.apply(this, args));
|
|
|
|
});
|
2019-09-05 17:56:06 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
itWithOptions('should be visible when the window is initially shown by default', {}, async () => {
|
2020-10-16 01:30:41 +00:00
|
|
|
load();
|
2023-02-23 23:53:53 +00:00
|
|
|
const [, state] = await once(ipcMain, 'initial-visibility-state');
|
2019-09-05 17:56:06 +00:00
|
|
|
expect(state).to.equal('visible');
|
|
|
|
});
|
|
|
|
|
|
|
|
itWithOptions('should be visible when the window is initially shown', {
|
2019-11-01 20:37:02 +00:00
|
|
|
show: true
|
2019-09-05 17:56:06 +00:00
|
|
|
}, async () => {
|
2020-10-16 01:30:41 +00:00
|
|
|
load();
|
2023-02-23 23:53:53 +00:00
|
|
|
const [, state] = await once(ipcMain, 'initial-visibility-state');
|
2019-09-05 17:56:06 +00:00
|
|
|
expect(state).to.equal('visible');
|
|
|
|
});
|
|
|
|
|
|
|
|
itWithOptions('should be hidden when the window is initially hidden', {
|
2019-11-01 20:37:02 +00:00
|
|
|
show: false
|
2019-09-05 17:56:06 +00:00
|
|
|
}, async () => {
|
2020-10-16 01:30:41 +00:00
|
|
|
load();
|
2023-02-23 23:53:53 +00:00
|
|
|
const [, state] = await once(ipcMain, 'initial-visibility-state');
|
2019-09-05 17:56:06 +00:00
|
|
|
expect(state).to.equal('hidden');
|
|
|
|
});
|
|
|
|
|
|
|
|
itWithOptions('should be visible when the window is initially hidden but shown before the page is loaded', {
|
2019-11-01 20:37:02 +00:00
|
|
|
show: false
|
2019-09-05 17:56:06 +00:00
|
|
|
}, async () => {
|
|
|
|
w.show();
|
2020-10-16 01:30:41 +00:00
|
|
|
load();
|
2023-02-23 23:53:53 +00:00
|
|
|
const [, state] = await once(ipcMain, 'initial-visibility-state');
|
2019-09-05 17:56:06 +00:00
|
|
|
expect(state).to.equal('visible');
|
|
|
|
});
|
|
|
|
|
|
|
|
itWithOptions('should be hidden when the window is initially shown but hidden before the page is loaded', {
|
2019-11-01 20:37:02 +00:00
|
|
|
show: true
|
2019-09-05 17:56:06 +00:00
|
|
|
}, async () => {
|
|
|
|
// TODO(MarshallOfSound): Figure out if we can work around this 1 tick issue for users
|
|
|
|
if (process.platform === 'darwin') {
|
|
|
|
// Wait for a tick, the window being "shown" takes 1 tick on macOS
|
2023-02-23 23:53:53 +00:00
|
|
|
await setTimeout(10000);
|
2019-09-05 17:56:06 +00:00
|
|
|
}
|
|
|
|
w.hide();
|
2020-10-16 01:30:41 +00:00
|
|
|
load();
|
2023-02-23 23:53:53 +00:00
|
|
|
const [, state] = await once(ipcMain, 'initial-visibility-state');
|
2019-09-05 17:56:06 +00:00
|
|
|
expect(state).to.equal('hidden');
|
|
|
|
});
|
|
|
|
|
|
|
|
itWithOptions('should be toggle between visible and hidden as the window is hidden and shown', {}, async () => {
|
2020-10-16 01:30:41 +00:00
|
|
|
load();
|
2023-02-23 23:53:53 +00:00
|
|
|
const [, initialState] = await once(ipcMain, 'initial-visibility-state');
|
2020-10-16 01:30:41 +00:00
|
|
|
expect(initialState).to.equal('visible');
|
|
|
|
w.hide();
|
2023-02-23 23:53:53 +00:00
|
|
|
await once(ipcMain, 'visibility-change-hidden');
|
2020-10-16 01:30:41 +00:00
|
|
|
w.show();
|
2023-02-23 23:53:53 +00:00
|
|
|
await once(ipcMain, 'visibility-change-visible');
|
2019-09-05 17:56:06 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
itWithOptions('should become hidden when a window is minimized', {}, async () => {
|
2020-10-16 01:30:41 +00:00
|
|
|
load();
|
2023-02-23 23:53:53 +00:00
|
|
|
const [, initialState] = await once(ipcMain, 'initial-visibility-state');
|
2020-10-16 01:30:41 +00:00
|
|
|
expect(initialState).to.equal('visible');
|
|
|
|
w.minimize();
|
2023-02-23 23:53:53 +00:00
|
|
|
const p = once(ipcMain, 'visibility-change-hidden');
|
|
|
|
w.minimize();
|
|
|
|
await p;
|
2019-09-05 17:56:06 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
itWithOptions('should become visible when a window is restored', {}, async () => {
|
2020-10-16 01:30:41 +00:00
|
|
|
load();
|
2023-02-23 23:53:53 +00:00
|
|
|
const [, initialState] = await once(ipcMain, 'initial-visibility-state');
|
2020-10-16 01:30:41 +00:00
|
|
|
expect(initialState).to.equal('visible');
|
|
|
|
w.minimize();
|
2023-02-23 23:53:53 +00:00
|
|
|
await once(ipcMain, 'visibility-change-hidden');
|
2020-10-16 01:30:41 +00:00
|
|
|
w.restore();
|
2023-02-23 23:53:53 +00:00
|
|
|
await once(ipcMain, 'visibility-change-visible');
|
2019-09-05 17:56:06 +00:00
|
|
|
});
|
|
|
|
|
2023-04-04 13:48:51 +00:00
|
|
|
ifdescribe(process.platform === 'darwin')('on platforms that support occlusion detection', () => {
|
2019-09-05 17:56:06 +00:00
|
|
|
let child: cp.ChildProcess;
|
|
|
|
|
|
|
|
const makeOtherWindow = (opts: { x: number; y: number; width: number; height: number; }) => {
|
|
|
|
child = cp.spawn(process.execPath, [path.resolve(__dirname, 'fixtures', 'chromium', 'other-window.js'), `${opts.x}`, `${opts.y}`, `${opts.width}`, `${opts.height}`]);
|
2021-01-22 19:25:47 +00:00
|
|
|
return new Promise<void>(resolve => {
|
2019-09-05 17:56:06 +00:00
|
|
|
child.stdout!.on('data', (chunk) => {
|
|
|
|
if (chunk.toString().includes('__ready__')) resolve();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
|
|
|
afterEach(() => {
|
|
|
|
if (child && !child.killed) {
|
|
|
|
child.kill('SIGTERM');
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
itWithOptions('should be visible when two windows are on screen', {
|
|
|
|
x: 0,
|
|
|
|
y: 0,
|
|
|
|
width: 200,
|
2019-11-01 20:37:02 +00:00
|
|
|
height: 200
|
2019-09-05 17:56:06 +00:00
|
|
|
}, async () => {
|
|
|
|
await makeOtherWindow({
|
|
|
|
x: 200,
|
|
|
|
y: 0,
|
|
|
|
width: 200,
|
2019-11-01 20:37:02 +00:00
|
|
|
height: 200
|
2019-09-05 17:56:06 +00:00
|
|
|
});
|
2020-10-16 01:30:41 +00:00
|
|
|
load();
|
2023-02-23 23:53:53 +00:00
|
|
|
const [, state] = await once(ipcMain, 'initial-visibility-state');
|
2019-09-05 17:56:06 +00:00
|
|
|
expect(state).to.equal('visible');
|
|
|
|
});
|
|
|
|
|
|
|
|
itWithOptions('should be visible when two windows are on screen that overlap partially', {
|
|
|
|
x: 50,
|
|
|
|
y: 50,
|
|
|
|
width: 150,
|
2019-11-01 20:37:02 +00:00
|
|
|
height: 150
|
2019-09-05 17:56:06 +00:00
|
|
|
}, async () => {
|
|
|
|
await makeOtherWindow({
|
|
|
|
x: 100,
|
|
|
|
y: 0,
|
|
|
|
width: 200,
|
2019-11-01 20:37:02 +00:00
|
|
|
height: 200
|
2019-09-05 17:56:06 +00:00
|
|
|
});
|
2020-10-16 01:30:41 +00:00
|
|
|
load();
|
2023-02-23 23:53:53 +00:00
|
|
|
const [, state] = await once(ipcMain, 'initial-visibility-state');
|
2019-09-05 17:56:06 +00:00
|
|
|
expect(state).to.equal('visible');
|
|
|
|
});
|
|
|
|
|
2020-10-16 01:30:41 +00:00
|
|
|
itWithOptions('should be hidden when a second window completely occludes the current window', {
|
2019-09-05 17:56:06 +00:00
|
|
|
x: 50,
|
|
|
|
y: 50,
|
|
|
|
width: 50,
|
2019-11-01 20:37:02 +00:00
|
|
|
height: 50
|
2019-09-05 17:56:06 +00:00
|
|
|
}, async function () {
|
|
|
|
this.timeout(240000);
|
2020-10-16 01:30:41 +00:00
|
|
|
load();
|
2023-02-23 23:53:53 +00:00
|
|
|
const [, state] = await once(ipcMain, 'initial-visibility-state');
|
2020-10-16 01:30:41 +00:00
|
|
|
expect(state).to.equal('visible');
|
|
|
|
makeOtherWindow({
|
|
|
|
x: 0,
|
|
|
|
y: 0,
|
|
|
|
width: 300,
|
|
|
|
height: 300
|
2019-09-05 17:56:06 +00:00
|
|
|
});
|
2023-02-23 23:53:53 +00:00
|
|
|
await once(ipcMain, 'visibility-change-hidden');
|
2019-09-05 17:56:06 +00:00
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|