2019-11-07 00:15:55 +00:00
import { expect } from 'chai' ;
2021-09-23 11:00:11 +00:00
import { BrowserWindow , WebContents , webFrameMain , session , ipcMain , app , protocol , webContents } from 'electron/main' ;
2021-01-13 21:49:35 +00:00
import { emittedOnce } from './events-helpers' ;
2019-10-11 20:55:50 +00:00
import { closeAllWindows } from './window-helpers' ;
import * as https from 'https' ;
import * as http from 'http' ;
import * as path from 'path' ;
import * as fs from 'fs' ;
import * as url from 'url' ;
import * as ChildProcess from 'child_process' ;
import { EventEmitter } from 'events' ;
2019-10-14 16:00:34 +00:00
import { promisify } from 'util' ;
2022-08-05 00:20:56 +00:00
import { ifit , ifdescribe , defer , delay , itremote } from './spec-helpers' ;
2019-10-16 15:12:31 +00:00
import { AddressInfo } from 'net' ;
2020-05-08 04:27:55 +00:00
import { PipeTransport } from './pipe-transport' ;
2022-07-27 09:10:04 +00:00
import * as ws from 'ws' ;
2020-03-20 20:28:31 +00:00
2020-06-23 03:32:45 +00:00
const features = process . _linkedBinding ( 'electron_common_features' ) ;
2020-03-20 20:28:31 +00:00
2022-08-16 19:23:13 +00:00
const fixturesPath = path . resolve ( __dirname , 'fixtures' ) ;
2019-05-29 23:33:19 +00:00
describe ( 'reporting api' , ( ) = > {
2020-12-09 17:16:41 +00:00
// TODO(nornagon): this started failing a lot on CI. Figure out why and fix
// it.
it . skip ( 'sends a report for a deprecation' , async ( ) = > {
2019-11-01 20:37:02 +00:00
const reports = new EventEmitter ( ) ;
2019-05-29 23:33:19 +00:00
// The Reporting API only works on https with valid certs. To dodge having
// to set up a trusted certificate, hack the validator.
session . defaultSession . setCertificateVerifyProc ( ( req , cb ) = > {
cb ( 0 ) ;
} ) ;
const certPath = path . join ( fixturesPath , 'certificates' ) ;
const options = {
key : fs.readFileSync ( path . join ( certPath , 'server.key' ) ) ,
cert : fs.readFileSync ( path . join ( certPath , 'server.pem' ) ) ,
ca : [
fs . readFileSync ( path . join ( certPath , 'rootCA.pem' ) ) ,
fs . readFileSync ( path . join ( certPath , 'intermediateCA.pem' ) )
] ,
requestCert : true ,
rejectUnauthorized : false
} ;
const server = https . createServer ( options , ( req , res ) = > {
if ( req . url === '/report' ) {
let data = '' ;
2019-11-01 20:37:02 +00:00
req . on ( 'data' , ( d ) = > { data += d . toString ( 'utf-8' ) ; } ) ;
2019-05-29 23:33:19 +00:00
req . on ( 'end' , ( ) = > {
reports . emit ( 'report' , JSON . parse ( data ) ) ;
} ) ;
}
res . setHeader ( 'Report-To' , JSON . stringify ( {
group : 'default' ,
max_age : 120 ,
2020-03-20 15:12:18 +00:00
endpoints : [ { url : ` https://localhost: ${ ( server . address ( ) as any ) . port } /report ` } ]
2019-05-29 23:33:19 +00:00
} ) ) ;
res . setHeader ( 'Content-Type' , 'text/html' ) ;
// using the deprecated `webkitRequestAnimationFrame` will trigger a
// "deprecation" report.
res . end ( '<script>webkitRequestAnimationFrame(() => {})</script>' ) ;
} ) ;
2021-01-22 19:25:47 +00:00
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
2019-05-29 23:33:19 +00:00
const bw = new BrowserWindow ( {
2019-11-01 20:37:02 +00:00
show : false
2019-05-29 23:33:19 +00:00
} ) ;
try {
const reportGenerated = emittedOnce ( reports , 'report' ) ;
const url = ` https://localhost: ${ ( server . address ( ) as any ) . port } /a ` ;
await bw . loadURL ( url ) ;
const [ report ] = await reportGenerated ;
expect ( report ) . to . be . an ( 'array' ) ;
expect ( report [ 0 ] . type ) . to . equal ( 'deprecation' ) ;
expect ( report [ 0 ] . url ) . to . equal ( url ) ;
expect ( report [ 0 ] . body . id ) . to . equal ( 'PrefixedRequestAnimationFrame' ) ;
} finally {
bw . destroy ( ) ;
server . close ( ) ;
}
} ) ;
} ) ;
2019-06-11 23:35:58 +00:00
describe ( 'window.postMessage' , ( ) = > {
afterEach ( async ( ) = > {
await closeAllWindows ( ) ;
} ) ;
2022-01-06 17:28:03 +00:00
it ( 'sets the source and origin correctly' , async ( ) = > {
const w = new BrowserWindow ( { show : false , webPreferences : { nodeIntegration : true , contextIsolation : false } } ) ;
w . loadURL ( ` file:// ${ fixturesPath } /pages/window-open-postMessage-driver.html ` ) ;
const [ , message ] = await emittedOnce ( ipcMain , 'complete' ) ;
expect ( message . data ) . to . equal ( 'testing' ) ;
expect ( message . origin ) . to . equal ( 'file://' ) ;
expect ( message . sourceEqualsOpener ) . to . equal ( true ) ;
expect ( message . eventOrigin ) . to . equal ( 'file://' ) ;
} ) ;
2019-06-11 23:35:58 +00:00
} ) ;
2019-06-15 07:15:15 +00:00
describe ( 'focus handling' , ( ) = > {
let webviewContents : WebContents = null as unknown as WebContents ;
let w : BrowserWindow = null as unknown as BrowserWindow ;
beforeEach ( async ( ) = > {
w = new BrowserWindow ( {
show : true ,
webPreferences : {
nodeIntegration : true ,
2021-03-01 21:52:29 +00:00
webviewTag : true ,
contextIsolation : false
2019-06-15 07:15:15 +00:00
}
} ) ;
const webviewReady = emittedOnce ( w . webContents , 'did-attach-webview' ) ;
await w . loadFile ( path . join ( fixturesPath , 'pages' , 'tab-focus-loop-elements.html' ) ) ;
const [ , wvContents ] = await webviewReady ;
webviewContents = wvContents ;
await emittedOnce ( webviewContents , 'did-finish-load' ) ;
w . focus ( ) ;
} ) ;
afterEach ( ( ) = > {
webviewContents = null as unknown as WebContents ;
w . destroy ( ) ;
w = null as unknown as BrowserWindow ;
} ) ;
const expectFocusChange = async ( ) = > {
const [ , focusedElementId ] = await emittedOnce ( ipcMain , 'focus-changed' ) ;
return focusedElementId ;
} ;
describe ( 'a TAB press' , ( ) = > {
const tabPressEvent : any = {
type : 'keyDown' ,
keyCode : 'Tab'
} ;
it ( 'moves focus to the next focusable item' , async ( ) = > {
let focusChange = expectFocusChange ( ) ;
w . webContents . sendInputEvent ( tabPressEvent ) ;
let focusedElementId = await focusChange ;
expect ( focusedElementId ) . to . equal ( 'BUTTON-element-1' , ` should start focused in element-1, it's instead in ${ focusedElementId } ` ) ;
2020-03-20 20:28:31 +00:00
2019-06-15 07:15:15 +00:00
focusChange = expectFocusChange ( ) ;
w . webContents . sendInputEvent ( tabPressEvent ) ;
focusedElementId = await focusChange ;
expect ( focusedElementId ) . to . equal ( 'BUTTON-element-2' , ` focus should've moved to element-2, it's instead in ${ focusedElementId } ` ) ;
2020-03-20 20:28:31 +00:00
2019-06-15 07:15:15 +00:00
focusChange = expectFocusChange ( ) ;
w . webContents . sendInputEvent ( tabPressEvent ) ;
focusedElementId = await focusChange ;
expect ( focusedElementId ) . to . equal ( 'BUTTON-wv-element-1' , ` focus should've moved to the webview's element-1, it's instead in ${ focusedElementId } ` ) ;
2020-03-20 20:28:31 +00:00
2019-06-15 07:15:15 +00:00
focusChange = expectFocusChange ( ) ;
webviewContents . sendInputEvent ( tabPressEvent ) ;
focusedElementId = await focusChange ;
expect ( focusedElementId ) . to . equal ( 'BUTTON-wv-element-2' , ` focus should've moved to the webview's element-2, it's instead in ${ focusedElementId } ` ) ;
2020-03-20 20:28:31 +00:00
2019-06-15 07:15:15 +00:00
focusChange = expectFocusChange ( ) ;
webviewContents . sendInputEvent ( tabPressEvent ) ;
focusedElementId = await focusChange ;
expect ( focusedElementId ) . to . equal ( 'BUTTON-element-3' , ` focus should've moved to element-3, it's instead in ${ focusedElementId } ` ) ;
2020-03-20 20:28:31 +00:00
2019-06-15 07:15:15 +00:00
focusChange = expectFocusChange ( ) ;
w . webContents . sendInputEvent ( tabPressEvent ) ;
focusedElementId = await focusChange ;
expect ( focusedElementId ) . to . equal ( 'BUTTON-element-1' , ` focus should've looped back to element-1, it's instead in ${ focusedElementId } ` ) ;
} ) ;
} ) ;
describe ( 'a SHIFT + TAB press' , ( ) = > {
const shiftTabPressEvent : any = {
type : 'keyDown' ,
modifiers : [ 'Shift' ] ,
keyCode : 'Tab'
} ;
it ( 'moves focus to the previous focusable item' , async ( ) = > {
let focusChange = expectFocusChange ( ) ;
w . webContents . sendInputEvent ( shiftTabPressEvent ) ;
let focusedElementId = await focusChange ;
expect ( focusedElementId ) . to . equal ( 'BUTTON-element-3' , ` should start focused in element-3, it's instead in ${ focusedElementId } ` ) ;
2020-03-20 20:28:31 +00:00
2019-06-15 07:15:15 +00:00
focusChange = expectFocusChange ( ) ;
w . webContents . sendInputEvent ( shiftTabPressEvent ) ;
focusedElementId = await focusChange ;
expect ( focusedElementId ) . to . equal ( 'BUTTON-wv-element-2' , ` focus should've moved to the webview's element-2, it's instead in ${ focusedElementId } ` ) ;
2020-03-20 20:28:31 +00:00
2019-06-15 07:15:15 +00:00
focusChange = expectFocusChange ( ) ;
webviewContents . sendInputEvent ( shiftTabPressEvent ) ;
focusedElementId = await focusChange ;
expect ( focusedElementId ) . to . equal ( 'BUTTON-wv-element-1' , ` focus should've moved to the webview's element-1, it's instead in ${ focusedElementId } ` ) ;
2020-03-20 20:28:31 +00:00
2019-06-15 07:15:15 +00:00
focusChange = expectFocusChange ( ) ;
webviewContents . sendInputEvent ( shiftTabPressEvent ) ;
focusedElementId = await focusChange ;
expect ( focusedElementId ) . to . equal ( 'BUTTON-element-2' , ` focus should've moved to element-2, it's instead in ${ focusedElementId } ` ) ;
2020-03-20 20:28:31 +00:00
2019-06-15 07:15:15 +00:00
focusChange = expectFocusChange ( ) ;
w . webContents . sendInputEvent ( shiftTabPressEvent ) ;
focusedElementId = await focusChange ;
expect ( focusedElementId ) . to . equal ( 'BUTTON-element-1' , ` focus should've moved to element-1, it's instead in ${ focusedElementId } ` ) ;
2020-03-20 20:28:31 +00:00
2019-06-15 07:15:15 +00:00
focusChange = expectFocusChange ( ) ;
w . webContents . sendInputEvent ( shiftTabPressEvent ) ;
focusedElementId = await focusChange ;
expect ( focusedElementId ) . to . equal ( 'BUTTON-element-3' , ` focus should've looped back to element-3, it's instead in ${ focusedElementId } ` ) ;
} ) ;
} ) ;
} ) ;
2019-08-02 23:56:46 +00:00
describe ( 'web security' , ( ) = > {
afterEach ( closeAllWindows ) ;
let server : http.Server ;
let serverUrl : string ;
before ( async ( ) = > {
server = http . createServer ( ( req , res ) = > {
res . setHeader ( 'Content-Type' , 'text/html' ) ;
res . end ( '<body>' ) ;
} ) ;
2021-01-22 19:25:47 +00:00
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
2019-08-02 23:56:46 +00:00
serverUrl = ` http://localhost: ${ ( server . address ( ) as any ) . port } ` ;
} ) ;
after ( ( ) = > {
server . close ( ) ;
} ) ;
it ( 'engages CORB when web security is not disabled' , async ( ) = > {
2021-03-01 21:52:29 +00:00
const w = new BrowserWindow ( { show : false , webPreferences : { webSecurity : true , nodeIntegration : true , contextIsolation : false } } ) ;
2019-08-02 23:56:46 +00:00
const p = emittedOnce ( ipcMain , 'success' ) ;
await w . loadURL ( ` data:text/html,<script>
const s = document . createElement ( 'script' )
s . src = "${serverUrl}"
// The script will load successfully but its body will be emptied out
// by CORB, so we don't expect a syntax error.
s . onload = ( ) = > { require ( 'electron' ) . ipcRenderer . send ( 'success' ) }
document . documentElement . appendChild ( s )
< / script > ` );
await p ;
} ) ;
2022-04-12 10:00:42 +00:00
it ( 'bypasses CORB when web security is disabled' , async ( ) = > {
2021-03-01 21:52:29 +00:00
const w = new BrowserWindow ( { show : false , webPreferences : { webSecurity : false , nodeIntegration : true , contextIsolation : false } } ) ;
2019-08-02 23:56:46 +00:00
const p = emittedOnce ( ipcMain , 'success' ) ;
await w . loadURL ( ` data:text/html,
< script >
window . onerror = ( e ) = > { require ( 'electron' ) . ipcRenderer . send ( 'success' , e ) }
< / script >
< script src = "${serverUrl}" > < / script > ` );
await p ;
} ) ;
2020-08-28 01:43:08 +00:00
2020-09-16 21:55:53 +00:00
it ( 'engages CORS when web security is not disabled' , async ( ) = > {
2021-03-01 21:52:29 +00:00
const w = new BrowserWindow ( { show : false , webPreferences : { webSecurity : true , nodeIntegration : true , contextIsolation : false } } ) ;
2020-09-16 21:55:53 +00:00
const p = emittedOnce ( ipcMain , 'response' ) ;
await w . loadURL ( ` data:text/html,<script>
( async function ( ) {
try {
await fetch ( '${serverUrl}' ) ;
require ( 'electron' ) . ipcRenderer . send ( 'response' , 'passed' ) ;
} catch {
require ( 'electron' ) . ipcRenderer . send ( 'response' , 'failed' ) ;
}
} ) ( ) ;
< / script > ` );
const [ , response ] = await p ;
expect ( response ) . to . equal ( 'failed' ) ;
} ) ;
it ( 'bypasses CORS when web security is disabled' , async ( ) = > {
2021-03-01 21:52:29 +00:00
const w = new BrowserWindow ( { show : false , webPreferences : { webSecurity : false , nodeIntegration : true , contextIsolation : false } } ) ;
2020-09-16 21:55:53 +00:00
const p = emittedOnce ( ipcMain , 'response' ) ;
await w . loadURL ( ` data:text/html,<script>
( async function ( ) {
try {
await fetch ( '${serverUrl}' ) ;
require ( 'electron' ) . ipcRenderer . send ( 'response' , 'passed' ) ;
} catch {
require ( 'electron' ) . ipcRenderer . send ( 'response' , 'failed' ) ;
}
} ) ( ) ;
< / script > ` );
const [ , response ] = await p ;
expect ( response ) . to . equal ( 'passed' ) ;
} ) ;
2021-04-07 01:46:23 +00:00
describe ( 'accessing file://' , ( ) = > {
async function loadFile ( w : BrowserWindow ) {
const thisFile = url . format ( {
pathname : __filename.replace ( /\\/g , '/' ) ,
protocol : 'file' ,
slashes : true
} ) ;
await w . loadURL ( ` data:text/html,<script>
function loadFile() {
return new Promise ( ( resolve ) = > {
fetch ( '${thisFile}' ) . then (
( ) = > resolve ( 'loaded' ) ,
( ) = > resolve ( 'failed' )
)
} ) ;
}
< / script > ` );
return await w . webContents . executeJavaScript ( 'loadFile()' ) ;
}
it ( 'is forbidden when web security is enabled' , async ( ) = > {
const w = new BrowserWindow ( { show : false , webPreferences : { webSecurity : true } } ) ;
const result = await loadFile ( w ) ;
expect ( result ) . to . equal ( 'failed' ) ;
} ) ;
it ( 'is allowed when web security is disabled' , async ( ) = > {
const w = new BrowserWindow ( { show : false , webPreferences : { webSecurity : false } } ) ;
const result = await loadFile ( w ) ;
expect ( result ) . to . equal ( 'loaded' ) ;
} ) ;
} ) ;
2021-04-07 20:04:50 +00:00
describe ( 'wasm-eval csp' , ( ) = > {
async function loadWasm ( csp : string ) {
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
sandbox : true ,
enableBlinkFeatures : 'WebAssemblyCSP'
}
} ) ;
await w . loadURL ( ` data:text/html,<head>
< meta http-equiv = "Content-Security-Policy" content = "default-src 'self'; script-src 'self' 'unsafe-inline' ${csp}" >
< / head >
< script >
function loadWasm() {
const wasmBin = new Uint8Array ( [ 0 , 97 , 115 , 109 , 1 , 0 , 0 , 0 ] )
return new Promise ( ( resolve ) = > {
WebAssembly . instantiate ( wasmBin ) . then ( ( ) = > {
resolve ( 'loaded' )
} ) . catch ( ( error ) = > {
resolve ( error . message )
} )
} ) ;
}
< / script > ` );
return await w . webContents . executeJavaScript ( 'loadWasm()' ) ;
}
it ( 'wasm codegen is disallowed by default' , async ( ) = > {
const r = await loadWasm ( '' ) ;
2022-07-20 11:03:34 +00:00
expect ( r ) . to . equal ( 'WebAssembly.instantiate(): Refused to compile or instantiate WebAssembly module because \'unsafe-eval\' is not an allowed source of script in the following Content Security Policy directive: "script-src \'self\' \'unsafe-inline\'"' ) ;
2021-04-07 20:04:50 +00:00
} ) ;
2021-06-22 19:17:16 +00:00
it ( 'wasm codegen is allowed with "wasm-unsafe-eval" csp' , async ( ) = > {
const r = await loadWasm ( "'wasm-unsafe-eval'" ) ;
2021-04-07 20:04:50 +00:00
expect ( r ) . to . equal ( 'loaded' ) ;
} ) ;
} ) ;
2022-12-14 18:05:34 +00:00
describe ( 'csp in sandbox: false' , ( ) = > {
it ( 'is correctly applied' , async ( ) = > {
const w = new BrowserWindow ( {
show : false ,
webPreferences : { sandbox : false }
} ) ;
w . loadURL ( ` data:text/html,<head>
< meta http-equiv = "Content-Security-Policy" content = "default-src 'self'; script-src 'self' 'unsafe-inline'" >
< / head >
< script >
try {
// We use console.log here because it is easier than making a
// preload script, and the behavior under test changes when
// contextIsolation: false
console . log ( eval ( 'failure' ) )
} catch ( e ) {
console . log ( 'success' )
}
< / script > ` );
const [ , , message ] = await emittedOnce ( w . webContents , 'console-message' ) ;
expect ( message ) . to . equal ( 'success' ) ;
} ) ;
} ) ;
2020-08-28 01:43:08 +00:00
it ( 'does not crash when multiple WebContent are created with web security disabled' , ( ) = > {
2020-09-15 18:48:12 +00:00
const options = { show : false , webPreferences : { webSecurity : false } } ;
2020-08-28 01:43:08 +00:00
const w1 = new BrowserWindow ( options ) ;
w1 . loadURL ( serverUrl ) ;
const w2 = new BrowserWindow ( options ) ;
w2 . loadURL ( serverUrl ) ;
} ) ;
2019-08-02 23:56:46 +00:00
} ) ;
2019-10-11 20:55:50 +00:00
2021-04-09 07:09:17 +00:00
describe ( 'command line switches' , ( ) = > {
2020-05-08 23:13:32 +00:00
let appProcess : ChildProcess.ChildProcessWithoutNullStreams | undefined ;
afterEach ( ( ) = > {
if ( appProcess && ! appProcess . killed ) {
appProcess . kill ( ) ;
appProcess = undefined ;
}
} ) ;
2019-10-11 20:55:50 +00:00
describe ( '--lang switch' , ( ) = > {
const currentLocale = app . getLocale ( ) ;
2022-09-23 18:50:46 +00:00
const currentSystemLocale = app . getSystemLocale ( ) ;
2022-11-09 15:50:43 +00:00
const currentPreferredLanguages = JSON . stringify ( app . getPreferredSystemLanguages ( ) ) ;
2020-11-18 02:13:01 +00:00
const testLocale = async ( locale : string , result : string , printEnv : boolean = false ) = > {
2019-10-11 20:55:50 +00:00
const appPath = path . join ( fixturesPath , 'api' , 'locale-check' ) ;
2020-11-18 02:13:01 +00:00
const args = [ appPath , ` --set-lang= ${ locale } ` ] ;
if ( printEnv ) {
args . push ( '--print-env' ) ;
}
appProcess = ChildProcess . spawn ( process . execPath , args ) ;
2019-10-11 20:55:50 +00:00
2020-06-30 22:10:36 +00:00
let output = '' ;
2019-10-11 20:55:50 +00:00
appProcess . stdout . on ( 'data' , ( data ) = > { output += data ; } ) ;
2021-03-08 16:23:55 +00:00
let stderr = '' ;
appProcess . stderr . on ( 'data' , ( data ) = > { stderr += data ; } ) ;
const [ code , signal ] = await emittedOnce ( appProcess , 'exit' ) ;
if ( code !== 0 ) {
throw new Error ( ` Process exited with code " ${ code } " signal " ${ signal } " output " ${ output } " stderr " ${ stderr } " ` ) ;
}
2020-06-30 22:10:36 +00:00
output = output . replace ( /(\r\n|\n|\r)/gm , '' ) ;
expect ( output ) . to . equal ( result ) ;
2019-10-11 20:55:50 +00:00
} ;
2022-11-09 15:50:43 +00:00
it ( 'should set the locale' , async ( ) = > testLocale ( 'fr' , ` fr| ${ currentSystemLocale } | ${ currentPreferredLanguages } ` ) ) ;
it ( 'should set the locale with country code' , async ( ) = > testLocale ( 'zh-CN' , ` zh-CN| ${ currentSystemLocale } | ${ currentPreferredLanguages } ` ) ) ;
it ( 'should not set an invalid locale' , async ( ) = > testLocale ( 'asdfkl' , ` ${ currentLocale } | ${ currentSystemLocale } | ${ currentPreferredLanguages } ` ) ) ;
2020-11-18 02:13:01 +00:00
const lcAll = String ( process . env . LC_ALL ) ;
ifit ( process . platform === 'linux' ) ( 'current process has a valid LC_ALL env' , async ( ) = > {
// The LC_ALL env should not be set to DOM locale string.
expect ( lcAll ) . to . not . equal ( app . getLocale ( ) ) ;
} ) ;
2021-03-10 18:04:57 +00:00
ifit ( process . platform === 'linux' ) ( 'should not change LC_ALL' , async ( ) = > testLocale ( 'fr' , lcAll , true ) ) ;
2020-11-18 02:13:01 +00:00
ifit ( process . platform === 'linux' ) ( 'should not change LC_ALL when setting invalid locale' , async ( ) = > testLocale ( 'asdfkl' , lcAll , true ) ) ;
ifit ( process . platform === 'linux' ) ( 'should not change LC_ALL when --lang is not set' , async ( ) = > testLocale ( '' , lcAll , true ) ) ;
2019-10-11 20:55:50 +00:00
} ) ;
2021-03-16 21:02:47 +00:00
describe ( '--remote-debugging-pipe switch' , ( ) = > {
2020-05-08 04:27:55 +00:00
it ( 'should expose CDP via pipe' , async ( ) = > {
const electronPath = process . execPath ;
2020-05-08 23:13:32 +00:00
appProcess = ChildProcess . spawn ( electronPath , [ '--remote-debugging-pipe' ] , {
2021-02-23 00:16:17 +00:00
stdio : [ 'inherit' , 'inherit' , 'inherit' , 'pipe' , 'pipe' ]
} ) as ChildProcess . ChildProcessWithoutNullStreams ;
2020-05-08 04:27:55 +00:00
const stdio = appProcess . stdio as unknown as [ NodeJS . ReadableStream , NodeJS . WritableStream , NodeJS . WritableStream , NodeJS . WritableStream , NodeJS . ReadableStream ] ;
const pipe = new PipeTransport ( stdio [ 3 ] , stdio [ 4 ] ) ;
const versionPromise = new Promise ( resolve = > { pipe . onmessage = resolve ; } ) ;
pipe . send ( { id : 1 , method : 'Browser.getVersion' , params : { } } ) ;
const message = ( await versionPromise ) as any ;
expect ( message . id ) . to . equal ( 1 ) ;
expect ( message . result . product ) . to . contain ( 'Chrome' ) ;
expect ( message . result . userAgent ) . to . contain ( 'Electron' ) ;
} ) ;
it ( 'should override --remote-debugging-port switch' , async ( ) = > {
const electronPath = process . execPath ;
2020-05-08 23:13:32 +00:00
appProcess = ChildProcess . spawn ( electronPath , [ '--remote-debugging-pipe' , '--remote-debugging-port=0' ] , {
2021-02-23 00:16:17 +00:00
stdio : [ 'inherit' , 'inherit' , 'pipe' , 'pipe' , 'pipe' ]
} ) as ChildProcess . ChildProcessWithoutNullStreams ;
2020-05-08 04:27:55 +00:00
let stderr = '' ;
2020-05-08 23:13:32 +00:00
appProcess . stderr . on ( 'data' , ( data : string ) = > { stderr += data ; } ) ;
2020-05-08 04:27:55 +00:00
const stdio = appProcess . stdio as unknown as [ NodeJS . ReadableStream , NodeJS . WritableStream , NodeJS . WritableStream , NodeJS . WritableStream , NodeJS . ReadableStream ] ;
const pipe = new PipeTransport ( stdio [ 3 ] , stdio [ 4 ] ) ;
const versionPromise = new Promise ( resolve = > { pipe . onmessage = resolve ; } ) ;
pipe . send ( { id : 1 , method : 'Browser.getVersion' , params : { } } ) ;
const message = ( await versionPromise ) as any ;
expect ( message . id ) . to . equal ( 1 ) ;
expect ( stderr ) . to . not . include ( 'DevTools listening on' ) ;
2020-05-08 23:13:32 +00:00
} ) ;
it ( 'should shut down Electron upon Browser.close CDP command' , async ( ) = > {
const electronPath = process . execPath ;
appProcess = ChildProcess . spawn ( electronPath , [ '--remote-debugging-pipe' ] , {
2021-02-23 00:16:17 +00:00
stdio : [ 'inherit' , 'inherit' , 'inherit' , 'pipe' , 'pipe' ]
} ) as ChildProcess . ChildProcessWithoutNullStreams ;
2020-05-08 23:13:32 +00:00
const stdio = appProcess . stdio as unknown as [ NodeJS . ReadableStream , NodeJS . WritableStream , NodeJS . WritableStream , NodeJS . WritableStream , NodeJS . ReadableStream ] ;
const pipe = new PipeTransport ( stdio [ 3 ] , stdio [ 4 ] ) ;
pipe . send ( { id : 1 , method : 'Browser.close' , params : { } } ) ;
await new Promise ( resolve = > { appProcess ! . on ( 'exit' , resolve ) ; } ) ;
2020-05-08 04:27:55 +00:00
} ) ;
} ) ;
2021-03-16 21:02:47 +00:00
describe ( '--remote-debugging-port switch' , ( ) = > {
2019-10-11 20:55:50 +00:00
it ( 'should display the discovery page' , ( done ) = > {
const electronPath = process . execPath ;
let output = '' ;
2020-05-08 23:13:32 +00:00
appProcess = ChildProcess . spawn ( electronPath , [ '--remote-debugging-port=' ] ) ;
2021-02-23 00:16:17 +00:00
appProcess . stdout . on ( 'data' , ( data ) = > {
console . log ( data ) ;
} ) ;
2019-10-11 20:55:50 +00:00
appProcess . stderr . on ( 'data' , ( data ) = > {
2021-02-23 00:16:17 +00:00
console . log ( data ) ;
2019-10-11 20:55:50 +00:00
output += data ;
const m = /DevTools listening on ws:\/\/127.0.0.1:(\d+)\// . exec ( output ) ;
if ( m ) {
2020-05-08 23:13:32 +00:00
appProcess ! . stderr . removeAllListeners ( 'data' ) ;
2019-10-11 20:55:50 +00:00
const port = m [ 1 ] ;
http . get ( ` http://127.0.0.1: ${ port } ` , ( res ) = > {
2020-06-30 22:10:36 +00:00
try {
expect ( res . statusCode ) . to . eql ( 200 ) ;
expect ( parseInt ( res . headers [ 'content-length' ] ! ) ) . to . be . greaterThan ( 0 ) ;
done ( ) ;
} catch ( e ) {
done ( e ) ;
} finally {
res . destroy ( ) ;
}
2019-10-11 20:55:50 +00:00
} ) ;
}
} ) ;
} ) ;
} ) ;
} ) ;
describe ( 'chromium features' , ( ) = > {
afterEach ( closeAllWindows ) ;
describe ( 'accessing key names also used as Node.js module names' , ( ) = > {
it ( 'does not crash' , ( done ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . webContents . once ( 'did-finish-load' , ( ) = > { done ( ) ; } ) ;
w . webContents . once ( 'crashed' , ( ) = > done ( new Error ( 'WebContents crashed.' ) ) ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'external-string.html' ) ) ;
} ) ;
} ) ;
2022-07-07 19:14:53 +00:00
describe ( 'first party sets' , ( ) = > {
const fps = [
'https://fps-member1.glitch.me' ,
'https://fps-member2.glitch.me' ,
'https://fps-member3.glitch.me'
] ;
it ( 'loads first party sets' , async ( ) = > {
const appPath = path . join ( fixturesPath , 'api' , 'first-party-sets' , 'base' ) ;
const fpsProcess = ChildProcess . spawn ( process . execPath , [ appPath ] ) ;
let output = '' ;
fpsProcess . stdout . on ( 'data' , data = > { output += data ; } ) ;
await emittedOnce ( fpsProcess , 'exit' ) ;
expect ( output ) . to . include ( fps . join ( ',' ) ) ;
} ) ;
it ( 'loads sets from the command line' , async ( ) = > {
const appPath = path . join ( fixturesPath , 'api' , 'first-party-sets' , 'command-line' ) ;
const args = [ appPath , ` --use-first-party-set= ${ fps } ` ] ;
const fpsProcess = ChildProcess . spawn ( process . execPath , args ) ;
let output = '' ;
fpsProcess . stdout . on ( 'data' , data = > { output += data ; } ) ;
await emittedOnce ( fpsProcess , 'exit' ) ;
expect ( output ) . to . include ( fps . join ( ',' ) ) ;
} ) ;
} ) ;
2019-10-11 20:55:50 +00:00
describe ( 'loading jquery' , ( ) = > {
it ( 'does not crash' , ( done ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . webContents . once ( 'did-finish-load' , ( ) = > { done ( ) ; } ) ;
w . webContents . once ( 'crashed' , ( ) = > done ( new Error ( 'WebContents crashed.' ) ) ) ;
2020-01-09 19:50:56 +00:00
w . loadFile ( path . join ( __dirname , 'fixtures' , 'pages' , 'jquery.html' ) ) ;
2019-10-11 20:55:50 +00:00
} ) ;
} ) ;
describe ( 'navigator.languages' , ( ) = > {
it ( 'should return the system locale only' , async ( ) = > {
const appLocale = app . getLocale ( ) ;
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( 'about:blank' ) ;
2020-03-20 15:12:18 +00:00
const languages = await w . webContents . executeJavaScript ( 'navigator.languages' ) ;
2020-05-04 17:49:29 +00:00
expect ( languages . length ) . to . be . greaterThan ( 0 ) ;
expect ( languages ) . to . contain ( appLocale ) ;
2019-10-11 20:55:50 +00:00
} ) ;
} ) ;
describe ( 'navigator.serviceWorker' , ( ) = > {
it ( 'should register for file scheme' , ( done ) = > {
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
nodeIntegration : true ,
2021-03-01 21:52:29 +00:00
partition : 'sw-file-scheme-spec' ,
contextIsolation : false
2019-10-11 20:55:50 +00:00
}
} ) ;
w . webContents . on ( 'ipc-message' , ( event , channel , message ) = > {
if ( channel === 'reload' ) {
w . webContents . reload ( ) ;
} else if ( channel === 'error' ) {
done ( message ) ;
} else if ( channel === 'response' ) {
expect ( message ) . to . equal ( 'Hello from serviceWorker!' ) ;
session . fromPartition ( 'sw-file-scheme-spec' ) . clearStorageData ( {
storages : [ 'serviceworkers' ]
} ) . then ( ( ) = > done ( ) ) ;
}
} ) ;
w . webContents . on ( 'crashed' , ( ) = > done ( new Error ( 'WebContents crashed.' ) ) ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'service-worker' , 'index.html' ) ) ;
} ) ;
it ( 'should register for intercepted file scheme' , ( done ) = > {
const customSession = session . fromPartition ( 'intercept-file' ) ;
customSession . protocol . interceptBufferProtocol ( 'file' , ( request , callback ) = > {
let file = url . parse ( request . url ) . pathname ! ;
if ( file [ 0 ] === '/' && process . platform === 'win32' ) file = file . slice ( 1 ) ;
const content = fs . readFileSync ( path . normalize ( file ) ) ;
const ext = path . extname ( file ) ;
let type = 'text/html' ;
if ( ext === '.js' ) type = 'application/javascript' ;
callback ( { data : content , mimeType : type } as any ) ;
} ) ;
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
nodeIntegration : true ,
2021-03-01 21:52:29 +00:00
session : customSession ,
contextIsolation : false
2019-10-11 20:55:50 +00:00
}
} ) ;
w . webContents . on ( 'ipc-message' , ( event , channel , message ) = > {
if ( channel === 'reload' ) {
w . webContents . reload ( ) ;
} else if ( channel === 'error' ) {
done ( ` unexpected error : ${ message } ` ) ;
} else if ( channel === 'response' ) {
expect ( message ) . to . equal ( 'Hello from serviceWorker!' ) ;
customSession . clearStorageData ( {
storages : [ 'serviceworkers' ]
} ) . then ( ( ) = > {
2020-06-02 16:46:18 +00:00
customSession . protocol . uninterceptProtocol ( 'file' ) ;
done ( ) ;
2019-10-11 20:55:50 +00:00
} ) ;
}
} ) ;
w . webContents . on ( 'crashed' , ( ) = > done ( new Error ( 'WebContents crashed.' ) ) ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'service-worker' , 'index.html' ) ) ;
} ) ;
2020-07-28 01:48:37 +00:00
2021-06-01 01:45:23 +00:00
it ( 'should register for custom scheme' , ( done ) = > {
const customSession = session . fromPartition ( 'custom-scheme' ) ;
customSession . protocol . registerFileProtocol ( serviceWorkerScheme , ( request , callback ) = > {
let file = url . parse ( request . url ) . pathname ! ;
if ( file [ 0 ] === '/' && process . platform === 'win32' ) file = file . slice ( 1 ) ;
callback ( { path : path.normalize ( file ) } as any ) ;
} ) ;
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
nodeIntegration : true ,
session : customSession ,
contextIsolation : false
}
} ) ;
w . webContents . on ( 'ipc-message' , ( event , channel , message ) = > {
if ( channel === 'reload' ) {
w . webContents . reload ( ) ;
} else if ( channel === 'error' ) {
done ( ` unexpected error : ${ message } ` ) ;
} else if ( channel === 'response' ) {
expect ( message ) . to . equal ( 'Hello from serviceWorker!' ) ;
customSession . clearStorageData ( {
storages : [ 'serviceworkers' ]
} ) . then ( ( ) = > {
customSession . protocol . uninterceptProtocol ( serviceWorkerScheme ) ;
done ( ) ;
} ) ;
}
} ) ;
w . webContents . on ( 'crashed' , ( ) = > done ( new Error ( 'WebContents crashed.' ) ) ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'service-worker' , 'custom-scheme-index.html' ) ) ;
} ) ;
2022-10-12 14:36:24 +00:00
it ( 'should not allow nodeIntegrationInWorker' , async ( ) = > {
2020-07-28 01:48:37 +00:00
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
nodeIntegration : true ,
2020-08-18 16:31:24 +00:00
nodeIntegrationInWorker : true ,
2021-03-01 21:52:29 +00:00
partition : 'sw-file-scheme-worker-spec' ,
contextIsolation : false
2020-07-28 01:48:37 +00:00
}
} ) ;
2022-10-12 14:36:24 +00:00
await w . loadURL ( ` file:// ${ fixturesPath } /pages/service-worker/empty.html ` ) ;
2020-07-28 01:48:37 +00:00
2022-10-12 14:36:24 +00:00
const data = await w . webContents . executeJavaScript ( `
navigator . serviceWorker . register ( 'worker-no-node.js' , {
scope : './'
} ) . then ( ( ) = > navigator . serviceWorker . ready )
new Promise ( ( resolve ) = > {
navigator . serviceWorker . onmessage = event = > resolve ( event . data ) ;
} ) ;
` );
expect ( data ) . to . equal ( 'undefined undefined undefined undefined' ) ;
2020-07-28 01:48:37 +00:00
} ) ;
2019-10-11 20:55:50 +00:00
} ) ;
2022-07-27 09:10:04 +00:00
ifdescribe ( features . isFakeLocationProviderEnabled ( ) ) ( 'navigator.geolocation' , ( ) = > {
2020-07-01 19:14:38 +00:00
it ( 'returns error when permission is denied' , async ( ) = > {
2019-10-11 20:55:50 +00:00
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
nodeIntegration : true ,
2021-03-01 21:52:29 +00:00
partition : 'geolocation-spec' ,
contextIsolation : false
2019-10-11 20:55:50 +00:00
}
} ) ;
2020-07-01 19:14:38 +00:00
const message = emittedOnce ( w . webContents , 'ipc-message' ) ;
2019-10-11 20:55:50 +00:00
w . webContents . session . setPermissionRequestHandler ( ( wc , permission , callback ) = > {
if ( permission === 'geolocation' ) {
callback ( false ) ;
} else {
callback ( true ) ;
}
} ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'geolocation' , 'index.html' ) ) ;
2020-07-01 19:14:38 +00:00
const [ , channel ] = await message ;
expect ( channel ) . to . equal ( 'success' , 'unexpected response from geolocation api' ) ;
2019-10-11 20:55:50 +00:00
} ) ;
2022-07-27 09:10:04 +00:00
it ( 'returns position when permission is granted' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( ` file:// ${ fixturesPath } /pages/blank.html ` ) ;
const position = await w . webContents . executeJavaScript ( ` new Promise((resolve, reject) =>
navigator . geolocation . getCurrentPosition (
x = > resolve ( { coords : x.coords , timestamp : x.timestamp } ) ,
reject ) ) ` );
expect ( position ) . to . have . property ( 'coords' ) ;
expect ( position ) . to . have . property ( 'timestamp' ) ;
} ) ;
2019-10-11 20:55:50 +00:00
} ) ;
2021-07-04 23:48:46 +00:00
describe ( 'web workers' , ( ) = > {
let appProcess : ChildProcess.ChildProcessWithoutNullStreams | undefined ;
afterEach ( ( ) = > {
if ( appProcess && ! appProcess . killed ) {
appProcess . kill ( ) ;
appProcess = undefined ;
}
} ) ;
it ( 'Worker with nodeIntegrationInWorker has access to self.module.paths' , async ( ) = > {
const appPath = path . join ( __dirname , 'fixtures' , 'apps' , 'self-module-paths' ) ;
appProcess = ChildProcess . spawn ( process . execPath , [ appPath ] ) ;
const [ code ] = await emittedOnce ( appProcess , 'exit' ) ;
expect ( code ) . to . equal ( 0 ) ;
} ) ;
2022-07-27 09:10:04 +00:00
it ( 'Worker can work' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( ` file:// ${ fixturesPath } /pages/blank.html ` ) ;
const data = await w . webContents . executeJavaScript ( `
const worker = new Worker ( '../workers/worker.js' ) ;
const message = 'ping' ;
const eventPromise = new Promise ( ( resolve ) = > { worker . onmessage = resolve ; } ) ;
worker . postMessage ( message ) ;
eventPromise . then ( t = > t . data )
` );
expect ( data ) . to . equal ( 'ping' ) ;
} ) ;
it ( 'Worker has no node integration by default' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( ` file:// ${ fixturesPath } /pages/blank.html ` ) ;
const data = await w . webContents . executeJavaScript ( `
const worker = new Worker ( '../workers/worker_node.js' ) ;
new Promise ( ( resolve ) = > { worker . onmessage = e = > resolve ( e . data ) ; } )
` );
expect ( data ) . to . equal ( 'undefined undefined undefined undefined' ) ;
} ) ;
it ( 'Worker has node integration with nodeIntegrationInWorker' , async ( ) = > {
const w = new BrowserWindow ( { show : false , webPreferences : { nodeIntegration : true , nodeIntegrationInWorker : true , contextIsolation : false } } ) ;
w . loadURL ( ` file:// ${ fixturesPath } /pages/worker.html ` ) ;
const [ , data ] = await emittedOnce ( ipcMain , 'worker-result' ) ;
expect ( data ) . to . equal ( 'object function object function' ) ;
} ) ;
describe ( 'SharedWorker' , ( ) = > {
it ( 'can work' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( ` file:// ${ fixturesPath } /pages/blank.html ` ) ;
const data = await w . webContents . executeJavaScript ( `
const worker = new SharedWorker ( '../workers/shared_worker.js' ) ;
const message = 'ping' ;
const eventPromise = new Promise ( ( resolve ) = > { worker . port . onmessage = e = > resolve ( e . data ) ; } ) ;
worker . port . postMessage ( message ) ;
eventPromise
` );
expect ( data ) . to . equal ( 'ping' ) ;
} ) ;
it ( 'has no node integration by default' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( ` file:// ${ fixturesPath } /pages/blank.html ` ) ;
const data = await w . webContents . executeJavaScript ( `
const worker = new SharedWorker ( '../workers/shared_worker_node.js' ) ;
new Promise ( ( resolve ) = > { worker . port . onmessage = e = > resolve ( e . data ) ; } )
` );
expect ( data ) . to . equal ( 'undefined undefined undefined undefined' ) ;
} ) ;
2022-10-12 14:36:24 +00:00
it ( 'does not have node integration with nodeIntegrationInWorker' , async ( ) = > {
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
nodeIntegration : true ,
nodeIntegrationInWorker : true ,
contextIsolation : false
}
} ) ;
await w . loadURL ( ` file:// ${ fixturesPath } /pages/blank.html ` ) ;
const data = await w . webContents . executeJavaScript ( `
const worker = new SharedWorker ( '../workers/shared_worker_node.js' ) ;
new Promise ( ( resolve ) = > { worker . port . onmessage = e = > resolve ( e . data ) ; } )
` );
expect ( data ) . to . equal ( 'undefined undefined undefined undefined' ) ;
2022-07-27 09:10:04 +00:00
} ) ;
} ) ;
2021-07-04 23:48:46 +00:00
} ) ;
2019-12-11 06:46:25 +00:00
describe ( 'form submit' , ( ) = > {
let server : http.Server ;
let serverUrl : string ;
before ( async ( ) = > {
server = http . createServer ( ( req , res ) = > {
let body = '' ;
req . on ( 'data' , ( chunk ) = > {
body += chunk ;
} ) ;
res . setHeader ( 'Content-Type' , 'application/json' ) ;
req . on ( 'end' , ( ) = > {
res . end ( ` body: ${ body } ` ) ;
} ) ;
} ) ;
2021-01-22 19:25:47 +00:00
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
2019-12-11 06:46:25 +00:00
serverUrl = ` http://localhost: ${ ( server . address ( ) as any ) . port } ` ;
} ) ;
after ( async ( ) = > {
server . close ( ) ;
await closeAllWindows ( ) ;
} ) ;
[ true , false ] . forEach ( ( isSandboxEnabled ) = >
describe ( ` sandbox= ${ isSandboxEnabled } ` , ( ) = > {
2020-03-20 15:12:18 +00:00
it ( 'posts data in the same window' , async ( ) = > {
2019-12-11 06:46:25 +00:00
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
sandbox : isSandboxEnabled
}
} ) ;
2020-03-20 15:12:18 +00:00
await w . loadFile ( path . join ( fixturesPath , 'pages' , 'form-with-data.html' ) ) ;
2019-12-11 06:46:25 +00:00
2020-03-20 15:12:18 +00:00
const loadPromise = emittedOnce ( w . webContents , 'did-finish-load' ) ;
2019-12-11 06:46:25 +00:00
2020-03-20 15:12:18 +00:00
w . webContents . executeJavaScript ( `
const form = document . querySelector ( 'form' )
form . action = '${serverUrl}' ;
form . submit ( ) ;
` );
await loadPromise ;
const res = await w . webContents . executeJavaScript ( 'document.body.innerText' ) ;
expect ( res ) . to . equal ( 'body:greeting=hello' ) ;
2019-12-11 06:46:25 +00:00
} ) ;
2020-03-20 15:12:18 +00:00
it ( 'posts data to a new window with target=_blank' , async ( ) = > {
2019-12-11 06:46:25 +00:00
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
sandbox : isSandboxEnabled
}
} ) ;
2020-03-20 15:12:18 +00:00
await w . loadFile ( path . join ( fixturesPath , 'pages' , 'form-with-data.html' ) ) ;
2019-12-11 06:46:25 +00:00
2020-03-20 15:12:18 +00:00
const windowCreatedPromise = emittedOnce ( app , 'browser-window-created' ) ;
2019-12-11 06:46:25 +00:00
2020-03-20 15:12:18 +00:00
w . webContents . executeJavaScript ( `
const form = document . querySelector ( 'form' )
form . action = '${serverUrl}' ;
form . target = '_blank' ;
form . submit ( ) ;
` );
const [ , newWin ] = await windowCreatedPromise ;
const res = await newWin . webContents . executeJavaScript ( 'document.body.innerText' ) ;
expect ( res ) . to . equal ( 'body:greeting=hello' ) ;
2019-12-11 06:46:25 +00:00
} ) ;
} )
) ;
} ) ;
2019-10-11 20:55:50 +00:00
describe ( 'window.open' , ( ) = > {
for ( const show of [ true , false ] ) {
2020-11-10 17:06:03 +00:00
it ( ` shows the child regardless of parent visibility when parent {show= ${ show } } ` , async ( ) = > {
2019-10-11 20:55:50 +00:00
const w = new BrowserWindow ( { show } ) ;
// toggle visibility
if ( show ) {
w . hide ( ) ;
} else {
w . show ( ) ;
}
2020-06-30 22:10:36 +00:00
defer ( ( ) = > { w . close ( ) ; } ) ;
2022-06-13 17:07:47 +00:00
const promise = emittedOnce ( app , 'browser-window-created' ) ;
2019-10-11 20:55:50 +00:00
w . loadFile ( path . join ( fixturesPath , 'pages' , 'window-open.html' ) ) ;
2022-06-13 17:07:47 +00:00
const [ , newWindow ] = await promise ;
expect ( newWindow . isVisible ( ) ) . to . equal ( true ) ;
2019-10-11 20:55:50 +00:00
} ) ;
}
2022-08-05 00:20:56 +00:00
// FIXME(zcbenz): This test is making the spec runner hang on exit on Windows.
ifit ( process . platform !== 'win32' ) ( 'disables node integration when it is disabled on the parent window' , async ( ) = > {
const windowUrl = url . pathToFileURL ( path . join ( fixturesPath , 'pages' , 'window-opener-no-node-integration.html' ) ) ;
windowUrl . searchParams . set ( 'p' , ` ${ fixturesPath } /pages/window-opener-node.html ` ) ;
const w = new BrowserWindow ( { show : false } ) ;
w . loadFile ( path . resolve ( __dirname , 'fixtures' , 'blank.html' ) ) ;
const { eventData } = await w . webContents . executeJavaScript ( ` (async () => {
const message = new Promise ( resolve = > window . addEventListener ( 'message' , resolve , { once : true } ) ) ;
const b = window . open ( $ { JSON . stringify ( windowUrl ) } , '' , 'show=false' )
const e = await message
b . close ( ) ;
return {
eventData : e.data
}
} ) ( ) ` );
expect ( eventData . isProcessGlobalUndefined ) . to . be . true ( ) ;
} ) ;
2019-10-11 20:55:50 +00:00
it ( 'disables node integration when it is disabled on the parent window for chrome devtools URLs' , async ( ) = > {
2021-04-13 19:36:38 +00:00
// NB. webSecurity is disabled because native window.open() is not
// allowed to load devtools:// URLs.
const w = new BrowserWindow ( { show : false , webPreferences : { nodeIntegration : true , webSecurity : false } } ) ;
2019-10-11 20:55:50 +00:00
w . loadURL ( 'about:blank' ) ;
w . webContents . executeJavaScript ( `
2021-03-01 21:52:29 +00:00
{ b = window . open ( 'devtools://devtools/bundled/inspector.html' , '' , 'nodeIntegration=no,show=no' ) ; null }
2019-10-11 20:55:50 +00:00
` );
const [ , contents ] = await emittedOnce ( app , 'web-contents-created' ) ;
const typeofProcessGlobal = await contents . executeJavaScript ( 'typeof process' ) ;
expect ( typeofProcessGlobal ) . to . equal ( 'undefined' ) ;
} ) ;
2022-01-06 17:28:03 +00:00
it ( 'can disable node integration when it is enabled on the parent window' , async ( ) = > {
const w = new BrowserWindow ( { show : false , webPreferences : { nodeIntegration : true } } ) ;
2021-12-06 03:54:14 +00:00
w . loadURL ( 'about:blank' ) ;
w . webContents . executeJavaScript ( `
{ b = window . open ( 'about:blank' , '' , 'nodeIntegration=no,show=no' ) ; null }
` );
const [ , contents ] = await emittedOnce ( app , 'web-contents-created' ) ;
const typeofProcessGlobal = await contents . executeJavaScript ( 'typeof process' ) ;
expect ( typeofProcessGlobal ) . to . equal ( 'undefined' ) ;
} ) ;
2022-02-25 18:17:35 +00:00
// TODO(jkleinsc) fix this flaky test on WOA
ifit ( process . platform !== 'win32' || process . arch !== 'arm64' ) ( 'disables JavaScript when it is disabled on the parent window' , async ( ) = > {
2021-04-13 19:36:38 +00:00
const w = new BrowserWindow ( { show : true , webPreferences : { nodeIntegration : true } } ) ;
w . webContents . loadFile ( path . resolve ( __dirname , 'fixtures' , 'blank.html' ) ) ;
2019-10-11 20:55:50 +00:00
const windowUrl = require ( 'url' ) . format ( {
pathname : ` ${ fixturesPath } /pages/window-no-javascript.html ` ,
protocol : 'file' ,
slashes : true
} ) ;
w . webContents . executeJavaScript ( `
2021-03-01 21:52:29 +00:00
{ b = window . open ( $ { JSON . stringify ( windowUrl ) } , '' , 'javascript=no,show=no' ) ; null }
2019-10-11 20:55:50 +00:00
` );
const [ , contents ] = await emittedOnce ( app , 'web-contents-created' ) ;
await emittedOnce ( contents , 'did-finish-load' ) ;
// Click link on page
contents . sendInputEvent ( { type : 'mouseDown' , clickCount : 1 , x : 1 , y : 1 } ) ;
contents . sendInputEvent ( { type : 'mouseUp' , clickCount : 1 , x : 1 , y : 1 } ) ;
const [ , window ] = await emittedOnce ( app , 'browser-window-created' ) ;
2020-06-25 17:19:08 +00:00
const preferences = window . webContents . getLastWebPreferences ( ) ;
2019-10-11 20:55:50 +00:00
expect ( preferences . javascript ) . to . be . false ( ) ;
} ) ;
it ( 'defines a window.location getter' , async ( ) = > {
let targetURL : string ;
if ( process . platform === 'win32' ) {
targetURL = ` file:/// ${ fixturesPath . replace ( /\\/g , '/' ) } /pages/base-page.html ` ;
} else {
targetURL = ` file:// ${ fixturesPath } /pages/base-page.html ` ;
}
const w = new BrowserWindow ( { show : false } ) ;
2021-04-13 19:36:38 +00:00
w . webContents . loadFile ( path . resolve ( __dirname , 'fixtures' , 'blank.html' ) ) ;
2020-01-29 12:01:37 +00:00
w . webContents . executeJavaScript ( ` { b = window.open( ${ JSON . stringify ( targetURL ) } ); null } ` ) ;
2019-10-11 20:55:50 +00:00
const [ , window ] = await emittedOnce ( app , 'browser-window-created' ) ;
await emittedOnce ( window . webContents , 'did-finish-load' ) ;
2020-03-20 15:12:18 +00:00
expect ( await w . webContents . executeJavaScript ( 'b.location.href' ) ) . to . equal ( targetURL ) ;
2019-10-11 20:55:50 +00:00
} ) ;
it ( 'defines a window.location setter' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
2021-04-13 19:36:38 +00:00
w . webContents . loadFile ( path . resolve ( __dirname , 'fixtures' , 'blank.html' ) ) ;
2020-03-20 15:12:18 +00:00
w . webContents . executeJavaScript ( '{ b = window.open("about:blank"); null }' ) ;
2019-10-11 20:55:50 +00:00
const [ , { webContents } ] = await emittedOnce ( app , 'browser-window-created' ) ;
await emittedOnce ( webContents , 'did-finish-load' ) ;
// When it loads, redirect
2020-01-29 12:01:37 +00:00
w . webContents . executeJavaScript ( ` { b.location = ${ JSON . stringify ( ` file:// ${ fixturesPath } /pages/base-page.html ` ) } ; null } ` ) ;
2019-10-11 20:55:50 +00:00
await emittedOnce ( webContents , 'did-finish-load' ) ;
} ) ;
it ( 'defines a window.location.href setter' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
2021-04-13 19:36:38 +00:00
w . webContents . loadFile ( path . resolve ( __dirname , 'fixtures' , 'blank.html' ) ) ;
2020-03-20 15:12:18 +00:00
w . webContents . executeJavaScript ( '{ b = window.open("about:blank"); null }' ) ;
2019-10-11 20:55:50 +00:00
const [ , { webContents } ] = await emittedOnce ( app , 'browser-window-created' ) ;
await emittedOnce ( webContents , 'did-finish-load' ) ;
// When it loads, redirect
2020-01-29 12:01:37 +00:00
w . webContents . executeJavaScript ( ` { b.location.href = ${ JSON . stringify ( ` file:// ${ fixturesPath } /pages/base-page.html ` ) } ; null } ` ) ;
2019-10-11 20:55:50 +00:00
await emittedOnce ( webContents , 'did-finish-load' ) ;
} ) ;
it ( 'open a blank page when no URL is specified' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadURL ( 'about:blank' ) ;
2020-03-20 15:12:18 +00:00
w . webContents . executeJavaScript ( '{ b = window.open(); null }' ) ;
2019-10-11 20:55:50 +00:00
const [ , { webContents } ] = await emittedOnce ( app , 'browser-window-created' ) ;
await emittedOnce ( webContents , 'did-finish-load' ) ;
2020-03-20 15:12:18 +00:00
expect ( await w . webContents . executeJavaScript ( 'b.location.href' ) ) . to . equal ( 'about:blank' ) ;
2019-10-11 20:55:50 +00:00
} ) ;
it ( 'open a blank page when an empty URL is specified' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadURL ( 'about:blank' ) ;
2020-03-20 15:12:18 +00:00
w . webContents . executeJavaScript ( '{ b = window.open(\'\'); null }' ) ;
2019-10-11 20:55:50 +00:00
const [ , { webContents } ] = await emittedOnce ( app , 'browser-window-created' ) ;
await emittedOnce ( webContents , 'did-finish-load' ) ;
2020-03-20 15:12:18 +00:00
expect ( await w . webContents . executeJavaScript ( 'b.location.href' ) ) . to . equal ( 'about:blank' ) ;
2019-10-11 20:55:50 +00:00
} ) ;
it ( 'does not throw an exception when the frameName is a built-in object property' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadURL ( 'about:blank' ) ;
2020-03-20 15:12:18 +00:00
w . webContents . executeJavaScript ( '{ b = window.open(\'\', \'__proto__\'); null }' ) ;
2022-06-13 17:07:47 +00:00
const frameName = await new Promise ( ( resolve ) = > {
w . webContents . setWindowOpenHandler ( details = > {
setImmediate ( ( ) = > resolve ( details . frameName ) ) ;
return { action : 'allow' } ;
} ) ;
} ) ;
2021-02-05 19:20:58 +00:00
expect ( frameName ) . to . equal ( '__proto__' ) ;
2019-10-11 20:55:50 +00:00
} ) ;
2022-08-05 00:20:56 +00:00
// TODO(nornagon): I'm not sure this ... ever was correct?
it . skip ( 'inherit options of parent window' , async ( ) = > {
const w = new BrowserWindow ( { show : false , width : 123 , height : 456 } ) ;
w . loadFile ( path . resolve ( __dirname , 'fixtures' , 'blank.html' ) ) ;
const url = ` file:// ${ fixturesPath } /pages/window-open-size.html ` ;
const { width , height , eventData } = await w . webContents . executeJavaScript ( ` (async () => {
const message = new Promise ( resolve = > window . addEventListener ( 'message' , resolve , { once : true } ) ) ;
const b = window . open ( $ { JSON . stringify ( url ) } , '' , 'show=false' )
const e = await message
b . close ( ) ;
const width = outerWidth ;
const height = outerHeight ;
return {
width ,
height ,
eventData : e.data
}
} ) ( ) ` );
expect ( eventData ) . to . equal ( ` size: ${ width } ${ height } ` ) ;
expect ( eventData ) . to . equal ( 'size: 123 456' ) ;
} ) ;
it ( 'does not override child options' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadFile ( path . resolve ( __dirname , 'fixtures' , 'blank.html' ) ) ;
const windowUrl = ` file:// ${ fixturesPath } /pages/window-open-size.html ` ;
const { eventData } = await w . webContents . executeJavaScript ( ` (async () => {
const message = new Promise ( resolve = > window . addEventListener ( 'message' , resolve , { once : true } ) ) ;
const b = window . open ( $ { JSON . stringify ( windowUrl ) } , '' , 'show=no,width=350,height=450' )
const e = await message
b . close ( ) ;
return { eventData : e.data }
} ) ( ) ` );
expect ( eventData ) . to . equal ( 'size: 350 450' ) ;
} ) ;
it ( 'disables the <webview> tag when it is disabled on the parent window' , async ( ) = > {
const windowUrl = url . pathToFileURL ( path . join ( fixturesPath , 'pages' , 'window-opener-no-webview-tag.html' ) ) ;
windowUrl . searchParams . set ( 'p' , ` ${ fixturesPath } /pages/window-opener-webview.html ` ) ;
const w = new BrowserWindow ( { show : false } ) ;
w . loadFile ( path . resolve ( __dirname , 'fixtures' , 'blank.html' ) ) ;
const { eventData } = await w . webContents . executeJavaScript ( ` (async () => {
const message = new Promise ( resolve = > window . addEventListener ( 'message' , resolve , { once : true } ) ) ;
const b = window . open ( $ { JSON . stringify ( windowUrl ) } , '' , 'webviewTag=no,contextIsolation=no,nodeIntegration=yes,show=no' )
const e = await message
b . close ( ) ;
return { eventData : e.data }
} ) ( ) ` );
expect ( eventData . isWebViewGlobalUndefined ) . to . be . true ( ) ;
} ) ;
it ( 'throws an exception when the arguments cannot be converted to strings' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadURL ( 'about:blank' ) ;
await expect (
w . webContents . executeJavaScript ( 'window.open(\'\', { toString: null })' )
) . to . eventually . be . rejected ( ) ;
await expect (
w . webContents . executeJavaScript ( 'window.open(\'\', \'\', { toString: 3 })' )
) . to . eventually . be . rejected ( ) ;
} ) ;
it ( 'does not throw an exception when the features include webPreferences' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadURL ( 'about:blank' ) ;
await expect (
w . webContents . executeJavaScript ( 'window.open(\'\', \'\', \'show=no,webPreferences=\'); null' )
) . to . eventually . be . fulfilled ( ) ;
} ) ;
2019-10-11 20:55:50 +00:00
} ) ;
describe ( 'window.opener' , ( ) = > {
it ( 'is null for main window' , async ( ) = > {
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
2021-03-01 21:52:29 +00:00
nodeIntegration : true ,
contextIsolation : false
2019-10-11 20:55:50 +00:00
}
} ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'window-opener.html' ) ) ;
const [ , channel , opener ] = await emittedOnce ( w . webContents , 'ipc-message' ) ;
expect ( channel ) . to . equal ( 'opener' ) ;
expect ( opener ) . to . equal ( null ) ;
} ) ;
2022-08-05 00:20:56 +00:00
it ( 'is not null for window opened by window.open' , async ( ) = > {
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
nodeIntegration : true ,
contextIsolation : false
}
} ) ;
w . loadFile ( path . resolve ( __dirname , 'fixtures' , 'blank.html' ) ) ;
const windowUrl = ` file:// ${ fixturesPath } /pages/window-opener.html ` ;
const eventData = await w . webContents . executeJavaScript ( `
const b = window . open ( $ { JSON . stringify ( windowUrl ) } , '' , 'show=no' ) ;
new Promise ( resolve = > window . addEventListener ( 'message' , resolve , { once : true } ) ) . then ( e = > e . data ) ;
` );
expect ( eventData ) . to . equal ( 'object' ) ;
} ) ;
} ) ;
describe ( 'window.opener.postMessage' , ( ) = > {
it ( 'sets source and origin correctly' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadFile ( path . resolve ( __dirname , 'fixtures' , 'blank.html' ) ) ;
const windowUrl = ` file:// ${ fixturesPath } /pages/window-opener-postMessage.html ` ;
const { sourceIsChild , origin } = await w . webContents . executeJavaScript ( `
const b = window . open ( $ { JSON . stringify ( windowUrl ) } , '' , 'show=no' ) ;
new Promise ( resolve = > window . addEventListener ( 'message' , resolve , { once : true } ) ) . then ( e = > ( {
sourceIsChild : e.source === b ,
origin : e.origin
} ) ) ;
` );
expect ( sourceIsChild ) . to . be . true ( ) ;
expect ( origin ) . to . equal ( 'file://' ) ;
} ) ;
it ( 'supports windows opened from a <webview>' , async ( ) = > {
const w = new BrowserWindow ( { show : false , webPreferences : { webviewTag : true } } ) ;
w . loadURL ( 'about:blank' ) ;
const childWindowUrl = url . pathToFileURL ( path . join ( fixturesPath , 'pages' , 'webview-opener-postMessage.html' ) ) ;
childWindowUrl . searchParams . set ( 'p' , ` ${ fixturesPath } /pages/window-opener-postMessage.html ` ) ;
const message = await w . webContents . executeJavaScript ( `
const webview = new WebView ( ) ;
webview . allowpopups = true ;
webview . setAttribute ( 'webpreferences' , 'contextIsolation=no' ) ;
webview . src = $ { JSON . stringify ( childWindowUrl ) }
const consoleMessage = new Promise ( resolve = > webview . addEventListener ( 'console-message' , resolve , { once : true } ) ) ;
document . body . appendChild ( webview ) ;
consoleMessage . then ( e = > e . message )
` );
expect ( message ) . to . equal ( 'message' ) ;
} ) ;
describe ( 'targetOrigin argument' , ( ) = > {
let serverURL : string ;
let server : any ;
beforeEach ( ( done ) = > {
server = http . createServer ( ( req , res ) = > {
res . writeHead ( 200 ) ;
const filePath = path . join ( fixturesPath , 'pages' , 'window-opener-targetOrigin.html' ) ;
res . end ( fs . readFileSync ( filePath , 'utf8' ) ) ;
} ) ;
server . listen ( 0 , '127.0.0.1' , ( ) = > {
serverURL = ` http://127.0.0.1: ${ server . address ( ) . port } ` ;
done ( ) ;
} ) ;
} ) ;
afterEach ( ( ) = > {
server . close ( ) ;
} ) ;
it ( 'delivers messages that match the origin' , async ( ) = > {
const w = new BrowserWindow ( { show : false , webPreferences : { nodeIntegration : true , contextIsolation : false } } ) ;
w . loadFile ( path . resolve ( __dirname , 'fixtures' , 'blank.html' ) ) ;
const data = await w . webContents . executeJavaScript ( `
window . open ( $ { JSON . stringify ( serverURL ) } , '' , 'show=no,contextIsolation=no,nodeIntegration=yes' ) ;
new Promise ( resolve = > window . addEventListener ( 'message' , resolve , { once : true } ) ) . then ( e = > e . data )
` );
expect ( data ) . to . equal ( 'deliver' ) ;
} ) ;
} ) ;
2019-10-11 20:55:50 +00:00
} ) ;
describe ( 'navigator.mediaDevices' , ( ) = > {
afterEach ( closeAllWindows ) ;
afterEach ( ( ) = > {
session . defaultSession . setPermissionCheckHandler ( null ) ;
2021-10-13 21:10:12 +00:00
session . defaultSession . setPermissionRequestHandler ( null ) ;
2019-10-11 20:55:50 +00:00
} ) ;
it ( 'can return labels of enumerated devices' , async ( ) = > {
2019-11-01 20:37:02 +00:00
const w = new BrowserWindow ( { show : false } ) ;
2019-10-11 20:55:50 +00:00
w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
2020-03-20 15:12:18 +00:00
const labels = await w . webContents . executeJavaScript ( 'navigator.mediaDevices.enumerateDevices().then(ds => ds.map(d => d.label))' ) ;
2019-10-11 20:55:50 +00:00
expect ( labels . some ( ( l : any ) = > l ) ) . to . be . true ( ) ;
} ) ;
it ( 'does not return labels of enumerated devices when permission denied' , async ( ) = > {
session . defaultSession . setPermissionCheckHandler ( ( ) = > false ) ;
2019-11-01 20:37:02 +00:00
const w = new BrowserWindow ( { show : false } ) ;
2019-10-11 20:55:50 +00:00
w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
2020-03-20 15:12:18 +00:00
const labels = await w . webContents . executeJavaScript ( 'navigator.mediaDevices.enumerateDevices().then(ds => ds.map(d => d.label))' ) ;
2019-10-11 20:55:50 +00:00
expect ( labels . some ( ( l : any ) = > l ) ) . to . be . false ( ) ;
} ) ;
2020-02-27 00:03:55 +00:00
it ( 'returns the same device ids across reloads' , async ( ) = > {
const ses = session . fromPartition ( 'persist:media-device-id' ) ;
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
nodeIntegration : true ,
2021-03-01 21:52:29 +00:00
session : ses ,
contextIsolation : false
2020-02-27 00:03:55 +00:00
}
} ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'media-id-reset.html' ) ) ;
const [ , firstDeviceIds ] = await emittedOnce ( ipcMain , 'deviceIds' ) ;
const [ , secondDeviceIds ] = await emittedOnce ( ipcMain , 'deviceIds' , ( ) = > w . webContents . reload ( ) ) ;
expect ( firstDeviceIds ) . to . deep . equal ( secondDeviceIds ) ;
} ) ;
2019-10-11 20:55:50 +00:00
it ( 'can return new device id when cookie storage is cleared' , async ( ) = > {
const ses = session . fromPartition ( 'persist:media-device-id' ) ;
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
nodeIntegration : true ,
2021-03-01 21:52:29 +00:00
session : ses ,
contextIsolation : false
2019-10-11 20:55:50 +00:00
}
} ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'media-id-reset.html' ) ) ;
const [ , firstDeviceIds ] = await emittedOnce ( ipcMain , 'deviceIds' ) ;
await ses . clearStorageData ( { storages : [ 'cookies' ] } ) ;
2020-02-27 00:03:55 +00:00
const [ , secondDeviceIds ] = await emittedOnce ( ipcMain , 'deviceIds' , ( ) = > w . webContents . reload ( ) ) ;
2019-10-11 20:55:50 +00:00
expect ( firstDeviceIds ) . to . not . deep . equal ( secondDeviceIds ) ;
} ) ;
2021-10-13 21:10:12 +00:00
it ( 'provides a securityOrigin to the request handler' , async ( ) = > {
session . defaultSession . setPermissionRequestHandler (
( wc , permission , callback , details ) = > {
if ( details . securityOrigin !== undefined ) {
callback ( true ) ;
} else {
callback ( false ) ;
}
}
) ;
const w = new BrowserWindow ( { show : false } ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
const labels = await w . webContents . executeJavaScript ( ` navigator.mediaDevices.getUserMedia({
video : {
mandatory : {
chromeMediaSource : "desktop" ,
minWidth : 1280 ,
maxWidth : 1280 ,
minHeight : 720 ,
maxHeight : 720
}
}
} ) . then ( ( stream ) = > stream . getVideoTracks ( ) ) ` );
expect ( labels . some ( ( l : any ) = > l ) ) . to . be . true ( ) ;
} ) ;
2022-07-20 08:09:14 +00:00
it ( 'fails with "not supported" for getDisplayMedia' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
const { ok , err } = await w . webContents . executeJavaScript ( 'navigator.mediaDevices.getDisplayMedia({video: true}).then(s => ({ok: true}), e => ({ok: false, err: e.message}))' ) ;
expect ( ok ) . to . be . false ( ) ;
expect ( err ) . to . equal ( 'Not supported' ) ;
} ) ;
2019-10-11 20:55:50 +00:00
} ) ;
2019-10-14 16:00:34 +00:00
describe ( 'window.opener access' , ( ) = > {
const scheme = 'app' ;
const fileUrl = ` file:// ${ fixturesPath } /pages/window-opener-location.html ` ;
const httpUrl1 = ` ${ scheme } ://origin1 ` ;
const httpUrl2 = ` ${ scheme } ://origin2 ` ;
2019-10-16 15:12:31 +00:00
const fileBlank = ` file:// ${ fixturesPath } /pages/blank.html ` ;
const httpBlank = ` ${ scheme } ://origin1/blank ` ;
2019-10-14 16:00:34 +00:00
const table = [
2022-01-06 17:28:03 +00:00
{ parent : fileBlank , child : httpUrl1 , nodeIntegration : false , openerAccessible : false } ,
{ parent : fileBlank , child : httpUrl1 , nodeIntegration : true , openerAccessible : false } ,
2019-10-14 16:00:34 +00:00
2022-01-06 17:28:03 +00:00
// {parent: httpBlank, child: fileUrl, nodeIntegration: false, openerAccessible: false}, // can't window.open()
// {parent: httpBlank, child: fileUrl, nodeIntegration: true, openerAccessible: false}, // can't window.open()
2019-10-14 16:00:34 +00:00
// NB. this is different from Chrome's behavior, which isolates file: urls from each other
2022-01-06 17:28:03 +00:00
{ parent : fileBlank , child : fileUrl , nodeIntegration : false , openerAccessible : true } ,
{ parent : fileBlank , child : fileUrl , nodeIntegration : true , openerAccessible : true } ,
{ parent : httpBlank , child : httpUrl1 , nodeIntegration : false , openerAccessible : true } ,
{ parent : httpBlank , child : httpUrl1 , nodeIntegration : true , openerAccessible : true } ,
{ parent : httpBlank , child : httpUrl2 , nodeIntegration : false , openerAccessible : false } ,
{ parent : httpBlank , child : httpUrl2 , nodeIntegration : true , openerAccessible : false }
2019-10-14 16:00:34 +00:00
] ;
2019-10-16 15:12:31 +00:00
const s = ( url : string ) = > url . startsWith ( 'file' ) ? 'file://...' : url ;
2019-10-14 16:00:34 +00:00
2020-06-02 16:46:18 +00:00
before ( ( ) = > {
protocol . registerFileProtocol ( scheme , ( request , callback ) = > {
2019-10-16 15:12:31 +00:00
if ( request . url . includes ( 'blank' ) ) {
callback ( ` ${ fixturesPath } /pages/blank.html ` ) ;
} else {
callback ( ` ${ fixturesPath } /pages/window-opener-location.html ` ) ;
}
2019-10-14 16:00:34 +00:00
} ) ;
} ) ;
2020-06-02 16:46:18 +00:00
after ( ( ) = > {
protocol . unregisterProtocol ( scheme ) ;
2019-10-14 16:00:34 +00:00
} ) ;
afterEach ( closeAllWindows ) ;
2019-10-16 15:12:31 +00:00
describe ( 'when opened from main window' , ( ) = > {
2022-01-06 17:28:03 +00:00
for ( const { parent , child , nodeIntegration , openerAccessible } of table ) {
2020-01-06 21:23:03 +00:00
for ( const sandboxPopup of [ false , true ] ) {
2022-01-06 17:28:03 +00:00
const description = ` when parent= ${ s ( parent ) } opens child= ${ s ( child ) } with nodeIntegration= ${ nodeIntegration } sandboxPopup= ${ sandboxPopup } , child should ${ openerAccessible ? '' : 'not ' } be able to access opener ` ;
2020-01-06 21:23:03 +00:00
it ( description , async ( ) = > {
2022-01-06 17:28:03 +00:00
const w = new BrowserWindow ( { show : true , webPreferences : { nodeIntegration : true , contextIsolation : false } } ) ;
2020-11-10 17:06:03 +00:00
w . webContents . setWindowOpenHandler ( ( ) = > ( {
action : 'allow' ,
overrideBrowserWindowOptions : {
webPreferences : {
sandbox : sandboxPopup
}
}
} ) ) ;
2020-01-06 21:23:03 +00:00
await w . loadURL ( parent ) ;
const childOpenerLocation = await w . webContents . executeJavaScript ( ` new Promise(resolve => {
window . addEventListener ( 'message' , function f ( e ) {
resolve ( e . data )
} )
window . open ( $ { JSON . stringify ( child ) } , "" , "show=no,nodeIntegration=${nodeIntegration ? 'yes' : 'no'}" )
} ) ` );
if ( openerAccessible ) {
expect ( childOpenerLocation ) . to . be . a ( 'string' ) ;
} else {
expect ( childOpenerLocation ) . to . be . null ( ) ;
}
} ) ;
}
2019-10-16 15:12:31 +00:00
}
} ) ;
describe ( 'when opened from <webview>' , ( ) = > {
2022-01-06 17:28:03 +00:00
for ( const { parent , child , nodeIntegration , openerAccessible } of table ) {
const description = ` when parent= ${ s ( parent ) } opens child= ${ s ( child ) } with nodeIntegration= ${ nodeIntegration } , child should ${ openerAccessible ? '' : 'not ' } be able to access opener ` ;
it ( description , async ( ) = > {
2019-10-16 15:12:31 +00:00
// This test involves three contexts:
// 1. The root BrowserWindow in which the test is run,
// 2. A <webview> belonging to the root window,
// 3. A window opened by calling window.open() from within the <webview>.
// We are testing whether context (3) can access context (2) under various conditions.
// This is context (1), the base window for the test.
2022-01-06 17:28:03 +00:00
const w = new BrowserWindow ( { show : false , webPreferences : { nodeIntegration : true , webviewTag : true , contextIsolation : false } } ) ;
2019-10-16 15:12:31 +00:00
await w . loadURL ( 'about:blank' ) ;
const parentCode = ` new Promise((resolve) => {
// This is context (3), a child window of the WebView.
2021-04-21 17:55:17 +00:00
const child = window . open ( $ { JSON . stringify ( child ) } , "" , "show=no,contextIsolation=no,nodeIntegration=yes" )
2019-10-16 15:12:31 +00:00
window . addEventListener ( "message" , e = > {
resolve ( e . data )
} )
} ) ` ;
const childOpenerLocation = await w . webContents . executeJavaScript ( ` new Promise((resolve, reject) => {
// This is context (2), a WebView which will call window.open()
const webview = new WebView ( )
2019-11-01 20:37:02 +00:00
webview . setAttribute ( 'nodeintegration' , '${nodeIntegration ? ' on ' : ' off '}' )
2022-01-06 17:28:03 +00:00
webview . setAttribute ( 'webpreferences' , 'contextIsolation=no' )
2019-10-16 15:12:31 +00:00
webview . setAttribute ( 'allowpopups' , 'on' )
webview . src = $ { JSON . stringify ( parent + '?p=' + encodeURIComponent ( child ) ) }
webview . addEventListener ( 'dom-ready' , async ( ) = > {
webview . executeJavaScript ( $ { JSON . stringify ( parentCode ) } ) . then ( resolve , reject )
} )
document . body . appendChild ( webview )
} ) ` );
if ( openerAccessible ) {
expect ( childOpenerLocation ) . to . be . a ( 'string' ) ;
} else {
expect ( childOpenerLocation ) . to . be . null ( ) ;
}
} ) ;
}
} ) ;
} ) ;
describe ( 'storage' , ( ) = > {
describe ( 'custom non standard schemes' , ( ) = > {
const protocolName = 'storage' ;
let contents : WebContents ;
2020-06-02 16:46:18 +00:00
before ( ( ) = > {
2019-10-16 15:12:31 +00:00
protocol . registerFileProtocol ( protocolName , ( request , callback ) = > {
const parsedUrl = url . parse ( request . url ) ;
let filename ;
switch ( parsedUrl . pathname ) {
case '/localStorage' : filename = 'local_storage.html' ; break ;
case '/sessionStorage' : filename = 'session_storage.html' ; break ;
case '/WebSQL' : filename = 'web_sql.html' ; break ;
case '/indexedDB' : filename = 'indexed_db.html' ; break ;
case '/cookie' : filename = 'cookie.html' ; break ;
default : filename = '' ;
}
callback ( { path : ` ${ fixturesPath } /pages/storage/ ${ filename } ` } ) ;
2020-06-02 16:46:18 +00:00
} ) ;
2019-10-16 15:12:31 +00:00
} ) ;
2020-06-02 16:46:18 +00:00
after ( ( ) = > {
protocol . unregisterProtocol ( protocolName ) ;
2019-10-16 15:12:31 +00:00
} ) ;
beforeEach ( ( ) = > {
contents = ( webContents as any ) . create ( {
2021-03-01 21:52:29 +00:00
nodeIntegration : true ,
contextIsolation : false
2019-10-16 15:12:31 +00:00
} ) ;
} ) ;
afterEach ( ( ) = > {
( contents as any ) . destroy ( ) ;
contents = null as any ;
} ) ;
2020-06-30 22:10:36 +00:00
it ( 'cannot access localStorage' , async ( ) = > {
const response = emittedOnce ( ipcMain , 'local-storage-response' ) ;
2019-10-16 15:12:31 +00:00
contents . loadURL ( protocolName + '://host/localStorage' ) ;
2020-06-30 22:10:36 +00:00
const [ , error ] = await response ;
expect ( error ) . to . equal ( 'Failed to read the \'localStorage\' property from \'Window\': Access is denied for this document.' ) ;
2019-10-16 15:12:31 +00:00
} ) ;
2020-06-30 22:10:36 +00:00
it ( 'cannot access sessionStorage' , async ( ) = > {
const response = emittedOnce ( ipcMain , 'session-storage-response' ) ;
2019-10-16 15:12:31 +00:00
contents . loadURL ( ` ${ protocolName } ://host/sessionStorage ` ) ;
2020-06-30 22:10:36 +00:00
const [ , error ] = await response ;
expect ( error ) . to . equal ( 'Failed to read the \'sessionStorage\' property from \'Window\': Access is denied for this document.' ) ;
2019-10-16 15:12:31 +00:00
} ) ;
2020-06-30 22:10:36 +00:00
it ( 'cannot access WebSQL database' , async ( ) = > {
const response = emittedOnce ( ipcMain , 'web-sql-response' ) ;
2019-10-16 15:12:31 +00:00
contents . loadURL ( ` ${ protocolName } ://host/WebSQL ` ) ;
2020-06-30 22:10:36 +00:00
const [ , error ] = await response ;
expect ( error ) . to . equal ( 'Failed to execute \'openDatabase\' on \'Window\': Access to the WebDatabase API is denied in this context.' ) ;
2019-10-16 15:12:31 +00:00
} ) ;
2020-06-30 22:10:36 +00:00
it ( 'cannot access indexedDB' , async ( ) = > {
const response = emittedOnce ( ipcMain , 'indexed-db-response' ) ;
2019-10-16 15:12:31 +00:00
contents . loadURL ( ` ${ protocolName } ://host/indexedDB ` ) ;
2020-06-30 22:10:36 +00:00
const [ , error ] = await response ;
expect ( error ) . to . equal ( 'Failed to execute \'open\' on \'IDBFactory\': access to the Indexed Database API is denied in this context.' ) ;
2019-10-16 15:12:31 +00:00
} ) ;
2020-06-30 22:10:36 +00:00
it ( 'cannot access cookie' , async ( ) = > {
const response = emittedOnce ( ipcMain , 'cookie-response' ) ;
2019-10-16 15:12:31 +00:00
contents . loadURL ( ` ${ protocolName } ://host/cookie ` ) ;
2020-06-30 22:10:36 +00:00
const [ , error ] = await response ;
expect ( error ) . to . equal ( 'Failed to set the \'cookie\' property on \'Document\': Access is denied for this document.' ) ;
2019-10-16 15:12:31 +00:00
} ) ;
} ) ;
describe ( 'can be accessed' , ( ) = > {
let server : http.Server ;
let serverUrl : string ;
let serverCrossSiteUrl : string ;
before ( ( done ) = > {
server = http . createServer ( ( req , res ) = > {
const respond = ( ) = > {
if ( req . url === '/redirect-cross-site' ) {
res . setHeader ( 'Location' , ` ${ serverCrossSiteUrl } /redirected ` ) ;
res . statusCode = 302 ;
res . end ( ) ;
} else if ( req . url === '/redirected' ) {
res . end ( '<html><script>window.localStorage</script></html>' ) ;
} else {
res . end ( ) ;
}
} ;
setTimeout ( respond , 0 ) ;
} ) ;
server . listen ( 0 , '127.0.0.1' , ( ) = > {
serverUrl = ` http://127.0.0.1: ${ ( server . address ( ) as AddressInfo ) . port } ` ;
serverCrossSiteUrl = ` http://localhost: ${ ( server . address ( ) as AddressInfo ) . port } ` ;
done ( ) ;
} ) ;
} ) ;
after ( ( ) = > {
server . close ( ) ;
server = null as any ;
} ) ;
afterEach ( closeAllWindows ) ;
const testLocalStorageAfterXSiteRedirect = ( testTitle : string , extraPreferences = { } ) = > {
2020-06-30 22:10:36 +00:00
it ( testTitle , async ( ) = > {
2019-10-16 15:12:31 +00:00
const w = new BrowserWindow ( {
show : false ,
. . . extraPreferences
2019-10-14 16:00:34 +00:00
} ) ;
2019-10-16 15:12:31 +00:00
let redirected = false ;
w . webContents . on ( 'crashed' , ( ) = > {
expect . fail ( 'renderer crashed / was killed' ) ;
} ) ;
w . webContents . on ( 'did-redirect-navigation' , ( event , url ) = > {
expect ( url ) . to . equal ( ` ${ serverCrossSiteUrl } /redirected ` ) ;
redirected = true ;
} ) ;
2020-06-30 22:10:36 +00:00
await w . loadURL ( ` ${ serverUrl } /redirect-cross-site ` ) ;
expect ( redirected ) . to . be . true ( 'didnt redirect' ) ;
2019-10-16 15:12:31 +00:00
} ) ;
} ;
2020-03-20 20:28:31 +00:00
2019-10-16 15:12:31 +00:00
testLocalStorageAfterXSiteRedirect ( 'after a cross-site redirect' ) ;
testLocalStorageAfterXSiteRedirect ( 'after a cross-site redirect in sandbox mode' , { sandbox : true } ) ;
} ) ;
2020-05-06 19:52:59 +00:00
describe ( 'enableWebSQL webpreference' , ( ) = > {
const origin = ` ${ standardScheme } ://fake-host ` ;
const filePath = path . join ( fixturesPath , 'pages' , 'storage' , 'web_sql.html' ) ;
const sqlPartition = 'web-sql-preference-test' ;
const sqlSession = session . fromPartition ( sqlPartition ) ;
const securityError = 'An attempt was made to break through the security policy of the user agent.' ;
let contents : WebContents , w : BrowserWindow ;
before ( ( ) = > {
sqlSession . protocol . registerFileProtocol ( standardScheme , ( request , callback ) = > {
callback ( { path : filePath } ) ;
} ) ;
} ) ;
after ( ( ) = > {
sqlSession . protocol . unregisterProtocol ( standardScheme ) ;
} ) ;
afterEach ( async ( ) = > {
if ( contents ) {
( contents as any ) . destroy ( ) ;
contents = null as any ;
}
await closeAllWindows ( ) ;
( w as any ) = null ;
} ) ;
it ( 'default value allows websql' , async ( ) = > {
contents = ( webContents as any ) . create ( {
session : sqlSession ,
2021-03-01 21:52:29 +00:00
nodeIntegration : true ,
contextIsolation : false
2020-05-06 19:52:59 +00:00
} ) ;
contents . loadURL ( origin ) ;
const [ , error ] = await emittedOnce ( ipcMain , 'web-sql-response' ) ;
expect ( error ) . to . be . null ( ) ;
} ) ;
it ( 'when set to false can disallow websql' , async ( ) = > {
contents = ( webContents as any ) . create ( {
session : sqlSession ,
nodeIntegration : true ,
2021-03-01 21:52:29 +00:00
enableWebSQL : false ,
contextIsolation : false
2020-05-06 19:52:59 +00:00
} ) ;
contents . loadURL ( origin ) ;
const [ , error ] = await emittedOnce ( ipcMain , 'web-sql-response' ) ;
expect ( error ) . to . equal ( securityError ) ;
} ) ;
it ( 'when set to false does not disable indexedDB' , async ( ) = > {
contents = ( webContents as any ) . create ( {
session : sqlSession ,
nodeIntegration : true ,
2021-03-01 21:52:29 +00:00
enableWebSQL : false ,
contextIsolation : false
2020-05-06 19:52:59 +00:00
} ) ;
contents . loadURL ( origin ) ;
const [ , error ] = await emittedOnce ( ipcMain , 'web-sql-response' ) ;
expect ( error ) . to . equal ( securityError ) ;
const dbName = 'random' ;
const result = await contents . executeJavaScript ( `
new Promise ( ( resolve , reject ) = > {
try {
let req = window . indexedDB . open ( '${dbName}' ) ;
2020-06-11 02:07:49 +00:00
req . onsuccess = ( event ) = > {
2020-05-06 19:52:59 +00:00
let db = req . result ;
resolve ( db . name ) ;
}
req . onerror = ( event ) = > { resolve ( event . target . code ) ; }
} catch ( e ) {
resolve ( e . message ) ;
}
} ) ;
` );
expect ( result ) . to . equal ( dbName ) ;
} ) ;
it ( 'child webContents can override when the embedder has allowed websql' , async ( ) = > {
w = new BrowserWindow ( {
show : false ,
webPreferences : {
nodeIntegration : true ,
webviewTag : true ,
2021-03-01 21:52:29 +00:00
session : sqlSession ,
contextIsolation : false
2020-05-06 19:52:59 +00:00
}
} ) ;
w . webContents . loadURL ( origin ) ;
const [ , error ] = await emittedOnce ( ipcMain , 'web-sql-response' ) ;
expect ( error ) . to . be . null ( ) ;
const webviewResult = emittedOnce ( ipcMain , 'web-sql-response' ) ;
await w . webContents . executeJavaScript ( `
new Promise ( ( resolve , reject ) = > {
const webview = new WebView ( ) ;
webview . setAttribute ( 'src' , '${origin}' ) ;
2021-03-01 21:52:29 +00:00
webview . setAttribute ( 'webpreferences' , 'enableWebSQL=0,contextIsolation=no' ) ;
2020-05-06 19:52:59 +00:00
webview . setAttribute ( 'partition' , '${sqlPartition}' ) ;
webview . setAttribute ( 'nodeIntegration' , 'on' ) ;
document . body . appendChild ( webview ) ;
webview . addEventListener ( 'dom-ready' , ( ) = > resolve ( ) ) ;
} ) ;
` );
const [ , childError ] = await webviewResult ;
expect ( childError ) . to . equal ( securityError ) ;
} ) ;
it ( 'child webContents cannot override when the embedder has disallowed websql' , async ( ) = > {
w = new BrowserWindow ( {
show : false ,
webPreferences : {
nodeIntegration : true ,
enableWebSQL : false ,
webviewTag : true ,
2021-03-01 21:52:29 +00:00
session : sqlSession ,
contextIsolation : false
2020-05-06 19:52:59 +00:00
}
} ) ;
w . webContents . loadURL ( 'data:text/html,<html></html>' ) ;
const webviewResult = emittedOnce ( ipcMain , 'web-sql-response' ) ;
await w . webContents . executeJavaScript ( `
new Promise ( ( resolve , reject ) = > {
const webview = new WebView ( ) ;
webview . setAttribute ( 'src' , '${origin}' ) ;
2021-03-01 21:52:29 +00:00
webview . setAttribute ( 'webpreferences' , 'enableWebSQL=1,contextIsolation=no' ) ;
2020-05-06 19:52:59 +00:00
webview . setAttribute ( 'partition' , '${sqlPartition}' ) ;
webview . setAttribute ( 'nodeIntegration' , 'on' ) ;
document . body . appendChild ( webview ) ;
webview . addEventListener ( 'dom-ready' , ( ) = > resolve ( ) ) ;
} ) ;
` );
const [ , childError ] = await webviewResult ;
expect ( childError ) . to . equal ( securityError ) ;
} ) ;
it ( 'child webContents can use websql when the embedder has allowed websql' , async ( ) = > {
w = new BrowserWindow ( {
show : false ,
webPreferences : {
nodeIntegration : true ,
webviewTag : true ,
2021-03-01 21:52:29 +00:00
session : sqlSession ,
contextIsolation : false
2020-05-06 19:52:59 +00:00
}
} ) ;
w . webContents . loadURL ( origin ) ;
const [ , error ] = await emittedOnce ( ipcMain , 'web-sql-response' ) ;
expect ( error ) . to . be . null ( ) ;
const webviewResult = emittedOnce ( ipcMain , 'web-sql-response' ) ;
await w . webContents . executeJavaScript ( `
new Promise ( ( resolve , reject ) = > {
const webview = new WebView ( ) ;
webview . setAttribute ( 'src' , '${origin}' ) ;
2021-03-01 21:52:29 +00:00
webview . setAttribute ( 'webpreferences' , 'enableWebSQL=1,contextIsolation=no' ) ;
2020-05-06 19:52:59 +00:00
webview . setAttribute ( 'partition' , '${sqlPartition}' ) ;
webview . setAttribute ( 'nodeIntegration' , 'on' ) ;
document . body . appendChild ( webview ) ;
webview . addEventListener ( 'dom-ready' , ( ) = > resolve ( ) ) ;
} ) ;
` );
const [ , childError ] = await webviewResult ;
expect ( childError ) . to . be . null ( ) ;
} ) ;
} ) ;
2022-08-05 00:20:56 +00:00
describe ( 'DOM storage quota increase' , ( ) = > {
[ 'localStorage' , 'sessionStorage' ] . forEach ( ( storageName ) = > {
it ( ` allows saving at least 40MiB in ${ storageName } ` , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
// Although JavaScript strings use UTF-16, the underlying
// storage provider may encode strings differently, muddling the
// translation between character and byte counts. However,
// a string of 40 * 2^20 characters will require at least 40MiB
// and presumably no more than 80MiB, a size guaranteed to
// to exceed the original 10MiB quota yet stay within the
// new 100MiB quota.
// Note that both the key name and value affect the total size.
const testKeyName = '_electronDOMStorageQuotaIncreasedTest' ;
const length = 40 * Math . pow ( 2 , 20 ) - testKeyName . length ;
await w . webContents . executeJavaScript ( `
$ { storageName } . setItem ( $ { JSON . stringify ( testKeyName ) } , 'X' . repeat ( $ { length } ) ) ;
` );
// Wait at least one turn of the event loop to help avoid false positives
// Although not entirely necessary, the previous version of this test case
// failed to detect a real problem (perhaps related to DOM storage data caching)
// wherein calling `getItem` immediately after `setItem` would appear to work
// but then later (e.g. next tick) it would not.
await delay ( 1 ) ;
try {
const storedLength = await w . webContents . executeJavaScript ( ` ${ storageName } .getItem( ${ JSON . stringify ( testKeyName ) } ).length ` ) ;
expect ( storedLength ) . to . equal ( length ) ;
} finally {
await w . webContents . executeJavaScript ( ` ${ storageName } .removeItem( ${ JSON . stringify ( testKeyName ) } ); ` ) ;
}
} ) ;
it ( ` throws when attempting to use more than 128MiB in ${ storageName } ` , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
await expect ( ( async ( ) = > {
const testKeyName = '_electronDOMStorageQuotaStillEnforcedTest' ;
const length = 128 * Math . pow ( 2 , 20 ) - testKeyName . length ;
try {
await w . webContents . executeJavaScript ( `
$ { storageName } . setItem ( $ { JSON . stringify ( testKeyName ) } , 'X' . repeat ( $ { length } ) ) ;
` );
} finally {
await w . webContents . executeJavaScript ( ` ${ storageName } .removeItem( ${ JSON . stringify ( testKeyName ) } ); ` ) ;
}
} ) ( ) ) . to . eventually . be . rejected ( ) ;
} ) ;
} ) ;
} ) ;
describe ( 'persistent storage' , ( ) = > {
it ( 'can be requested' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
const grantedBytes = await w . webContents . executeJavaScript ( ` new Promise(resolve => {
navigator . webkitPersistentStorage . requestQuota ( 1024 * 1024 , resolve ) ;
} ) ` );
expect ( grantedBytes ) . to . equal ( 1048576 ) ;
} ) ;
} ) ;
2019-10-16 15:12:31 +00:00
} ) ;
ifdescribe ( features . isPDFViewerEnabled ( ) ) ( 'PDF Viewer' , ( ) = > {
const pdfSource = url . format ( {
2020-02-13 00:39:12 +00:00
pathname : path.join ( __dirname , 'fixtures' , 'cat.pdf' ) . replace ( /\\/g , '/' ) ,
2019-10-16 15:12:31 +00:00
protocol : 'file' ,
slashes : true
} ) ;
2021-01-28 01:09:55 +00:00
it ( 'successfully loads a PDF file' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadURL ( pdfSource ) ;
await emittedOnce ( w . webContents , 'did-finish-load' ) ;
} ) ;
2020-02-13 00:39:12 +00:00
it ( 'opens when loading a pdf resource as top level navigation' , async ( ) = > {
2019-10-16 15:12:31 +00:00
const w = new BrowserWindow ( { show : false } ) ;
2020-02-13 00:39:12 +00:00
w . loadURL ( pdfSource ) ;
2021-01-13 21:49:35 +00:00
const [ , contents ] = await emittedOnce ( app , 'web-contents-created' ) ;
2021-04-23 20:51:37 +00:00
await emittedOnce ( contents , 'did-navigate' ) ;
2021-01-13 21:49:35 +00:00
expect ( contents . getURL ( ) ) . to . equal ( 'chrome-extension://mhjfbmdgcfjbbpaeojofohoefgiehjai/index.html' ) ;
2019-10-16 15:12:31 +00:00
} ) ;
2020-02-13 00:39:12 +00:00
it ( 'opens when loading a pdf resource in a iframe' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadFile ( path . join ( __dirname , 'fixtures' , 'pages' , 'pdf-in-iframe.html' ) ) ;
2021-01-13 21:49:35 +00:00
const [ , contents ] = await emittedOnce ( app , 'web-contents-created' ) ;
2021-04-23 20:51:37 +00:00
await emittedOnce ( contents , 'did-navigate' ) ;
2021-01-13 21:49:35 +00:00
expect ( contents . getURL ( ) ) . to . equal ( 'chrome-extension://mhjfbmdgcfjbbpaeojofohoefgiehjai/index.html' ) ;
2019-10-16 15:12:31 +00:00
} ) ;
} ) ;
describe ( 'window.history' , ( ) = > {
describe ( 'window.history.pushState' , ( ) = > {
2020-01-23 18:51:41 +00:00
it ( 'should push state after calling history.pushState() from the same url' , async ( ) = > {
2019-10-16 15:12:31 +00:00
const w = new BrowserWindow ( { show : false } ) ;
2020-01-23 18:51:41 +00:00
await w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
// History should have current page by now.
expect ( ( w . webContents as any ) . length ( ) ) . to . equal ( 1 ) ;
2020-01-29 09:42:25 +00:00
const waitCommit = emittedOnce ( w . webContents , 'navigation-entry-committed' ) ;
2020-01-23 18:51:41 +00:00
w . webContents . executeJavaScript ( 'window.history.pushState({}, "")' ) ;
await waitCommit ;
// Initial page + pushed state.
expect ( ( w . webContents as any ) . length ( ) ) . to . equal ( 2 ) ;
2019-10-16 15:12:31 +00:00
} ) ;
} ) ;
2022-09-09 00:08:56 +00:00
describe ( 'window.history.back' , ( ) = > {
it ( 'should not allow sandboxed iframe to modify main frame state' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadURL ( 'data:text/html,<iframe sandbox="allow-scripts"></iframe>' ) ;
await Promise . all ( [
emittedOnce ( w . webContents , 'navigation-entry-committed' ) ,
emittedOnce ( w . webContents , 'did-frame-navigate' ) ,
emittedOnce ( w . webContents , 'did-navigate' )
] ) ;
w . webContents . executeJavaScript ( 'window.history.pushState(1, "")' ) ;
await Promise . all ( [
emittedOnce ( w . webContents , 'navigation-entry-committed' ) ,
emittedOnce ( w . webContents , 'did-navigate-in-page' )
] ) ;
( w . webContents as any ) . once ( 'navigation-entry-committed' , ( ) = > {
expect . fail ( 'Unexpected navigation-entry-committed' ) ;
} ) ;
w . webContents . once ( 'did-navigate-in-page' , ( ) = > {
expect . fail ( 'Unexpected did-navigate-in-page' ) ;
} ) ;
await w . webContents . mainFrame . frames [ 0 ] . executeJavaScript ( 'window.history.back()' ) ;
expect ( await w . webContents . executeJavaScript ( 'window.history.state' ) ) . to . equal ( 1 ) ;
expect ( ( w . webContents as any ) . getActiveIndex ( ) ) . to . equal ( 1 ) ;
} ) ;
} ) ;
2019-10-14 16:00:34 +00:00
} ) ;
2020-06-11 02:07:49 +00:00
describe ( 'chrome://media-internals' , ( ) = > {
it ( 'loads the page successfully' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadURL ( 'chrome://media-internals' ) ;
const pageExists = await w . webContents . executeJavaScript (
"window.hasOwnProperty('chrome') && window.chrome.hasOwnProperty('send')"
) ;
expect ( pageExists ) . to . be . true ( ) ;
} ) ;
} ) ;
describe ( 'chrome://webrtc-internals' , ( ) = > {
it ( 'loads the page successfully' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadURL ( 'chrome://webrtc-internals' ) ;
const pageExists = await w . webContents . executeJavaScript (
"window.hasOwnProperty('chrome') && window.chrome.hasOwnProperty('send')"
) ;
expect ( pageExists ) . to . be . true ( ) ;
} ) ;
} ) ;
2021-05-19 09:27:35 +00:00
describe ( 'document.hasFocus' , ( ) = > {
it ( 'has correct value when multiple windows are opened' , async ( ) = > {
const w1 = new BrowserWindow ( { show : true } ) ;
const w2 = new BrowserWindow ( { show : true } ) ;
const w3 = new BrowserWindow ( { show : false } ) ;
await w1 . loadFile ( path . join ( __dirname , 'fixtures' , 'blank.html' ) ) ;
await w2 . loadFile ( path . join ( __dirname , 'fixtures' , 'blank.html' ) ) ;
await w3 . loadFile ( path . join ( __dirname , 'fixtures' , 'blank.html' ) ) ;
expect ( webContents . getFocusedWebContents ( ) . id ) . to . equal ( w2 . webContents . id ) ;
let focus = false ;
focus = await w1 . webContents . executeJavaScript (
'document.hasFocus()'
) ;
expect ( focus ) . to . be . false ( ) ;
focus = await w2 . webContents . executeJavaScript (
'document.hasFocus()'
) ;
expect ( focus ) . to . be . true ( ) ;
focus = await w3 . webContents . executeJavaScript (
'document.hasFocus()'
) ;
expect ( focus ) . to . be . false ( ) ;
} ) ;
} ) ;
2022-06-13 16:35:42 +00:00
describe ( 'navigator.userAgentData' , ( ) = > {
// These tests are done on an http server because navigator.userAgentData
// requires a secure context.
let server : http.Server ;
let serverUrl : string ;
before ( async ( ) = > {
server = http . createServer ( ( req , res ) = > {
res . setHeader ( 'Content-Type' , 'text/html' ) ;
res . end ( '' ) ;
} ) ;
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
serverUrl = ` http://localhost: ${ ( server . address ( ) as any ) . port } ` ;
} ) ;
after ( ( ) = > {
server . close ( ) ;
} ) ;
describe ( 'is not empty' , ( ) = > {
it ( 'by default' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( serverUrl ) ;
const platform = await w . webContents . executeJavaScript ( 'navigator.userAgentData.platform' ) ;
expect ( platform ) . not . to . be . empty ( ) ;
} ) ;
it ( 'when there is a session-wide UA override' , async ( ) = > {
const ses = session . fromPartition ( ` ${ Math . random ( ) } ` ) ;
ses . setUserAgent ( 'foobar' ) ;
const w = new BrowserWindow ( { show : false , webPreferences : { session : ses } } ) ;
await w . loadURL ( serverUrl ) ;
const platform = await w . webContents . executeJavaScript ( 'navigator.userAgentData.platform' ) ;
expect ( platform ) . not . to . be . empty ( ) ;
} ) ;
it ( 'when there is a WebContents-specific UA override' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . webContents . setUserAgent ( 'foo' ) ;
await w . loadURL ( serverUrl ) ;
const platform = await w . webContents . executeJavaScript ( 'navigator.userAgentData.platform' ) ;
expect ( platform ) . not . to . be . empty ( ) ;
} ) ;
it ( 'when there is a WebContents-specific UA override at load time' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( serverUrl , {
userAgent : 'foo'
} ) ;
const platform = await w . webContents . executeJavaScript ( 'navigator.userAgentData.platform' ) ;
expect ( platform ) . not . to . be . empty ( ) ;
} ) ;
} ) ;
describe ( 'brand list' , ( ) = > {
it ( 'contains chromium' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( serverUrl ) ;
const brands = await w . webContents . executeJavaScript ( 'navigator.userAgentData.brands' ) ;
expect ( brands . map ( ( b : any ) = > b . brand ) ) . to . include ( 'Chromium' ) ;
} ) ;
} ) ;
} ) ;
2022-07-27 09:10:04 +00:00
describe ( 'Badging API' , ( ) = > {
it ( 'does not crash' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( ` file:// ${ fixturesPath } /pages/blank.html ` ) ;
await w . webContents . executeJavaScript ( 'navigator.setAppBadge(42)' ) ;
await w . webContents . executeJavaScript ( 'navigator.setAppBadge()' ) ;
await w . webContents . executeJavaScript ( 'navigator.clearAppBadge()' ) ;
} ) ;
} ) ;
describe ( 'navigator.webkitGetUserMedia' , ( ) = > {
it ( 'calls its callbacks' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( ` file:// ${ fixturesPath } /pages/blank.html ` ) ;
await w . webContents . executeJavaScript ( ` new Promise((resolve) => {
navigator . webkitGetUserMedia ( {
audio : true ,
video : false
} , ( ) = > resolve ( ) ,
( ) = > resolve ( ) ) ;
} ) ` );
} ) ;
} ) ;
describe ( 'navigator.language' , ( ) = > {
it ( 'should not be empty' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( 'about:blank' ) ;
expect ( await w . webContents . executeJavaScript ( 'navigator.language' ) ) . to . not . equal ( '' ) ;
} ) ;
} ) ;
describe ( 'heap snapshot' , ( ) = > {
it ( 'does not crash' , async ( ) = > {
const w = new BrowserWindow ( { show : false , webPreferences : { nodeIntegration : true , contextIsolation : false } } ) ;
w . loadURL ( 'about:blank' ) ;
await w . webContents . executeJavaScript ( 'process._linkedBinding(\'electron_common_v8_util\').takeHeapSnapshot()' ) ;
} ) ;
} ) ;
ifdescribe ( process . platform !== 'win32' && process . platform !== 'linux' ) ( 'webgl' , ( ) = > {
it ( 'can be gotten as context in canvas' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
w . loadURL ( 'about:blank' ) ;
await w . loadURL ( ` file:// ${ fixturesPath } /pages/blank.html ` ) ;
const canWebglContextBeCreated = await w . webContents . executeJavaScript ( `
document . createElement ( 'canvas' ) . getContext ( 'webgl' ) != null ;
` );
expect ( canWebglContextBeCreated ) . to . be . true ( ) ;
} ) ;
} ) ;
describe ( 'iframe' , ( ) = > {
it ( 'does not have node integration' , async ( ) = > {
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( ` file:// ${ fixturesPath } /pages/blank.html ` ) ;
const result = await w . webContents . executeJavaScript ( `
const iframe = document . createElement ( 'iframe' )
iframe . src = './set-global.html' ;
document . body . appendChild ( iframe ) ;
new Promise ( resolve = > iframe . onload = e = > resolve ( iframe . contentWindow . test ) )
` );
expect ( result ) . to . equal ( 'undefined undefined undefined' ) ;
} ) ;
} ) ;
describe ( 'websockets' , ( ) = > {
it ( 'has user agent' , async ( ) = > {
const server = http . createServer ( ) ;
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
const port = ( server . address ( ) as AddressInfo ) . port ;
const wss = new ws . Server ( { server : server } ) ;
const finished = new Promise < string | undefined > ( ( resolve , reject ) = > {
wss . on ( 'error' , reject ) ;
wss . on ( 'connection' , ( ws , upgradeReq ) = > {
resolve ( upgradeReq . headers [ 'user-agent' ] ) ;
} ) ;
} ) ;
const w = new BrowserWindow ( { show : false } ) ;
w . loadURL ( 'about:blank' ) ;
w . webContents . executeJavaScript ( `
new WebSocket ( 'ws://127.0.0.1:${port}' ) ;
` );
expect ( await finished ) . to . include ( 'Electron' ) ;
} ) ;
} ) ;
describe ( 'fetch' , ( ) = > {
it ( 'does not crash' , async ( ) = > {
const server = http . createServer ( ( req , res ) = > {
res . end ( 'test' ) ;
} ) ;
defer ( ( ) = > server . close ( ) ) ;
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
const port = ( server . address ( ) as AddressInfo ) . port ;
const w = new BrowserWindow ( { show : false } ) ;
w . loadURL ( ` file:// ${ fixturesPath } /pages/blank.html ` ) ;
const x = await w . webContents . executeJavaScript ( `
fetch ( 'http://127.0.0.1:${port}' ) . then ( ( res ) = > res . body . getReader ( ) )
. then ( ( reader ) = > {
return reader . read ( ) . then ( ( r ) = > {
reader . cancel ( ) ;
return r . value ;
} ) ;
} )
` );
expect ( x ) . to . deep . equal ( new Uint8Array ( [ 116 , 101 , 115 , 116 ] ) ) ;
} ) ;
} ) ;
2022-08-05 00:20:56 +00:00
describe ( 'Promise' , ( ) = > {
before ( ( ) = > {
ipcMain . handle ( 'ping' , ( e , arg ) = > arg ) ;
} ) ;
after ( ( ) = > {
ipcMain . removeHandler ( 'ping' ) ;
} ) ;
itremote ( 'resolves correctly in Node.js calls' , async ( ) = > {
await new Promise < void > ( ( resolve , reject ) = > {
class XElement extends HTMLElement { }
customElements . define ( 'x-element' , XElement ) ;
setImmediate ( ( ) = > {
let called = false ;
Promise . resolve ( ) . then ( ( ) = > {
if ( called ) resolve ( ) ;
else reject ( new Error ( 'wrong sequence' ) ) ;
} ) ;
document . createElement ( 'x-element' ) ;
called = true ;
} ) ;
} ) ;
} ) ;
itremote ( 'resolves correctly in Electron calls' , async ( ) = > {
await new Promise < void > ( ( resolve , reject ) = > {
class YElement extends HTMLElement { }
customElements . define ( 'y-element' , YElement ) ;
require ( 'electron' ) . ipcRenderer . invoke ( 'ping' ) . then ( ( ) = > {
let called = false ;
Promise . resolve ( ) . then ( ( ) = > {
if ( called ) resolve ( ) ;
else reject ( new Error ( 'wrong sequence' ) ) ;
} ) ;
document . createElement ( 'y-element' ) ;
called = true ;
} ) ;
} ) ;
} ) ;
} ) ;
describe ( 'synchronous prompts' , ( ) = > {
describe ( 'window.alert(message, title)' , ( ) = > {
itremote ( 'throws an exception when the arguments cannot be converted to strings' , ( ) = > {
expect ( ( ) = > {
window . alert ( { toString : null } ) ;
} ) . to . throw ( 'Cannot convert object to primitive value' ) ;
} ) ;
} ) ;
describe ( 'window.confirm(message, title)' , ( ) = > {
itremote ( 'throws an exception when the arguments cannot be converted to strings' , ( ) = > {
expect ( ( ) = > {
( window . confirm as any ) ( { toString : null } , 'title' ) ;
} ) . to . throw ( 'Cannot convert object to primitive value' ) ;
} ) ;
} ) ;
} ) ;
describe ( 'window.history' , ( ) = > {
describe ( 'window.history.go(offset)' , ( ) = > {
itremote ( 'throws an exception when the argument cannot be converted to a string' , ( ) = > {
expect ( ( ) = > {
( window . history . go as any ) ( { toString : null } ) ;
} ) . to . throw ( 'Cannot convert object to primitive value' ) ;
} ) ;
} ) ;
} ) ;
describe ( 'console functions' , ( ) = > {
itremote ( 'should exist' , ( ) = > {
expect ( console . log , 'log' ) . to . be . a ( 'function' ) ;
expect ( console . error , 'error' ) . to . be . a ( 'function' ) ;
expect ( console . warn , 'warn' ) . to . be . a ( 'function' ) ;
expect ( console . info , 'info' ) . to . be . a ( 'function' ) ;
expect ( console . debug , 'debug' ) . to . be . a ( 'function' ) ;
expect ( console . trace , 'trace' ) . to . be . a ( 'function' ) ;
expect ( console . time , 'time' ) . to . be . a ( 'function' ) ;
expect ( console . timeEnd , 'timeEnd' ) . to . be . a ( 'function' ) ;
} ) ;
} ) ;
ifdescribe ( features . isTtsEnabled ( ) ) ( 'SpeechSynthesis' , ( ) = > {
before ( function ( ) {
// TODO(nornagon): this is broken on CI, it triggers:
// [FATAL:speech_synthesis.mojom-shared.h(237)] The outgoing message will
// trigger VALIDATION_ERROR_UNEXPECTED_NULL_POINTER at the receiving side
// (null text in SpeechSynthesisUtterance struct).
this . skip ( ) ;
} ) ;
itremote ( 'should emit lifecycle events' , async ( ) = > {
const sentence = ` long sentence which will take at least a few seconds to
utter so that it ' s possible to pause and resume before the end ` ;
const utter = new SpeechSynthesisUtterance ( sentence ) ;
// Create a dummy utterance so that speech synthesis state
// is initialized for later calls.
speechSynthesis . speak ( new SpeechSynthesisUtterance ( ) ) ;
speechSynthesis . cancel ( ) ;
speechSynthesis . speak ( utter ) ;
// paused state after speak()
expect ( speechSynthesis . paused ) . to . be . false ( ) ;
await new Promise ( ( resolve ) = > { utter . onstart = resolve ; } ) ;
// paused state after start event
expect ( speechSynthesis . paused ) . to . be . false ( ) ;
speechSynthesis . pause ( ) ;
// paused state changes async, right before the pause event
expect ( speechSynthesis . paused ) . to . be . false ( ) ;
await new Promise ( ( resolve ) = > { utter . onpause = resolve ; } ) ;
expect ( speechSynthesis . paused ) . to . be . true ( ) ;
speechSynthesis . resume ( ) ;
await new Promise ( ( resolve ) = > { utter . onresume = resolve ; } ) ;
// paused state after resume event
expect ( speechSynthesis . paused ) . to . be . false ( ) ;
await new Promise ( ( resolve ) = > { utter . onend = resolve ; } ) ;
} ) ;
} ) ;
2019-10-11 20:55:50 +00:00
} ) ;
2019-10-16 15:12:31 +00:00
describe ( 'font fallback' , ( ) = > {
async function getRenderedFonts ( html : string ) {
const w = new BrowserWindow ( { show : false } ) ;
try {
await w . loadURL ( ` data:text/html, ${ html } ` ) ;
w . webContents . debugger . attach ( ) ;
const sendCommand = ( method : string , commandParams? : any ) = > w . webContents . debugger . sendCommand ( method , commandParams ) ;
const { nodeId } = ( await sendCommand ( 'DOM.getDocument' ) ) . root . children [ 0 ] ;
await sendCommand ( 'CSS.enable' ) ;
const { fonts } = await sendCommand ( 'CSS.getPlatformFontsForNode' , { nodeId } ) ;
return fonts ;
} finally {
w . close ( ) ;
}
}
it ( 'should use Helvetica for sans-serif on Mac, and Arial on Windows and Linux' , async ( ) = > {
2020-03-20 15:12:18 +00:00
const html = '<body style="font-family: sans-serif">test</body>' ;
2019-10-16 15:12:31 +00:00
const fonts = await getRenderedFonts ( html ) ;
expect ( fonts ) . to . be . an ( 'array' ) ;
expect ( fonts ) . to . have . length ( 1 ) ;
2021-04-19 18:27:34 +00:00
if ( process . platform === 'win32' ) {
expect ( fonts [ 0 ] . familyName ) . to . equal ( 'Arial' ) ;
} else if ( process . platform === 'darwin' ) {
expect ( fonts [ 0 ] . familyName ) . to . equal ( 'Helvetica' ) ;
} else if ( process . platform === 'linux' ) {
expect ( fonts [ 0 ] . familyName ) . to . equal ( 'DejaVu Sans' ) ;
} // I think this depends on the distro? We don't specify a default.
2019-10-16 15:12:31 +00:00
} ) ;
ifit ( process . platform !== 'linux' ) ( 'should fall back to Japanese font for sans-serif Japanese script' , async function ( ) {
const html = `
< html lang = "ja-JP" >
< head >
< meta charset = "utf-8" / >
< / head >
< body style = "font-family: sans-serif" > test 智 史 < / body >
< / html >
` ;
const fonts = await getRenderedFonts ( html ) ;
expect ( fonts ) . to . be . an ( 'array' ) ;
expect ( fonts ) . to . have . length ( 1 ) ;
2019-11-01 20:37:02 +00:00
if ( process . platform === 'win32' ) { expect ( fonts [ 0 ] . familyName ) . to . be . oneOf ( [ 'Meiryo' , 'Yu Gothic' ] ) ; } else if ( process . platform === 'darwin' ) { expect ( fonts [ 0 ] . familyName ) . to . equal ( 'Hiragino Kaku Gothic ProN' ) ; }
2019-10-16 15:12:31 +00:00
} ) ;
2019-11-01 20:37:02 +00:00
} ) ;
2019-11-05 21:34:45 +00:00
describe ( 'iframe using HTML fullscreen API while window is OS-fullscreened' , ( ) = > {
const fullscreenChildHtml = promisify ( fs . readFile ) (
path . join ( fixturesPath , 'pages' , 'fullscreen-oopif.html' )
) ;
let w : BrowserWindow , server : http.Server ;
before ( ( ) = > {
server = http . createServer ( async ( _req , res ) = > {
res . writeHead ( 200 , { 'Content-Type' : 'text/html' } ) ;
res . write ( await fullscreenChildHtml ) ;
res . end ( ) ;
} ) ;
server . listen ( 8989 , '127.0.0.1' ) ;
} ) ;
beforeEach ( ( ) = > {
w = new BrowserWindow ( {
show : true ,
fullscreen : true ,
webPreferences : {
nodeIntegration : true ,
2021-03-01 21:52:29 +00:00
nodeIntegrationInSubFrames : true ,
contextIsolation : false
2019-11-05 21:34:45 +00:00
}
} ) ;
} ) ;
afterEach ( async ( ) = > {
2021-04-21 14:56:25 +00:00
await closeAllWindows ( ) ;
( w as any ) = null ;
2019-11-05 21:34:45 +00:00
server . close ( ) ;
} ) ;
2022-06-07 16:59:50 +00:00
ifit ( process . platform !== 'darwin' ) ( 'can fullscreen from out-of-process iframes (non-macOS)' , async ( ) = > {
2020-06-30 22:10:36 +00:00
const fullscreenChange = emittedOnce ( ipcMain , 'fullscreenChange' ) ;
const html =
'<iframe style="width: 0" frameborder=0 src="http://localhost:8989" allowfullscreen></iframe>' ;
w . loadURL ( ` data:text/html, ${ html } ` ) ;
await fullscreenChange ;
2019-11-05 21:34:45 +00:00
2020-06-30 22:10:36 +00:00
const fullscreenWidth = await w . webContents . executeJavaScript (
"document.querySelector('iframe').offsetWidth"
) ;
expect ( fullscreenWidth > 0 ) . to . be . true ( ) ;
2019-11-05 21:34:45 +00:00
2020-06-30 22:10:36 +00:00
await w . webContents . executeJavaScript (
"document.querySelector('iframe').contentWindow.postMessage('exitFullscreen', '*')"
) ;
2019-11-05 21:34:45 +00:00
2020-06-30 22:10:36 +00:00
await delay ( 500 ) ;
2019-11-05 21:34:45 +00:00
2020-06-30 22:10:36 +00:00
const width = await w . webContents . executeJavaScript (
"document.querySelector('iframe').offsetWidth"
) ;
expect ( width ) . to . equal ( 0 ) ;
2019-11-05 21:34:45 +00:00
} ) ;
2022-06-07 16:59:50 +00:00
ifit ( process . platform === 'darwin' ) ( 'can fullscreen from out-of-process iframes (macOS)' , async ( ) = > {
await emittedOnce ( w , 'enter-full-screen' ) ;
const fullscreenChange = emittedOnce ( ipcMain , 'fullscreenChange' ) ;
const html =
'<iframe style="width: 0" frameborder=0 src="http://localhost:8989" allowfullscreen></iframe>' ;
w . loadURL ( ` data:text/html, ${ html } ` ) ;
await fullscreenChange ;
const fullscreenWidth = await w . webContents . executeJavaScript (
"document.querySelector('iframe').offsetWidth"
) ;
expect ( fullscreenWidth > 0 ) . to . be . true ( ) ;
await w . webContents . executeJavaScript (
"document.querySelector('iframe').contentWindow.postMessage('exitFullscreen', '*')"
) ;
await emittedOnce ( w . webContents , 'leave-html-full-screen' ) ;
const width = await w . webContents . executeJavaScript (
"document.querySelector('iframe').offsetWidth"
) ;
expect ( width ) . to . equal ( 0 ) ;
w . setFullScreen ( false ) ;
await emittedOnce ( w , 'leave-full-screen' ) ;
} ) ;
2022-02-25 18:17:35 +00:00
// TODO(jkleinsc) fix this flaky test on WOA
ifit ( process . platform !== 'win32' || process . arch !== 'arm64' ) ( 'can fullscreen from in-process iframes' , async ( ) = > {
2022-06-07 16:59:50 +00:00
if ( process . platform === 'darwin' ) await emittedOnce ( w , 'enter-full-screen' ) ;
2020-06-30 22:10:36 +00:00
const fullscreenChange = emittedOnce ( ipcMain , 'fullscreenChange' ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'fullscreen-ipif.html' ) ) ;
await fullscreenChange ;
2019-11-05 21:34:45 +00:00
2020-06-30 22:10:36 +00:00
const fullscreenWidth = await w . webContents . executeJavaScript (
"document.querySelector('iframe').offsetWidth"
) ;
expect ( fullscreenWidth > 0 ) . to . true ( ) ;
2020-03-20 20:28:31 +00:00
2020-06-30 22:10:36 +00:00
await w . webContents . executeJavaScript ( 'document.exitFullscreen()' ) ;
const width = await w . webContents . executeJavaScript (
"document.querySelector('iframe').offsetWidth"
) ;
expect ( width ) . to . equal ( 0 ) ;
2019-11-05 21:34:45 +00:00
} ) ;
} ) ;
2020-09-28 16:22:03 +00:00
describe ( 'navigator.serial' , ( ) = > {
let w : BrowserWindow ;
before ( async ( ) = > {
w = new BrowserWindow ( {
2021-07-29 23:57:22 +00:00
show : false
2020-09-28 16:22:03 +00:00
} ) ;
await w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
} ) ;
const getPorts : any = ( ) = > {
return w . webContents . executeJavaScript ( `
navigator . serial . requestPort ( ) . then ( port = > port . toString ( ) ) . catch ( err = > err . toString ( ) ) ;
` , true);
} ;
2022-10-27 16:37:04 +00:00
const notFoundError = 'NotFoundError: Failed to execute \'requestPort\' on \'Serial\': No port selected by the user.' ;
2020-09-28 16:22:03 +00:00
after ( closeAllWindows ) ;
afterEach ( ( ) = > {
session . defaultSession . setPermissionCheckHandler ( null ) ;
session . defaultSession . removeAllListeners ( 'select-serial-port' ) ;
} ) ;
it ( 'does not return a port if select-serial-port event is not defined' , async ( ) = > {
w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
const port = await getPorts ( ) ;
2022-10-27 16:37:04 +00:00
expect ( port ) . to . equal ( notFoundError ) ;
2020-09-28 16:22:03 +00:00
} ) ;
it ( 'does not return a port when permission denied' , async ( ) = > {
w . webContents . session . on ( 'select-serial-port' , ( event , portList , webContents , callback ) = > {
callback ( portList [ 0 ] . portId ) ;
} ) ;
session . defaultSession . setPermissionCheckHandler ( ( ) = > false ) ;
const port = await getPorts ( ) ;
2022-10-27 16:37:04 +00:00
expect ( port ) . to . equal ( notFoundError ) ;
2020-09-28 16:22:03 +00:00
} ) ;
2021-04-12 13:18:39 +00:00
it ( 'does not crash when select-serial-port is called with an invalid port' , async ( ) = > {
w . webContents . session . on ( 'select-serial-port' , ( event , portList , webContents , callback ) = > {
callback ( 'i-do-not-exist' ) ;
} ) ;
const port = await getPorts ( ) ;
2022-10-27 16:37:04 +00:00
expect ( port ) . to . equal ( notFoundError ) ;
2021-04-12 13:18:39 +00:00
} ) ;
2020-09-28 16:22:03 +00:00
it ( 'returns a port when select-serial-port event is defined' , async ( ) = > {
2022-05-23 14:33:39 +00:00
let havePorts = false ;
2020-09-28 16:22:03 +00:00
w . webContents . session . on ( 'select-serial-port' , ( event , portList , webContents , callback ) = > {
2022-05-23 14:33:39 +00:00
if ( portList . length > 0 ) {
havePorts = true ;
callback ( portList [ 0 ] . portId ) ;
} else {
callback ( '' ) ;
}
2020-09-28 16:22:03 +00:00
} ) ;
const port = await getPorts ( ) ;
2022-05-23 14:33:39 +00:00
if ( havePorts ) {
expect ( port ) . to . equal ( '[object SerialPort]' ) ;
} else {
2022-10-27 16:37:04 +00:00
expect ( port ) . to . equal ( notFoundError ) ;
2022-05-23 14:33:39 +00:00
}
} ) ;
it ( 'navigator.serial.getPorts() returns values' , async ( ) = > {
let havePorts = false ;
w . webContents . session . on ( 'select-serial-port' , ( event , portList , webContents , callback ) = > {
if ( portList . length > 0 ) {
havePorts = true ;
callback ( portList [ 0 ] . portId ) ;
} else {
callback ( '' ) ;
}
} ) ;
await getPorts ( ) ;
if ( havePorts ) {
const grantedPorts = await w . webContents . executeJavaScript ( 'navigator.serial.getPorts()' ) ;
expect ( grantedPorts ) . to . not . be . empty ( ) ;
}
2020-09-28 16:22:03 +00:00
} ) ;
2022-10-18 09:22:32 +00:00
it ( 'supports port.forget()' , async ( ) = > {
let forgottenPortFromEvent = { } ;
let havePorts = false ;
w . webContents . session . on ( 'select-serial-port' , ( event , portList , webContents , callback ) = > {
if ( portList . length > 0 ) {
havePorts = true ;
callback ( portList [ 0 ] . portId ) ;
} else {
callback ( '' ) ;
}
} ) ;
w . webContents . session . on ( 'serial-port-revoked' , ( event , details ) = > {
forgottenPortFromEvent = details . port ;
} ) ;
await getPorts ( ) ;
if ( havePorts ) {
const grantedPorts = await w . webContents . executeJavaScript ( 'navigator.serial.getPorts()' ) ;
if ( grantedPorts . length > 0 ) {
const forgottenPort = await w . webContents . executeJavaScript ( `
navigator . serial . getPorts ( ) . then ( async ( ports ) = > {
const portInfo = await ports [ 0 ] . getInfo ( ) ;
await ports [ 0 ] . forget ( ) ;
if ( portInfo . usbVendorId && portInfo . usbProductId ) {
return {
vendorId : '' + portInfo . usbVendorId ,
productId : '' + portInfo . usbProductId
}
} else {
return { } ;
}
} )
` );
const grantedPorts2 = await w . webContents . executeJavaScript ( 'navigator.serial.getPorts()' ) ;
expect ( grantedPorts2 . length ) . to . be . lessThan ( grantedPorts . length ) ;
if ( forgottenPort . vendorId && forgottenPort . productId ) {
expect ( forgottenPortFromEvent ) . to . include ( forgottenPort ) ;
}
}
}
} ) ;
2020-09-28 16:22:03 +00:00
} ) ;
2020-10-29 18:22:32 +00:00
describe ( 'navigator.clipboard' , ( ) = > {
let w : BrowserWindow ;
before ( async ( ) = > {
w = new BrowserWindow ( {
webPreferences : {
enableBlinkFeatures : 'Serial'
}
} ) ;
await w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
} ) ;
const readClipboard : any = ( ) = > {
return w . webContents . executeJavaScript ( `
navigator . clipboard . read ( ) . then ( clipboard = > clipboard . toString ( ) ) . catch ( err = > err . message ) ;
` , true);
} ;
after ( closeAllWindows ) ;
afterEach ( ( ) = > {
session . defaultSession . setPermissionRequestHandler ( null ) ;
} ) ;
it ( 'returns clipboard contents when a PermissionRequestHandler is not defined' , async ( ) = > {
const clipboard = await readClipboard ( ) ;
expect ( clipboard ) . to . not . equal ( 'Read permission denied.' ) ;
} ) ;
it ( 'returns an error when permission denied' , async ( ) = > {
session . defaultSession . setPermissionRequestHandler ( ( wc , permission , callback ) = > {
if ( permission === 'clipboard-read' ) {
callback ( false ) ;
} else {
callback ( true ) ;
}
} ) ;
const clipboard = await readClipboard ( ) ;
expect ( clipboard ) . to . equal ( 'Read permission denied.' ) ;
} ) ;
it ( 'returns clipboard contents when permission is granted' , async ( ) = > {
session . defaultSession . setPermissionRequestHandler ( ( wc , permission , callback ) = > {
if ( permission === 'clipboard-read' ) {
callback ( true ) ;
} else {
callback ( false ) ;
}
} ) ;
const clipboard = await readClipboard ( ) ;
expect ( clipboard ) . to . not . equal ( 'Read permission denied.' ) ;
} ) ;
} ) ;
2021-01-21 05:45:06 +00:00
ifdescribe ( ( process . platform !== 'linux' || app . isUnityRunning ( ) ) ) ( 'navigator.setAppBadge/clearAppBadge' , ( ) = > {
let w : BrowserWindow ;
const expectedBadgeCount = 42 ;
const fireAppBadgeAction : any = ( action : string , value : any ) = > {
return w . webContents . executeJavaScript ( `
navigator . $ { action } AppBadge ( $ { value } ) . then ( ( ) = > 'success' ) . catch ( err = > err . message ) ` );
} ;
// For some reason on macOS changing the badge count doesn't happen right away, so wait
// until it changes.
async function waitForBadgeCount ( value : number ) {
let badgeCount = app . getBadgeCount ( ) ;
while ( badgeCount !== value ) {
await new Promise ( resolve = > setTimeout ( resolve , 10 ) ) ;
badgeCount = app . getBadgeCount ( ) ;
}
return badgeCount ;
}
2021-03-05 01:12:03 +00:00
describe ( 'in the renderer' , ( ) = > {
before ( async ( ) = > {
w = new BrowserWindow ( {
show : false
} ) ;
await w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
} ) ;
2021-01-21 05:45:06 +00:00
2021-03-05 01:12:03 +00:00
after ( ( ) = > {
app . badgeCount = 0 ;
closeAllWindows ( ) ;
} ) ;
2021-01-21 05:45:06 +00:00
2021-03-05 01:12:03 +00:00
it ( 'setAppBadge can set a numerical value' , async ( ) = > {
const result = await fireAppBadgeAction ( 'set' , expectedBadgeCount ) ;
expect ( result ) . to . equal ( 'success' ) ;
expect ( waitForBadgeCount ( expectedBadgeCount ) ) . to . eventually . equal ( expectedBadgeCount ) ;
} ) ;
it ( 'setAppBadge can set an empty(dot) value' , async ( ) = > {
const result = await fireAppBadgeAction ( 'set' ) ;
expect ( result ) . to . equal ( 'success' ) ;
expect ( waitForBadgeCount ( 0 ) ) . to . eventually . equal ( 0 ) ;
} ) ;
it ( 'clearAppBadge can clear a value' , async ( ) = > {
let result = await fireAppBadgeAction ( 'set' , expectedBadgeCount ) ;
expect ( result ) . to . equal ( 'success' ) ;
expect ( waitForBadgeCount ( expectedBadgeCount ) ) . to . eventually . equal ( expectedBadgeCount ) ;
result = await fireAppBadgeAction ( 'clear' ) ;
expect ( result ) . to . equal ( 'success' ) ;
expect ( waitForBadgeCount ( 0 ) ) . to . eventually . equal ( 0 ) ;
} ) ;
2021-01-21 05:45:06 +00:00
} ) ;
2021-03-05 01:12:03 +00:00
describe ( 'in a service worker' , ( ) = > {
beforeEach ( async ( ) = > {
w = new BrowserWindow ( {
show : false ,
webPreferences : {
nodeIntegration : true ,
partition : 'sw-file-scheme-spec' ,
contextIsolation : false
}
} ) ;
} ) ;
afterEach ( ( ) = > {
app . badgeCount = 0 ;
closeAllWindows ( ) ;
} ) ;
it ( 'setAppBadge can be called in a ServiceWorker' , ( done ) = > {
w . webContents . on ( 'ipc-message' , ( event , channel , message ) = > {
if ( channel === 'reload' ) {
w . webContents . reload ( ) ;
} else if ( channel === 'error' ) {
done ( message ) ;
} else if ( channel === 'response' ) {
expect ( message ) . to . equal ( 'SUCCESS setting app badge' ) ;
expect ( waitForBadgeCount ( expectedBadgeCount ) ) . to . eventually . equal ( expectedBadgeCount ) ;
session . fromPartition ( 'sw-file-scheme-spec' ) . clearStorageData ( {
storages : [ 'serviceworkers' ]
} ) . then ( ( ) = > done ( ) ) ;
}
} ) ;
w . webContents . on ( 'crashed' , ( ) = > done ( new Error ( 'WebContents crashed.' ) ) ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'service-worker' , 'badge-index.html' ) , { search : '?setBadge' } ) ;
} ) ;
it ( 'clearAppBadge can be called in a ServiceWorker' , ( done ) = > {
w . webContents . on ( 'ipc-message' , ( event , channel , message ) = > {
if ( channel === 'reload' ) {
w . webContents . reload ( ) ;
} else if ( channel === 'setAppBadge' ) {
expect ( message ) . to . equal ( 'SUCCESS setting app badge' ) ;
expect ( waitForBadgeCount ( expectedBadgeCount ) ) . to . eventually . equal ( expectedBadgeCount ) ;
} else if ( channel === 'error' ) {
done ( message ) ;
} else if ( channel === 'response' ) {
expect ( message ) . to . equal ( 'SUCCESS clearing app badge' ) ;
expect ( waitForBadgeCount ( expectedBadgeCount ) ) . to . eventually . equal ( expectedBadgeCount ) ;
session . fromPartition ( 'sw-file-scheme-spec' ) . clearStorageData ( {
storages : [ 'serviceworkers' ]
} ) . then ( ( ) = > done ( ) ) ;
}
} ) ;
w . webContents . on ( 'crashed' , ( ) = > done ( new Error ( 'WebContents crashed.' ) ) ) ;
w . loadFile ( path . join ( fixturesPath , 'pages' , 'service-worker' , 'badge-index.html' ) , { search : '?clearBadge' } ) ;
} ) ;
2021-01-21 05:45:06 +00:00
} ) ;
} ) ;
2021-02-26 19:10:27 +00:00
describe ( 'navigator.bluetooth' , ( ) = > {
let w : BrowserWindow ;
before ( async ( ) = > {
w = new BrowserWindow ( {
show : false ,
webPreferences : {
enableBlinkFeatures : 'WebBluetooth'
}
} ) ;
await w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
} ) ;
after ( closeAllWindows ) ;
it ( 'can request bluetooth devices' , async ( ) = > {
const bluetooth = await w . webContents . executeJavaScript ( `
navigator . bluetooth . requestDevice ( { acceptAllDevices : true } ) . then ( device = > "Found a device!" ) . catch ( err = > err . message ) ; ` , true);
expect ( bluetooth ) . to . be . oneOf ( [ 'Found a device!' , 'Bluetooth adapter not available.' , 'User cancelled the requestDevice() chooser.' ] ) ;
} ) ;
} ) ;
2021-09-23 11:00:11 +00:00
describe ( 'navigator.hid' , ( ) = > {
let w : BrowserWindow ;
let server : http.Server ;
let serverUrl : string ;
before ( async ( ) = > {
w = new BrowserWindow ( {
show : false
} ) ;
await w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
server = http . createServer ( ( req , res ) = > {
res . setHeader ( 'Content-Type' , 'text/html' ) ;
res . end ( '<body>' ) ;
} ) ;
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
serverUrl = ` http://localhost: ${ ( server . address ( ) as any ) . port } ` ;
} ) ;
2022-05-23 19:13:18 +00:00
const requestDevices : any = ( ) = > {
2021-09-23 11:00:11 +00:00
return w . webContents . executeJavaScript ( `
navigator . hid . requestDevice ( { filters : [ ] } ) . then ( device = > device . toString ( ) ) . catch ( err = > err . toString ( ) ) ;
` , true);
} ;
after ( ( ) = > {
server . close ( ) ;
closeAllWindows ( ) ;
} ) ;
afterEach ( ( ) = > {
session . defaultSession . setPermissionCheckHandler ( null ) ;
session . defaultSession . setDevicePermissionHandler ( null ) ;
session . defaultSession . removeAllListeners ( 'select-hid-device' ) ;
} ) ;
it ( 'does not return a device if select-hid-device event is not defined' , async ( ) = > {
w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
2022-05-23 19:13:18 +00:00
const device = await requestDevices ( ) ;
2021-09-23 11:00:11 +00:00
expect ( device ) . to . equal ( '' ) ;
} ) ;
it ( 'does not return a device when permission denied' , async ( ) = > {
let selectFired = false ;
w . webContents . session . on ( 'select-hid-device' , ( event , details , callback ) = > {
selectFired = true ;
callback ( ) ;
} ) ;
session . defaultSession . setPermissionCheckHandler ( ( ) = > false ) ;
2022-05-23 19:13:18 +00:00
const device = await requestDevices ( ) ;
2021-09-23 11:00:11 +00:00
expect ( selectFired ) . to . be . false ( ) ;
expect ( device ) . to . equal ( '' ) ;
} ) ;
it ( 'returns a device when select-hid-device event is defined' , async ( ) = > {
let haveDevices = false ;
let selectFired = false ;
w . webContents . session . on ( 'select-hid-device' , ( event , details , callback ) = > {
expect ( details . frame ) . to . have . ownProperty ( 'frameTreeNodeId' ) . that . is . a ( 'number' ) ;
selectFired = true ;
if ( details . deviceList . length > 0 ) {
haveDevices = true ;
callback ( details . deviceList [ 0 ] . deviceId ) ;
} else {
callback ( ) ;
}
} ) ;
2022-05-23 19:13:18 +00:00
const device = await requestDevices ( ) ;
2021-09-23 11:00:11 +00:00
expect ( selectFired ) . to . be . true ( ) ;
if ( haveDevices ) {
expect ( device ) . to . contain ( '[object HIDDevice]' ) ;
} else {
expect ( device ) . to . equal ( '' ) ;
}
2022-10-27 16:37:04 +00:00
if ( haveDevices ) {
2021-09-23 11:00:11 +00:00
// Verify that navigation will clear device permissions
const grantedDevices = await w . webContents . executeJavaScript ( 'navigator.hid.getDevices()' ) ;
expect ( grantedDevices ) . to . not . be . empty ( ) ;
w . loadURL ( serverUrl ) ;
const [ , , , , , frameProcessId , frameRoutingId ] = await emittedOnce ( w . webContents , 'did-frame-navigate' ) ;
const frame = webFrameMain . fromId ( frameProcessId , frameRoutingId ) ;
expect ( frame ) . to . not . be . empty ( ) ;
if ( frame ) {
const grantedDevicesOnNewPage = await frame . executeJavaScript ( 'navigator.hid.getDevices()' ) ;
expect ( grantedDevicesOnNewPage ) . to . be . empty ( ) ;
}
}
} ) ;
it ( 'returns a device when DevicePermissionHandler is defined' , async ( ) = > {
let haveDevices = false ;
let selectFired = false ;
let gotDevicePerms = false ;
w . webContents . session . on ( 'select-hid-device' , ( event , details , callback ) = > {
selectFired = true ;
if ( details . deviceList . length > 0 ) {
const foundDevice = details . deviceList . find ( ( device ) = > {
if ( device . name && device . name !== '' && device . serialNumber && device . serialNumber !== '' ) {
haveDevices = true ;
return true ;
}
} ) ;
if ( foundDevice ) {
callback ( foundDevice . deviceId ) ;
return ;
}
}
callback ( ) ;
} ) ;
session . defaultSession . setDevicePermissionHandler ( ( ) = > {
gotDevicePerms = true ;
return true ;
} ) ;
await w . webContents . executeJavaScript ( 'navigator.hid.getDevices();' , true ) ;
2022-05-23 19:13:18 +00:00
const device = await requestDevices ( ) ;
2021-09-23 11:00:11 +00:00
expect ( selectFired ) . to . be . true ( ) ;
if ( haveDevices ) {
expect ( device ) . to . contain ( '[object HIDDevice]' ) ;
expect ( gotDevicePerms ) . to . be . true ( ) ;
} else {
expect ( device ) . to . equal ( '' ) ;
}
} ) ;
2022-04-12 11:19:14 +00:00
2022-05-23 19:13:18 +00:00
it ( 'excludes a device when a exclusionFilter is specified' , async ( ) = > {
2022-04-12 11:19:14 +00:00
const exclusionFilters = < any > [ ] ;
let haveDevices = false ;
let checkForExcludedDevice = false ;
w . webContents . session . on ( 'select-hid-device' , ( event , details , callback ) = > {
if ( details . deviceList . length > 0 ) {
details . deviceList . find ( ( device ) = > {
if ( device . name && device . name !== '' && device . serialNumber && device . serialNumber !== '' ) {
if ( checkForExcludedDevice ) {
const compareDevice = {
vendorId : device.vendorId ,
productId : device.productId
} ;
expect ( compareDevice ) . to . not . equal ( exclusionFilters [ 0 ] , 'excluded device should not be returned' ) ;
} else {
haveDevices = true ;
exclusionFilters . push ( {
vendorId : device.vendorId ,
productId : device.productId
} ) ;
return true ;
}
}
} ) ;
}
callback ( ) ;
} ) ;
2022-05-23 19:13:18 +00:00
await requestDevices ( ) ;
2022-04-12 11:19:14 +00:00
if ( haveDevices ) {
2022-06-16 07:46:11 +00:00
// We have devices to exclude, so check if exclusionFilters work
2022-04-12 11:19:14 +00:00
checkForExcludedDevice = true ;
await w . webContents . executeJavaScript ( `
navigator . hid . requestDevice ( { filters : [ ] , exclusionFilters : $ { JSON . stringify ( exclusionFilters ) } } ) . then ( device = > device . toString ( ) ) . catch ( err = > err . toString ( ) ) ;
2022-05-23 19:13:18 +00:00
2022-04-12 11:19:14 +00:00
` , true);
}
} ) ;
2022-05-23 19:13:18 +00:00
it ( 'supports device.forget()' , async ( ) = > {
let deletedDeviceFromEvent ;
let haveDevices = false ;
w . webContents . session . on ( 'select-hid-device' , ( event , details , callback ) = > {
if ( details . deviceList . length > 0 ) {
haveDevices = true ;
callback ( details . deviceList [ 0 ] . deviceId ) ;
} else {
callback ( ) ;
}
} ) ;
w . webContents . session . on ( 'hid-device-revoked' , ( event , details ) = > {
deletedDeviceFromEvent = details . device ;
} ) ;
await requestDevices ( ) ;
if ( haveDevices ) {
const grantedDevices = await w . webContents . executeJavaScript ( 'navigator.hid.getDevices()' ) ;
if ( grantedDevices . length > 0 ) {
const deletedDevice = await w . webContents . executeJavaScript ( `
navigator . hid . getDevices ( ) . then ( devices = > {
devices [ 0 ] . forget ( ) ;
return {
vendorId : devices [ 0 ] . vendorId ,
productId : devices [ 0 ] . productId ,
name : devices [ 0 ] . productName
}
} )
` );
const grantedDevices2 = await w . webContents . executeJavaScript ( 'navigator.hid.getDevices()' ) ;
expect ( grantedDevices2 . length ) . to . be . lessThan ( grantedDevices . length ) ;
if ( deletedDevice . name !== '' && deletedDevice . productId && deletedDevice . vendorId ) {
expect ( deletedDeviceFromEvent ) . to . include ( deletedDevice ) ;
}
}
}
} ) ;
2021-09-23 11:00:11 +00:00
} ) ;
2022-11-22 21:50:32 +00:00
describe ( 'navigator.usb' , ( ) = > {
let w : BrowserWindow ;
let server : http.Server ;
let serverUrl : string ;
before ( async ( ) = > {
w = new BrowserWindow ( {
show : false
} ) ;
await w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
server = http . createServer ( ( req , res ) = > {
res . setHeader ( 'Content-Type' , 'text/html' ) ;
res . end ( '<body>' ) ;
} ) ;
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
serverUrl = ` http://localhost: ${ ( server . address ( ) as any ) . port } ` ;
} ) ;
const requestDevices : any = ( ) = > {
return w . webContents . executeJavaScript ( `
navigator . usb . requestDevice ( { filters : [ ] } ) . then ( device = > device . toString ( ) ) . catch ( err = > err . toString ( ) ) ;
` , true);
} ;
const notFoundError = 'NotFoundError: Failed to execute \'requestDevice\' on \'USB\': No device selected.' ;
after ( ( ) = > {
server . close ( ) ;
closeAllWindows ( ) ;
} ) ;
afterEach ( ( ) = > {
session . defaultSession . setPermissionCheckHandler ( null ) ;
session . defaultSession . setDevicePermissionHandler ( null ) ;
session . defaultSession . removeAllListeners ( 'select-usb-device' ) ;
} ) ;
it ( 'does not return a device if select-usb-device event is not defined' , async ( ) = > {
w . loadFile ( path . join ( fixturesPath , 'pages' , 'blank.html' ) ) ;
const device = await requestDevices ( ) ;
expect ( device ) . to . equal ( notFoundError ) ;
} ) ;
it ( 'does not return a device when permission denied' , async ( ) = > {
let selectFired = false ;
w . webContents . session . on ( 'select-usb-device' , ( event , details , callback ) = > {
selectFired = true ;
callback ( ) ;
} ) ;
session . defaultSession . setPermissionCheckHandler ( ( ) = > false ) ;
const device = await requestDevices ( ) ;
expect ( selectFired ) . to . be . false ( ) ;
expect ( device ) . to . equal ( notFoundError ) ;
} ) ;
it ( 'returns a device when select-usb-device event is defined' , async ( ) = > {
let haveDevices = false ;
let selectFired = false ;
w . webContents . session . on ( 'select-usb-device' , ( event , details , callback ) = > {
expect ( details . frame ) . to . have . ownProperty ( 'frameTreeNodeId' ) . that . is . a ( 'number' ) ;
selectFired = true ;
if ( details . deviceList . length > 0 ) {
haveDevices = true ;
callback ( details . deviceList [ 0 ] . deviceId ) ;
} else {
callback ( ) ;
}
} ) ;
const device = await requestDevices ( ) ;
expect ( selectFired ) . to . be . true ( ) ;
if ( haveDevices ) {
expect ( device ) . to . contain ( '[object USBDevice]' ) ;
} else {
expect ( device ) . to . equal ( notFoundError ) ;
}
if ( haveDevices ) {
// Verify that navigation will clear device permissions
const grantedDevices = await w . webContents . executeJavaScript ( 'navigator.usb.getDevices()' ) ;
expect ( grantedDevices ) . to . not . be . empty ( ) ;
w . loadURL ( serverUrl ) ;
const [ , , , , , frameProcessId , frameRoutingId ] = await emittedOnce ( w . webContents , 'did-frame-navigate' ) ;
const frame = webFrameMain . fromId ( frameProcessId , frameRoutingId ) ;
expect ( frame ) . to . not . be . empty ( ) ;
if ( frame ) {
const grantedDevicesOnNewPage = await frame . executeJavaScript ( 'navigator.usb.getDevices()' ) ;
expect ( grantedDevicesOnNewPage ) . to . be . empty ( ) ;
}
}
} ) ;
it ( 'returns a device when DevicePermissionHandler is defined' , async ( ) = > {
let haveDevices = false ;
let selectFired = false ;
let gotDevicePerms = false ;
w . webContents . session . on ( 'select-usb-device' , ( event , details , callback ) = > {
selectFired = true ;
if ( details . deviceList . length > 0 ) {
const foundDevice = details . deviceList . find ( ( device ) = > {
if ( device . productName && device . productName !== '' && device . serialNumber && device . serialNumber !== '' ) {
haveDevices = true ;
return true ;
}
} ) ;
if ( foundDevice ) {
callback ( foundDevice . deviceId ) ;
return ;
}
}
callback ( ) ;
} ) ;
session . defaultSession . setDevicePermissionHandler ( ( ) = > {
gotDevicePerms = true ;
return true ;
} ) ;
await w . webContents . executeJavaScript ( 'navigator.usb.getDevices();' , true ) ;
const device = await requestDevices ( ) ;
expect ( selectFired ) . to . be . true ( ) ;
if ( haveDevices ) {
expect ( device ) . to . contain ( '[object USBDevice]' ) ;
expect ( gotDevicePerms ) . to . be . true ( ) ;
} else {
expect ( device ) . to . equal ( notFoundError ) ;
}
} ) ;
it ( 'supports device.forget()' , async ( ) = > {
let deletedDeviceFromEvent ;
let haveDevices = false ;
w . webContents . session . on ( 'select-usb-device' , ( event , details , callback ) = > {
if ( details . deviceList . length > 0 ) {
haveDevices = true ;
callback ( details . deviceList [ 0 ] . deviceId ) ;
} else {
callback ( ) ;
}
} ) ;
w . webContents . session . on ( 'usb-device-revoked' , ( event , details ) = > {
deletedDeviceFromEvent = details . device ;
} ) ;
await requestDevices ( ) ;
if ( haveDevices ) {
const grantedDevices = await w . webContents . executeJavaScript ( 'navigator.usb.getDevices()' ) ;
if ( grantedDevices . length > 0 ) {
const deletedDevice = await w . webContents . executeJavaScript ( `
navigator . usb . getDevices ( ) . then ( devices = > {
devices [ 0 ] . forget ( ) ;
return {
vendorId : devices [ 0 ] . vendorId ,
productId : devices [ 0 ] . productId ,
productName : devices [ 0 ] . productName
}
} )
` );
const grantedDevices2 = await w . webContents . executeJavaScript ( 'navigator.usb.getDevices()' ) ;
expect ( grantedDevices2 . length ) . to . be . lessThan ( grantedDevices . length ) ;
if ( deletedDevice . name !== '' && deletedDevice . productId && deletedDevice . vendorId ) {
expect ( deletedDeviceFromEvent ) . to . include ( deletedDevice ) ;
}
}
}
} ) ;
} ) ;