2020-03-20 20:28:31 +00:00
import { expect } from 'chai' ;
import * as http from 'http' ;
import * as https from 'https' ;
import * as path from 'path' ;
import * as fs from 'fs' ;
import * as ChildProcess from 'child_process' ;
2020-05-19 17:18:12 +00:00
import { app , session , BrowserWindow , net , ipcMain , Session } from 'electron/main' ;
2020-03-20 20:28:31 +00:00
import * as send from 'send' ;
import * as auth from 'basic-auth' ;
import { closeAllWindows } from './window-helpers' ;
import { emittedOnce } from './events-helpers' ;
2020-10-27 17:53:27 +00:00
import { defer , delay } from './spec-helpers' ;
2020-03-20 20:28:31 +00:00
import { AddressInfo } from 'net' ;
2019-05-28 21:12:59 +00:00
/* The whole session API doesn't use standard callbacks */
/* eslint-disable standard/no-callback-literal */
describe ( 'session module' , ( ) = > {
2020-03-20 20:28:31 +00:00
const fixtures = path . resolve ( __dirname , '..' , 'spec' , 'fixtures' ) ;
const url = 'http://127.0.0.1' ;
2019-05-28 21:12:59 +00:00
describe ( 'session.defaultSession' , ( ) = > {
it ( 'returns the default session' , ( ) = > {
2020-03-20 20:28:31 +00:00
expect ( session . defaultSession ) . to . equal ( session . fromPartition ( '' ) ) ;
} ) ;
} ) ;
2019-05-28 21:12:59 +00:00
describe ( 'session.fromPartition(partition, options)' , ( ) = > {
it ( 'returns existing session with same partition' , ( ) = > {
2020-03-20 20:28:31 +00:00
expect ( session . fromPartition ( 'test' ) ) . to . equal ( session . fromPartition ( 'test' ) ) ;
} ) ;
} ) ;
2019-05-28 21:12:59 +00:00
describe ( 'ses.cookies' , ( ) = > {
2020-03-20 20:28:31 +00:00
const name = '0' ;
const value = '0' ;
afterEach ( closeAllWindows ) ;
2019-05-28 21:12:59 +00:00
2019-12-11 07:44:49 +00:00
// Clear cookie of defaultSession after each test.
afterEach ( async ( ) = > {
2020-03-20 20:28:31 +00:00
const { cookies } = session . defaultSession ;
const cs = await cookies . get ( { url } ) ;
2019-12-11 07:44:49 +00:00
for ( const c of cs ) {
2020-03-20 20:28:31 +00:00
await cookies . remove ( url , c . name ) ;
2019-12-11 07:44:49 +00:00
}
2020-03-20 20:28:31 +00:00
} ) ;
2019-12-11 07:44:49 +00:00
2019-05-30 22:05:02 +00:00
it ( 'should get cookies' , async ( ) = > {
2019-05-28 21:12:59 +00:00
const server = http . createServer ( ( req , res ) = > {
2020-03-20 20:28:31 +00:00
res . setHeader ( 'Set-Cookie' , [ ` ${ name } = ${ value } ` ] ) ;
res . end ( 'finished' ) ;
server . close ( ) ;
} ) ;
2021-01-22 19:25:47 +00:00
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
2020-03-20 20:28:31 +00:00
const { port } = server . address ( ) as AddressInfo ;
const w = new BrowserWindow ( { show : false } ) ;
await w . loadURL ( ` ${ url } : ${ port } ` ) ;
const list = await w . webContents . session . cookies . get ( { url } ) ;
const cookie = list . find ( cookie = > cookie . name === name ) ;
expect ( cookie ) . to . exist . and . to . have . property ( 'value' , value ) ;
} ) ;
2019-05-28 21:12:59 +00:00
it ( 'sets cookies' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const { cookies } = session . defaultSession ;
const name = '1' ;
const value = '1' ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
await cookies . set ( { url , name , value , expirationDate : ( + new Date ( ) ) / 1000 + 120 } ) ;
const c = ( await cookies . get ( { url } ) ) [ 0 ] ;
expect ( c . name ) . to . equal ( name ) ;
expect ( c . value ) . to . equal ( value ) ;
expect ( c . session ) . to . equal ( false ) ;
} ) ;
2019-12-11 07:44:49 +00:00
it ( 'sets session cookies' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const { cookies } = session . defaultSession ;
const name = '2' ;
const value = '1' ;
2019-12-11 07:44:49 +00:00
2020-03-20 20:28:31 +00:00
await cookies . set ( { url , name , value } ) ;
const c = ( await cookies . get ( { url } ) ) [ 0 ] ;
expect ( c . name ) . to . equal ( name ) ;
expect ( c . value ) . to . equal ( value ) ;
expect ( c . session ) . to . equal ( true ) ;
} ) ;
2019-12-11 07:44:49 +00:00
it ( 'sets cookies without name' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const { cookies } = session . defaultSession ;
const value = '3' ;
2019-12-11 07:44:49 +00:00
2020-03-20 20:28:31 +00:00
await cookies . set ( { url , value } ) ;
const c = ( await cookies . get ( { url } ) ) [ 0 ] ;
expect ( c . name ) . to . be . empty ( ) ;
expect ( c . value ) . to . equal ( value ) ;
} ) ;
2019-05-28 21:12:59 +00:00
2020-04-02 18:28:43 +00:00
for ( const sameSite of < const > [ 'unspecified' , 'no_restriction' , 'lax' , 'strict' ] ) {
it ( ` sets cookies with samesite= ${ sameSite } ` , async ( ) = > {
const { cookies } = session . defaultSession ;
const value = 'hithere' ;
await cookies . set ( { url , value , sameSite } ) ;
const c = ( await cookies . get ( { url } ) ) [ 0 ] ;
expect ( c . name ) . to . be . empty ( ) ;
expect ( c . value ) . to . equal ( value ) ;
expect ( c . sameSite ) . to . equal ( sameSite ) ;
} ) ;
}
2020-07-09 17:18:49 +00:00
it ( 'fails to set cookies with samesite=garbage' , async ( ) = > {
2020-04-02 18:28:43 +00:00
const { cookies } = session . defaultSession ;
const value = 'hithere' ;
await expect ( cookies . set ( { url , value , sameSite : 'garbage' as any } ) ) . to . eventually . be . rejectedWith ( 'Failed to convert \'garbage\' to an appropriate cookie same site value' ) ;
} ) ;
2019-10-09 06:57:40 +00:00
it ( 'gets cookies without url' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const { cookies } = session . defaultSession ;
const name = '1' ;
const value = '1' ;
2019-10-09 06:57:40 +00:00
2020-03-20 20:28:31 +00:00
await cookies . set ( { url , name , value , expirationDate : ( + new Date ( ) ) / 1000 + 120 } ) ;
const cs = await cookies . get ( { domain : '127.0.0.1' } ) ;
expect ( cs . some ( c = > c . name === name && c . value === value ) ) . to . equal ( true ) ;
} ) ;
2019-10-09 06:57:40 +00:00
2019-05-28 21:12:59 +00:00
it ( 'yields an error when setting a cookie with missing required fields' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const { cookies } = session . defaultSession ;
const name = '1' ;
const value = '1' ;
2019-06-13 02:49:36 +00:00
await expect (
cookies . set ( { url : '' , name , value } )
2020-03-20 20:28:31 +00:00
) . to . eventually . be . rejectedWith ( 'Failed to get cookie domain' ) ;
} ) ;
2019-06-13 02:49:36 +00:00
it ( 'yields an error when setting a cookie with an invalid URL' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const { cookies } = session . defaultSession ;
const name = '1' ;
const value = '1' ;
2019-06-13 02:49:36 +00:00
await expect (
cookies . set ( { url : 'asdf' , name , value } )
2020-03-20 20:28:31 +00:00
) . to . eventually . be . rejectedWith ( 'Failed to get cookie domain' ) ;
} ) ;
2019-05-28 21:12:59 +00:00
it ( 'should overwrite previous cookies' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const { cookies } = session . defaultSession ;
const name = 'DidOverwrite' ;
2020-03-20 15:12:18 +00:00
for ( const value of [ 'No' , 'Yes' ] ) {
2020-03-20 20:28:31 +00:00
await cookies . set ( { url , name , value , expirationDate : ( + new Date ( ) ) / 1000 + 120 } ) ;
const list = await cookies . get ( { url } ) ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
expect ( list . some ( cookie = > cookie . name === name && cookie . value === value ) ) . to . equal ( true ) ;
2019-05-28 21:12:59 +00:00
}
2020-03-20 20:28:31 +00:00
} ) ;
2019-05-28 21:12:59 +00:00
it ( 'should remove cookies' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const { cookies } = session . defaultSession ;
const name = '2' ;
const value = '2' ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
await cookies . set ( { url , name , value , expirationDate : ( + new Date ( ) ) / 1000 + 120 } ) ;
await cookies . remove ( url , name ) ;
const list = await cookies . get ( { url } ) ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
expect ( list . some ( cookie = > cookie . name === name && cookie . value === value ) ) . to . equal ( false ) ;
} ) ;
2019-05-28 21:12:59 +00:00
2019-08-02 23:56:46 +00:00
it . skip ( 'should set cookie for standard scheme' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const { cookies } = session . defaultSession ;
const domain = 'fake-host' ;
const url = ` ${ standardScheme } :// ${ domain } ` ;
const name = 'custom' ;
const value = '1' ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
await cookies . set ( { url , name , value , expirationDate : ( + new Date ( ) ) / 1000 + 120 } ) ;
const list = await cookies . get ( { url } ) ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
expect ( list ) . to . have . lengthOf ( 1 ) ;
expect ( list [ 0 ] ) . to . have . property ( 'name' , name ) ;
expect ( list [ 0 ] ) . to . have . property ( 'value' , value ) ;
expect ( list [ 0 ] ) . to . have . property ( 'domain' , domain ) ;
} ) ;
2019-05-28 21:12:59 +00:00
it ( 'emits a changed event when a cookie is added or removed' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const { cookies } = session . fromPartition ( 'cookies-changed' ) ;
const name = 'foo' ;
const value = 'bar' ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
const a = emittedOnce ( cookies , 'changed' ) ;
await cookies . set ( { url , name , value , expirationDate : ( + new Date ( ) ) / 1000 + 120 } ) ;
const [ , setEventCookie , setEventCause , setEventRemoved ] = await a ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
const b = emittedOnce ( cookies , 'changed' ) ;
await cookies . remove ( url , name ) ;
const [ , removeEventCookie , removeEventCause , removeEventRemoved ] = await b ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
expect ( setEventCookie . name ) . to . equal ( name ) ;
expect ( setEventCookie . value ) . to . equal ( value ) ;
expect ( setEventCause ) . to . equal ( 'explicit' ) ;
expect ( setEventRemoved ) . to . equal ( false ) ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
expect ( removeEventCookie . name ) . to . equal ( name ) ;
expect ( removeEventCookie . value ) . to . equal ( value ) ;
expect ( removeEventCause ) . to . equal ( 'explicit' ) ;
expect ( removeEventRemoved ) . to . equal ( true ) ;
} ) ;
2019-05-28 21:12:59 +00:00
describe ( 'ses.cookies.flushStore()' , async ( ) = > {
2019-05-30 22:05:02 +00:00
it ( 'flushes the cookies to disk' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const name = 'foo' ;
const value = 'bar' ;
const { cookies } = session . defaultSession ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
await cookies . set ( { url , name , value } ) ;
await cookies . flushStore ( ) ;
} ) ;
} ) ;
2019-05-28 21:12:59 +00:00
2022-06-01 06:12:47 +00:00
it ( 'should survive an app restart for persistent partition' , async function ( ) {
this . timeout ( 60000 ) ;
2020-03-20 20:28:31 +00:00
const appPath = path . join ( fixtures , 'api' , 'cookie-app' ) ;
2019-05-28 21:12:59 +00:00
2019-08-27 21:55:19 +00:00
const runAppWithPhase = ( phase : string ) = > {
2019-11-01 20:37:02 +00:00
return new Promise ( ( resolve ) = > {
2020-03-20 20:28:31 +00:00
let output = '' ;
2019-05-28 21:12:59 +00:00
const appProcess = ChildProcess . spawn (
2019-05-30 22:05:02 +00:00
process . execPath ,
2019-05-28 21:12:59 +00:00
[ appPath ] ,
{ env : { PHASE : phase , . . . process . env } }
2020-03-20 20:28:31 +00:00
) ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
appProcess . stdout . on ( 'data' , data = > { output += data ; } ) ;
2020-01-27 01:29:50 +00:00
appProcess . on ( 'exit' , ( ) = > {
2020-03-20 20:28:31 +00:00
resolve ( output . replace ( /(\r\n|\n|\r)/gm , '' ) ) ;
} ) ;
} ) ;
} ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
expect ( await runAppWithPhase ( 'one' ) ) . to . equal ( '011' ) ;
expect ( await runAppWithPhase ( 'two' ) ) . to . equal ( '110' ) ;
} ) ;
} ) ;
2019-05-28 21:12:59 +00:00
describe ( 'ses.clearStorageData(options)' , ( ) = > {
2020-03-20 20:28:31 +00:00
afterEach ( closeAllWindows ) ;
2019-05-28 21:12:59 +00:00
it ( 'clears localstorage data' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const w = new BrowserWindow ( { show : false , webPreferences : { nodeIntegration : true } } ) ;
await w . loadFile ( path . join ( fixtures , 'api' , 'localstorage.html' ) ) ;
2019-05-28 21:12:59 +00:00
const options = {
origin : 'file://' ,
storages : [ 'localstorage' ] ,
quotas : [ 'persistent' ]
2020-03-20 20:28:31 +00:00
} ;
await w . webContents . session . clearStorageData ( options ) ;
2019-05-28 21:12:59 +00:00
while ( await w . webContents . executeJavaScript ( 'localStorage.length' ) !== 0 ) {
// The storage clear isn't instantly visible to the renderer, so keep
// trying until it is.
}
2020-03-20 20:28:31 +00:00
} ) ;
} ) ;
2019-05-28 21:12:59 +00:00
describe ( 'will-download event' , ( ) = > {
2020-03-20 20:28:31 +00:00
afterEach ( closeAllWindows ) ;
2019-05-30 22:05:02 +00:00
it ( 'can cancel default download behavior' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const w = new BrowserWindow ( { show : false } ) ;
const mockFile = Buffer . alloc ( 1024 ) ;
const contentDisposition = 'inline; filename="mockFile.txt"' ;
2019-05-28 21:12:59 +00:00
const downloadServer = http . createServer ( ( req , res ) = > {
res . writeHead ( 200 , {
'Content-Length' : mockFile . length ,
'Content-Type' : 'application/plain' ,
'Content-Disposition' : contentDisposition
2020-03-20 20:28:31 +00:00
} ) ;
res . end ( mockFile ) ;
downloadServer . close ( ) ;
} ) ;
2021-01-22 19:25:47 +00:00
await new Promise < void > ( resolve = > downloadServer . listen ( 0 , '127.0.0.1' , resolve ) ) ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
const port = ( downloadServer . address ( ) as AddressInfo ) . port ;
const url = ` http://127.0.0.1: ${ port } / ` ;
2019-05-28 21:12:59 +00:00
2019-09-25 21:38:50 +00:00
const downloadPrevented : Promise < { itemUrl : string , itemFilename : string , item : Electron.DownloadItem } > = new Promise ( resolve = > {
2019-05-28 21:12:59 +00:00
w . webContents . session . once ( 'will-download' , function ( e , item ) {
2020-03-20 20:28:31 +00:00
e . preventDefault ( ) ;
resolve ( { itemUrl : item.getURL ( ) , itemFilename : item.getFilename ( ) , item } ) ;
} ) ;
} ) ;
w . loadURL ( url ) ;
const { item , itemUrl , itemFilename } = await downloadPrevented ;
expect ( itemUrl ) . to . equal ( url ) ;
expect ( itemFilename ) . to . equal ( 'mockFile.txt' ) ;
2020-06-17 17:08:10 +00:00
// Delay till the next tick.
2021-01-22 19:25:47 +00:00
await new Promise < void > ( resolve = > setImmediate ( ( ) = > resolve ( ) ) ) ;
2020-04-03 00:22:46 +00:00
expect ( ( ) = > item . getURL ( ) ) . to . throw ( 'DownloadItem used after being destroyed' ) ;
2020-03-20 20:28:31 +00:00
} ) ;
} ) ;
2019-05-28 21:12:59 +00:00
describe ( 'ses.protocol' , ( ) = > {
2020-03-20 20:28:31 +00:00
const partitionName = 'temp' ;
const protocolName = 'sp' ;
let customSession : Session ;
const protocol = session . defaultSession . protocol ;
2019-08-27 21:55:19 +00:00
const handler = ( ignoredError : any , callback : Function ) = > {
2020-03-20 20:28:31 +00:00
callback ( { data : '<script>require(\'electron\').ipcRenderer.send(\'hello\')</script>' , mimeType : 'text/html' } ) ;
} ;
2019-05-28 21:12:59 +00:00
2019-05-30 22:05:02 +00:00
beforeEach ( async ( ) = > {
2020-03-20 20:28:31 +00:00
customSession = session . fromPartition ( partitionName ) ;
await customSession . protocol . registerStringProtocol ( protocolName , handler ) ;
} ) ;
2019-05-28 21:12:59 +00:00
2019-05-30 22:05:02 +00:00
afterEach ( async ( ) = > {
2020-03-20 20:28:31 +00:00
await customSession . protocol . unregisterProtocol ( protocolName ) ;
customSession = null as any ;
} ) ;
afterEach ( closeAllWindows ) ;
2019-05-28 21:12:59 +00:00
2020-06-02 16:46:18 +00:00
it ( 'does not affect defaultSession' , ( ) = > {
const result1 = protocol . isProtocolRegistered ( protocolName ) ;
2020-03-20 20:28:31 +00:00
expect ( result1 ) . to . equal ( false ) ;
2019-05-28 21:12:59 +00:00
2020-06-02 16:46:18 +00:00
const result2 = customSession . protocol . isProtocolRegistered ( protocolName ) ;
2020-03-20 20:28:31 +00:00
expect ( result2 ) . to . equal ( true ) ;
} ) ;
2019-05-28 21:12:59 +00:00
it ( 'handles requests from partition' , async ( ) = > {
2019-08-29 06:50:14 +00:00
const w = new BrowserWindow ( {
show : false ,
webPreferences : {
partition : partitionName ,
2021-03-01 21:52:29 +00:00
nodeIntegration : true ,
contextIsolation : false
2019-08-29 06:50:14 +00:00
}
2020-03-20 20:28:31 +00:00
} ) ;
customSession = session . fromPartition ( partitionName ) ;
await customSession . protocol . registerStringProtocol ( protocolName , handler ) ;
w . loadURL ( ` ${ protocolName } ://fake-host ` ) ;
await emittedOnce ( ipcMain , 'hello' ) ;
} ) ;
} ) ;
2019-05-28 21:12:59 +00:00
describe ( 'ses.setProxy(options)' , ( ) = > {
2020-03-20 20:28:31 +00:00
let server : http.Server ;
let customSession : Electron.Session ;
2020-10-27 17:53:27 +00:00
let created = false ;
2019-05-28 21:12:59 +00:00
2019-05-30 22:05:02 +00:00
beforeEach ( async ( ) = > {
2020-03-20 20:28:31 +00:00
customSession = session . fromPartition ( 'proxyconfig' ) ;
2020-10-27 17:53:27 +00:00
if ( ! created ) {
// Work around for https://github.com/electron/electron/issues/26166 to
// reduce flake
await delay ( 100 ) ;
created = true ;
}
2020-03-20 20:28:31 +00:00
} ) ;
2019-05-28 21:12:59 +00:00
afterEach ( ( ) = > {
if ( server ) {
2020-03-20 20:28:31 +00:00
server . close ( ) ;
2019-05-28 21:12:59 +00:00
}
2020-05-19 17:18:12 +00:00
customSession = null as any ;
2020-03-20 20:28:31 +00:00
} ) ;
2019-05-28 21:12:59 +00:00
it ( 'allows configuring proxy settings' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const config = { proxyRules : 'http=myproxy:80' } ;
await customSession . setProxy ( config ) ;
const proxy = await customSession . resolveProxy ( 'http://example.com/' ) ;
expect ( proxy ) . to . equal ( 'PROXY myproxy:80' ) ;
} ) ;
2019-05-28 21:12:59 +00:00
it ( 'allows removing the implicit bypass rules for localhost' , async ( ) = > {
const config = {
proxyRules : 'http=myproxy:80' ,
proxyBypassRules : '<-loopback>'
2020-03-20 20:28:31 +00:00
} ;
2019-05-28 21:12:59 +00:00
2020-03-20 20:28:31 +00:00
await customSession . setProxy ( config ) ;
const proxy = await customSession . resolveProxy ( 'http://localhost' ) ;
expect ( proxy ) . to . equal ( 'PROXY myproxy:80' ) ;
} ) ;
2019-05-28 21:12:59 +00:00
it ( 'allows configuring proxy settings with pacScript' , async ( ) = > {
server = http . createServer ( ( req , res ) = > {
const pac = `
function FindProxyForURL ( url , host ) {
return "PROXY myproxy:8132" ;
}
2020-03-20 20:28:31 +00:00
` ;
2019-05-28 21:12:59 +00:00
res . writeHead ( 200 , {
'Content-Type' : 'application/x-ns-proxy-autoconfig'
2020-03-20 20:28:31 +00:00
} ) ;
res . end ( pac ) ;
} ) ;
2021-01-22 19:25:47 +00:00
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
2020-10-27 06:50:06 +00:00
{
const config = { pacScript : ` http://127.0.0.1: ${ ( server . address ( ) as AddressInfo ) . port } ` } ;
await customSession . setProxy ( config ) ;
const proxy = await customSession . resolveProxy ( 'https://google.com' ) ;
expect ( proxy ) . to . equal ( 'PROXY myproxy:8132' ) ;
}
{
const config = { mode : 'pac_script' as any , pacScript : ` http://127.0.0.1: ${ ( server . address ( ) as AddressInfo ) . port } ` } ;
await customSession . setProxy ( config ) ;
const proxy = await customSession . resolveProxy ( 'https://google.com' ) ;
expect ( proxy ) . to . equal ( 'PROXY myproxy:8132' ) ;
}
2020-03-20 20:28:31 +00:00
} ) ;
2019-05-28 21:12:59 +00:00
it ( 'allows bypassing proxy settings' , async ( ) = > {
const config = {
proxyRules : 'http=myproxy:80' ,
proxyBypassRules : '<local>'
2020-03-20 20:28:31 +00:00
} ;
await customSession . setProxy ( config ) ;
const proxy = await customSession . resolveProxy ( 'http://example/' ) ;
expect ( proxy ) . to . equal ( 'DIRECT' ) ;
} ) ;
2020-10-27 06:50:06 +00:00
it ( 'allows configuring proxy settings with mode `direct`' , async ( ) = > {
const config = { mode : 'direct' as any , proxyRules : 'http=myproxy:80' } ;
await customSession . setProxy ( config ) ;
const proxy = await customSession . resolveProxy ( 'http://example.com/' ) ;
expect ( proxy ) . to . equal ( 'DIRECT' ) ;
} ) ;
it ( 'allows configuring proxy settings with mode `auto_detect`' , async ( ) = > {
const config = { mode : 'auto_detect' as any } ;
await customSession . setProxy ( config ) ;
} ) ;
it ( 'allows configuring proxy settings with mode `pac_script`' , async ( ) = > {
const config = { mode : 'pac_script' as any } ;
await customSession . setProxy ( config ) ;
const proxy = await customSession . resolveProxy ( 'http://example.com/' ) ;
expect ( proxy ) . to . equal ( 'DIRECT' ) ;
} ) ;
it ( 'allows configuring proxy settings with mode `fixed_servers`' , async ( ) = > {
const config = { mode : 'fixed_servers' as any , proxyRules : 'http=myproxy:80' } ;
await customSession . setProxy ( config ) ;
const proxy = await customSession . resolveProxy ( 'http://example.com/' ) ;
expect ( proxy ) . to . equal ( 'PROXY myproxy:80' ) ;
} ) ;
it ( 'allows configuring proxy settings with mode `system`' , async ( ) = > {
const config = { mode : 'system' as any } ;
await customSession . setProxy ( config ) ;
} ) ;
it ( 'disallows configuring proxy settings with mode `invalid`' , async ( ) = > {
const config = { mode : 'invalid' as any } ;
await expect ( customSession . setProxy ( config ) ) . to . eventually . be . rejectedWith ( /Invalid mode/ ) ;
} ) ;
it ( 'reload proxy configuration' , async ( ) = > {
let proxyPort = 8132 ;
server = http . createServer ( ( req , res ) = > {
const pac = `
function FindProxyForURL ( url , host ) {
return "PROXY myproxy:${proxyPort}" ;
}
` ;
res . writeHead ( 200 , {
'Content-Type' : 'application/x-ns-proxy-autoconfig'
} ) ;
res . end ( pac ) ;
} ) ;
2021-01-22 19:25:47 +00:00
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
2020-10-27 06:50:06 +00:00
const config = { mode : 'pac_script' as any , pacScript : ` http://127.0.0.1: ${ ( server . address ( ) as AddressInfo ) . port } ` } ;
await customSession . setProxy ( config ) ;
{
const proxy = await customSession . resolveProxy ( 'https://google.com' ) ;
expect ( proxy ) . to . equal ( ` PROXY myproxy: ${ proxyPort } ` ) ;
}
{
proxyPort = 8133 ;
await customSession . forceReloadProxyConfig ( ) ;
const proxy = await customSession . resolveProxy ( 'https://google.com' ) ;
expect ( proxy ) . to . equal ( ` PROXY myproxy: ${ proxyPort } ` ) ;
}
} ) ;
2020-03-20 20:28:31 +00:00
} ) ;
2019-05-28 21:12:59 +00:00
2019-09-03 22:54:14 +00:00
describe ( 'ses.getBlobData()' , ( ) = > {
2020-03-20 20:28:31 +00:00
const scheme = 'cors-blob' ;
const protocol = session . defaultSession . protocol ;
const url = ` ${ scheme } ://host ` ;
2019-05-30 22:05:02 +00:00
after ( async ( ) = > {
2020-03-20 20:28:31 +00:00
await protocol . unregisterProtocol ( scheme ) ;
} ) ;
afterEach ( closeAllWindows ) ;
2019-05-28 21:12:59 +00:00
2019-05-30 22:05:02 +00:00
it ( 'returns blob data for uuid' , ( done ) = > {
2019-05-28 21:12:59 +00:00
const postData = JSON . stringify ( {
type : 'blob' ,
value : 'hello'
2020-03-20 20:28:31 +00:00
} ) ;
2019-05-28 21:12:59 +00:00
const content = ` <html>
< script >
let fd = new FormData ( ) ;
fd . append ( 'file' , new Blob ( [ '${postData}' ] , { type : 'application/json' } ) ) ;
fetch ( '${url}' , { method : 'POST' , body : fd } ) ;
< / script >
2020-03-20 20:28:31 +00:00
< / html > ` ;
2019-05-28 21:12:59 +00:00
protocol . registerStringProtocol ( scheme , ( request , callback ) = > {
2020-06-30 22:10:36 +00:00
try {
if ( request . method === 'GET' ) {
callback ( { data : content , mimeType : 'text/html' } ) ;
} else if ( request . method === 'POST' ) {
const uuid = request . uploadData ! [ 1 ] . blobUUID ;
expect ( uuid ) . to . be . a ( 'string' ) ;
session . defaultSession . getBlobData ( uuid ! ) . then ( result = > {
try {
expect ( result . toString ( ) ) . to . equal ( postData ) ;
done ( ) ;
} catch ( e ) {
done ( e ) ;
}
} ) ;
}
} catch ( e ) {
done ( e ) ;
2019-05-28 21:12:59 +00:00
}
2020-03-20 20:28:31 +00:00
} ) ;
2020-06-02 16:46:18 +00:00
const w = new BrowserWindow ( { show : false } ) ;
w . loadURL ( url ) ;
2020-03-20 20:28:31 +00:00
} ) ;
} ) ;
2019-05-28 21:12:59 +00:00
2019-08-27 21:55:19 +00:00
describe ( 'ses.setCertificateVerifyProc(callback)' , ( ) = > {
2020-03-20 20:28:31 +00:00
let server : http.Server ;
2019-05-28 21:12:59 +00:00
beforeEach ( ( done ) = > {
2020-03-20 20:28:31 +00:00
const certPath = path . join ( fixtures , 'certificates' ) ;
2019-05-28 21:12:59 +00:00
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' ) )
] ,
rejectUnauthorized : false
2020-03-20 20:28:31 +00:00
} ;
2019-05-28 21:12:59 +00:00
server = https . createServer ( options , ( req , res ) = > {
2020-03-20 20:28:31 +00:00
res . writeHead ( 200 ) ;
res . end ( '<title>hello</title>' ) ;
} ) ;
server . listen ( 0 , '127.0.0.1' , done ) ;
} ) ;
2019-05-28 21:12:59 +00:00
2019-05-30 22:05:02 +00:00
afterEach ( ( done ) = > {
2020-03-20 20:28:31 +00:00
server . close ( done ) ;
} ) ;
afterEach ( closeAllWindows ) ;
2019-05-28 21:12:59 +00:00
2019-05-30 22:05:02 +00:00
it ( 'accepts the request when the callback is called with 0' , async ( ) = > {
2020-11-17 19:12:50 +00:00
const ses = session . fromPartition ( ` ${ Math . random ( ) } ` ) ;
2021-06-17 21:17:25 +00:00
let validate : ( ) = > void ;
ses . setCertificateVerifyProc ( ( { hostname , verificationResult , errorCode } , callback ) = > {
2021-09-01 22:58:29 +00:00
if ( hostname !== '127.0.0.1' ) return callback ( - 3 ) ;
2021-06-17 21:17:25 +00:00
validate = ( ) = > {
expect ( verificationResult ) . to . be . oneOf ( [ 'net::ERR_CERT_AUTHORITY_INVALID' , 'net::ERR_CERT_COMMON_NAME_INVALID' ] ) ;
expect ( errorCode ) . to . be . oneOf ( [ - 202 , - 200 ] ) ;
} ;
2020-03-20 20:28:31 +00:00
callback ( 0 ) ;
} ) ;
2019-05-28 21:12:59 +00:00
2020-11-17 19:12:50 +00:00
const w = new BrowserWindow ( { show : false , webPreferences : { session : ses } } ) ;
2020-03-20 20:28:31 +00:00
await w . loadURL ( ` https://127.0.0.1: ${ ( server . address ( ) as AddressInfo ) . port } ` ) ;
expect ( w . webContents . getTitle ( ) ) . to . equal ( 'hello' ) ;
2021-06-17 21:17:25 +00:00
expect ( validate ! ) . not . to . be . undefined ( ) ;
validate ! ( ) ;
2020-03-20 20:28:31 +00:00
} ) ;
2019-05-28 21:12:59 +00:00
2019-05-30 22:05:02 +00:00
it ( 'rejects the request when the callback is called with -2' , async ( ) = > {
2020-11-17 19:12:50 +00:00
const ses = session . fromPartition ( ` ${ Math . random ( ) } ` ) ;
2021-06-17 21:17:25 +00:00
let validate : ( ) = > void ;
2021-08-02 01:24:58 +00:00
ses . setCertificateVerifyProc ( ( { hostname , certificate , verificationResult , isIssuedByKnownRoot } , callback ) = > {
2021-09-01 22:58:29 +00:00
if ( hostname !== '127.0.0.1' ) return callback ( - 3 ) ;
2021-06-17 21:17:25 +00:00
validate = ( ) = > {
expect ( certificate . issuerName ) . to . equal ( 'Intermediate CA' ) ;
expect ( certificate . subjectName ) . to . equal ( 'localhost' ) ;
expect ( certificate . issuer . commonName ) . to . equal ( 'Intermediate CA' ) ;
expect ( certificate . subject . commonName ) . to . equal ( 'localhost' ) ;
expect ( certificate . issuerCert . issuer . commonName ) . to . equal ( 'Root CA' ) ;
expect ( certificate . issuerCert . subject . commonName ) . to . equal ( 'Intermediate CA' ) ;
expect ( certificate . issuerCert . issuerCert . issuer . commonName ) . to . equal ( 'Root CA' ) ;
expect ( certificate . issuerCert . issuerCert . subject . commonName ) . to . equal ( 'Root CA' ) ;
expect ( certificate . issuerCert . issuerCert . issuerCert ) . to . equal ( undefined ) ;
expect ( verificationResult ) . to . be . oneOf ( [ 'net::ERR_CERT_AUTHORITY_INVALID' , 'net::ERR_CERT_COMMON_NAME_INVALID' ] ) ;
2021-08-02 01:24:58 +00:00
expect ( isIssuedByKnownRoot ) . to . be . false ( ) ;
2021-06-17 21:17:25 +00:00
} ;
2020-03-20 20:28:31 +00:00
callback ( - 2 ) ;
} ) ;
const url = ` https://127.0.0.1: ${ ( server . address ( ) as AddressInfo ) . port } ` ;
2020-11-17 19:12:50 +00:00
const w = new BrowserWindow ( { show : false , webPreferences : { session : ses } } ) ;
2020-03-20 20:28:31 +00:00
await expect ( w . loadURL ( url ) ) . to . eventually . be . rejectedWith ( /ERR_FAILED/ ) ;
expect ( w . webContents . getTitle ( ) ) . to . equal ( url ) ;
2021-06-17 21:17:25 +00:00
expect ( validate ! ) . not . to . be . undefined ( ) ;
validate ! ( ) ;
2020-03-20 20:28:31 +00:00
} ) ;
2019-06-28 22:22:23 +00:00
it ( 'saves cached results' , async ( ) = > {
2020-11-17 19:12:50 +00:00
const ses = session . fromPartition ( ` ${ Math . random ( ) } ` ) ;
2020-03-20 20:28:31 +00:00
let numVerificationRequests = 0 ;
2020-11-17 19:12:50 +00:00
ses . setCertificateVerifyProc ( ( e , callback ) = > {
2021-09-01 22:58:29 +00:00
if ( e . hostname !== '127.0.0.1' ) return callback ( - 3 ) ;
2020-03-20 20:28:31 +00:00
numVerificationRequests ++ ;
callback ( - 2 ) ;
} ) ;
const url = ` https://127.0.0.1: ${ ( server . address ( ) as AddressInfo ) . port } ` ;
2020-11-17 19:12:50 +00:00
const w = new BrowserWindow ( { show : false , webPreferences : { session : ses } } ) ;
2020-03-20 20:28:31 +00:00
await expect ( w . loadURL ( url ) , 'first load' ) . to . eventually . be . rejectedWith ( /ERR_FAILED/ ) ;
await emittedOnce ( w . webContents , 'did-stop-loading' ) ;
await expect ( w . loadURL ( url + '/test' ) , 'second load' ) . to . eventually . be . rejectedWith ( /ERR_FAILED/ ) ;
expect ( w . webContents . getTitle ( ) ) . to . equal ( url + '/test' ) ;
expect ( numVerificationRequests ) . to . equal ( 1 ) ;
} ) ;
2020-11-17 19:12:50 +00:00
it ( 'does not cancel requests in other sessions' , async ( ) = > {
const ses1 = session . fromPartition ( ` ${ Math . random ( ) } ` ) ;
ses1 . setCertificateVerifyProc ( ( opts , cb ) = > cb ( 0 ) ) ;
const ses2 = session . fromPartition ( ` ${ Math . random ( ) } ` ) ;
const url = ` https://127.0.0.1: ${ ( server . address ( ) as AddressInfo ) . port } ` ;
const req = net . request ( { url , session : ses1 , credentials : 'include' } ) ;
req . end ( ) ;
setTimeout ( ( ) = > {
ses2 . setCertificateVerifyProc ( ( opts , callback ) = > callback ( 0 ) ) ;
} ) ;
2021-01-22 19:25:47 +00:00
await expect ( new Promise < void > ( ( resolve , reject ) = > {
2020-11-17 19:12:50 +00:00
req . on ( 'error' , ( err ) = > {
reject ( err ) ;
} ) ;
req . on ( 'response' , ( ) = > {
resolve ( ) ;
} ) ;
} ) ) . to . eventually . be . fulfilled ( ) ;
} ) ;
2020-03-20 20:28:31 +00:00
} ) ;
2019-05-28 21:12:59 +00:00
2020-02-21 18:40:45 +00:00
describe ( 'ses.clearAuthCache()' , ( ) = > {
2019-08-29 00:43:12 +00:00
it ( 'can clear http auth info from cache' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const ses = session . fromPartition ( 'auth-cache' ) ;
2019-05-28 21:12:59 +00:00
const server = http . createServer ( ( req , res ) = > {
2020-03-20 20:28:31 +00:00
const credentials = auth ( req ) ;
2019-05-28 21:12:59 +00:00
if ( ! credentials || credentials . name !== 'test' || credentials . pass !== 'test' ) {
2020-03-20 20:28:31 +00:00
res . statusCode = 401 ;
res . setHeader ( 'WWW-Authenticate' , 'Basic realm="Restricted"' ) ;
res . end ( ) ;
2019-05-28 21:12:59 +00:00
} else {
2020-03-20 20:28:31 +00:00
res . end ( 'authenticated' ) ;
2019-05-28 21:12:59 +00:00
}
2020-03-20 20:28:31 +00:00
} ) ;
2021-01-22 19:25:47 +00:00
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
2020-03-20 20:28:31 +00:00
const port = ( server . address ( ) as AddressInfo ) . port ;
2019-08-29 00:43:12 +00:00
const fetch = ( url : string ) = > new Promise ( ( resolve , reject ) = > {
2020-03-20 20:28:31 +00:00
const request = net . request ( { url , session : ses } ) ;
2019-08-29 00:43:12 +00:00
request . on ( 'response' , ( response ) = > {
2020-03-20 20:28:31 +00:00
let data : string | null = null ;
2019-08-29 00:43:12 +00:00
response . on ( 'data' , ( chunk ) = > {
2019-11-25 22:34:25 +00:00
if ( ! data ) {
2020-03-20 20:28:31 +00:00
data = '' ;
2019-11-25 22:34:25 +00:00
}
2020-03-20 20:28:31 +00:00
data += chunk ;
} ) ;
2019-08-29 00:43:12 +00:00
response . on ( 'end' , ( ) = > {
2019-11-25 22:34:25 +00:00
if ( ! data ) {
2020-03-20 20:28:31 +00:00
reject ( new Error ( 'Empty response' ) ) ;
2019-11-25 22:34:25 +00:00
} else {
2020-03-20 20:28:31 +00:00
resolve ( data ) ;
2019-11-25 22:34:25 +00:00
}
2020-03-20 20:28:31 +00:00
} ) ;
response . on ( 'error' , ( error : any ) = > { reject ( new Error ( error ) ) ; } ) ;
} ) ;
request . on ( 'error' , ( error : any ) = > { reject ( new Error ( error ) ) ; } ) ;
request . end ( ) ;
} ) ;
2019-08-29 00:43:12 +00:00
// the first time should throw due to unauthenticated
2020-03-20 20:28:31 +00:00
await expect ( fetch ( ` http://127.0.0.1: ${ port } ` ) ) . to . eventually . be . rejected ( ) ;
2019-08-29 00:43:12 +00:00
// passing the password should let us in
2020-03-20 20:28:31 +00:00
expect ( await fetch ( ` http://test:test@127.0.0.1: ${ port } ` ) ) . to . equal ( 'authenticated' ) ;
2019-08-29 00:43:12 +00:00
// subsequently, the credentials are cached
2020-03-20 20:28:31 +00:00
expect ( await fetch ( ` http://127.0.0.1: ${ port } ` ) ) . to . equal ( 'authenticated' ) ;
await ses . clearAuthCache ( ) ;
2019-08-29 00:43:12 +00:00
// once the cache is cleared, we should get an error again
2020-03-20 20:28:31 +00:00
await expect ( fetch ( ` http://127.0.0.1: ${ port } ` ) ) . to . eventually . be . rejected ( ) ;
} ) ;
} ) ;
2019-05-30 22:05:02 +00:00
describe ( 'DownloadItem' , ( ) = > {
2020-03-20 20:28:31 +00:00
const mockPDF = Buffer . alloc ( 1024 * 1024 * 5 ) ;
const downloadFilePath = path . join ( __dirname , '..' , 'fixtures' , 'mock.pdf' ) ;
const protocolName = 'custom-dl' ;
const contentDisposition = 'inline; filename="mock.pdf"' ;
let address : AddressInfo ;
let downloadServer : http.Server ;
2019-05-30 22:05:02 +00:00
before ( async ( ) = > {
downloadServer = http . createServer ( ( req , res ) = > {
res . writeHead ( 200 , {
'Content-Length' : mockPDF . length ,
'Content-Type' : 'application/pdf' ,
'Content-Disposition' : req . url === '/?testFilename' ? 'inline' : contentDisposition
2020-03-20 20:28:31 +00:00
} ) ;
res . end ( mockPDF ) ;
} ) ;
2021-01-22 19:25:47 +00:00
await new Promise < void > ( resolve = > downloadServer . listen ( 0 , '127.0.0.1' , resolve ) ) ;
2020-03-20 20:28:31 +00:00
address = downloadServer . address ( ) as AddressInfo ;
} ) ;
2019-05-30 22:05:02 +00:00
after ( async ( ) = > {
2020-03-20 20:28:31 +00:00
await new Promise ( resolve = > downloadServer . close ( resolve ) ) ;
} ) ;
afterEach ( closeAllWindows ) ;
2019-05-30 22:05:02 +00:00
2019-08-27 21:55:19 +00:00
const isPathEqual = ( path1 : string , path2 : string ) = > {
2020-03-20 20:28:31 +00:00
return path . relative ( path1 , path2 ) === '' ;
} ;
2019-08-27 21:55:19 +00:00
const assertDownload = ( state : string , item : Electron.DownloadItem , isCustom = false ) = > {
2020-03-20 20:28:31 +00:00
expect ( state ) . to . equal ( 'completed' ) ;
expect ( item . getFilename ( ) ) . to . equal ( 'mock.pdf' ) ;
expect ( path . isAbsolute ( item . savePath ) ) . to . equal ( true ) ;
expect ( isPathEqual ( item . savePath , downloadFilePath ) ) . to . equal ( true ) ;
2019-05-30 22:05:02 +00:00
if ( isCustom ) {
2020-03-20 20:28:31 +00:00
expect ( item . getURL ( ) ) . to . equal ( ` ${ protocolName } ://item ` ) ;
2019-05-30 22:05:02 +00:00
} else {
2020-03-20 20:28:31 +00:00
expect ( item . getURL ( ) ) . to . be . equal ( ` ${ url } : ${ address . port } / ` ) ;
2019-05-30 22:05:02 +00:00
}
2020-03-20 20:28:31 +00:00
expect ( item . getMimeType ( ) ) . to . equal ( 'application/pdf' ) ;
expect ( item . getReceivedBytes ( ) ) . to . equal ( mockPDF . length ) ;
expect ( item . getTotalBytes ( ) ) . to . equal ( mockPDF . length ) ;
expect ( item . getContentDisposition ( ) ) . to . equal ( contentDisposition ) ;
expect ( fs . existsSync ( downloadFilePath ) ) . to . equal ( true ) ;
fs . unlinkSync ( downloadFilePath ) ;
} ;
2019-05-30 22:05:02 +00:00
2019-08-29 03:27:20 +00:00
it ( 'can download using session.downloadURL' , ( done ) = > {
2020-03-20 20:28:31 +00:00
const port = address . port ;
2019-08-29 03:27:20 +00:00
session . defaultSession . once ( 'will-download' , function ( e , item ) {
2020-03-20 20:28:31 +00:00
item . savePath = downloadFilePath ;
2019-08-29 03:27:20 +00:00
item . on ( 'done' , function ( e , state ) {
2020-06-30 22:10:36 +00:00
try {
assertDownload ( state , item ) ;
done ( ) ;
} catch ( e ) {
done ( e ) ;
}
2020-03-20 20:28:31 +00:00
} ) ;
} ) ;
session . defaultSession . downloadURL ( ` ${ url } : ${ port } ` ) ;
} ) ;
2019-08-29 03:27:20 +00:00
2019-05-30 22:05:02 +00:00
it ( 'can download using WebContents.downloadURL' , ( done ) = > {
2020-03-20 20:28:31 +00:00
const port = address . port ;
const w = new BrowserWindow ( { show : false } ) ;
2019-05-30 22:05:02 +00:00
w . webContents . session . once ( 'will-download' , function ( e , item ) {
2020-03-20 20:28:31 +00:00
item . savePath = downloadFilePath ;
2019-05-30 22:05:02 +00:00
item . on ( 'done' , function ( e , state ) {
2020-06-30 22:10:36 +00:00
try {
assertDownload ( state , item ) ;
done ( ) ;
} catch ( e ) {
done ( e ) ;
}
2020-03-20 20:28:31 +00:00
} ) ;
} ) ;
w . webContents . downloadURL ( ` ${ url } : ${ port } ` ) ;
} ) ;
2019-05-30 22:05:02 +00:00
it ( 'can download from custom protocols using WebContents.downloadURL' , ( done ) = > {
2020-03-20 20:28:31 +00:00
const protocol = session . defaultSession . protocol ;
const port = address . port ;
2019-08-27 21:55:19 +00:00
const handler = ( ignoredError : any , callback : Function ) = > {
2020-03-20 20:28:31 +00:00
callback ( { url : ` ${ url } : ${ port } ` } ) ;
} ;
2020-06-02 16:46:18 +00:00
protocol . registerHttpProtocol ( protocolName , handler ) ;
const w = new BrowserWindow ( { show : false } ) ;
w . webContents . session . once ( 'will-download' , function ( e , item ) {
item . savePath = downloadFilePath ;
item . on ( 'done' , function ( e , state ) {
2020-06-30 22:10:36 +00:00
try {
assertDownload ( state , item , true ) ;
done ( ) ;
} catch ( e ) {
done ( e ) ;
}
2020-03-20 20:28:31 +00:00
} ) ;
} ) ;
2020-06-02 16:46:18 +00:00
w . webContents . downloadURL ( ` ${ protocolName } ://item ` ) ;
2020-03-20 20:28:31 +00:00
} ) ;
2019-05-30 22:05:02 +00:00
it ( 'can download using WebView.downloadURL' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const port = address . port ;
const w = new BrowserWindow ( { show : false , webPreferences : { webviewTag : true } } ) ;
await w . loadURL ( 'about:blank' ) ;
2019-11-01 20:37:02 +00:00
function webviewDownload ( { fixtures , url , port } : { fixtures : string , url : string , port : string } ) {
2020-03-20 20:28:31 +00:00
const webview = new ( window as any ) . WebView ( ) ;
2019-05-30 22:05:02 +00:00
webview . addEventListener ( 'did-finish-load' , ( ) = > {
2020-03-20 20:28:31 +00:00
webview . downloadURL ( ` ${ url } : ${ port } / ` ) ;
} ) ;
webview . src = ` file:// ${ fixtures } /api/blank.html ` ;
document . body . appendChild ( webview ) ;
2019-05-30 22:05:02 +00:00
}
2019-08-27 21:55:19 +00:00
const done : Promise < [ string , Electron . DownloadItem ] > = new Promise ( resolve = > {
2019-05-30 22:05:02 +00:00
w . webContents . session . once ( 'will-download' , function ( e , item ) {
2020-03-20 20:28:31 +00:00
item . savePath = downloadFilePath ;
2019-05-30 22:05:02 +00:00
item . on ( 'done' , function ( e , state ) {
2020-03-20 20:28:31 +00:00
resolve ( [ state , item ] ) ;
} ) ;
} ) ;
} ) ;
await w . webContents . executeJavaScript ( ` ( ${ webviewDownload } )( ${ JSON . stringify ( { fixtures , url , port } )}) ` ) ;
const [ state , item ] = await done ;
assertDownload ( state , item ) ;
} ) ;
2019-05-30 22:05:02 +00:00
it ( 'can cancel download' , ( done ) = > {
2020-03-20 20:28:31 +00:00
const port = address . port ;
const w = new BrowserWindow ( { show : false } ) ;
2019-05-30 22:05:02 +00:00
w . webContents . session . once ( 'will-download' , function ( e , item ) {
2020-03-20 20:28:31 +00:00
item . savePath = downloadFilePath ;
2019-05-30 22:05:02 +00:00
item . on ( 'done' , function ( e , state ) {
2020-06-30 22:10:36 +00:00
try {
expect ( state ) . to . equal ( 'cancelled' ) ;
expect ( item . getFilename ( ) ) . to . equal ( 'mock.pdf' ) ;
expect ( item . getMimeType ( ) ) . to . equal ( 'application/pdf' ) ;
expect ( item . getReceivedBytes ( ) ) . to . equal ( 0 ) ;
expect ( item . getTotalBytes ( ) ) . to . equal ( mockPDF . length ) ;
expect ( item . getContentDisposition ( ) ) . to . equal ( contentDisposition ) ;
done ( ) ;
} catch ( e ) {
done ( e ) ;
}
2020-03-20 20:28:31 +00:00
} ) ;
item . cancel ( ) ;
} ) ;
w . webContents . downloadURL ( ` ${ url } : ${ port } / ` ) ;
} ) ;
2019-05-30 22:05:02 +00:00
it ( 'can generate a default filename' , function ( done ) {
if ( process . env . APPVEYOR === 'True' ) {
// FIXME(alexeykuzmin): Skip the test.
// this.skip()
2020-03-20 20:28:31 +00:00
return done ( ) ;
2019-05-30 22:05:02 +00:00
}
2020-03-20 20:28:31 +00:00
const port = address . port ;
const w = new BrowserWindow ( { show : false } ) ;
2019-05-30 22:05:02 +00:00
w . webContents . session . once ( 'will-download' , function ( e , item ) {
2020-03-20 20:28:31 +00:00
item . savePath = downloadFilePath ;
2019-11-01 20:37:02 +00:00
item . on ( 'done' , function ( ) {
2020-06-30 22:10:36 +00:00
try {
expect ( item . getFilename ( ) ) . to . equal ( 'download.pdf' ) ;
done ( ) ;
} catch ( e ) {
done ( e ) ;
}
2020-03-20 20:28:31 +00:00
} ) ;
item . cancel ( ) ;
} ) ;
w . webContents . downloadURL ( ` ${ url } : ${ port } /?testFilename ` ) ;
} ) ;
2019-05-30 22:05:02 +00:00
it ( 'can set options for the save dialog' , ( done ) = > {
2020-03-20 20:28:31 +00:00
const filePath = path . join ( __dirname , 'fixtures' , 'mock.pdf' ) ;
const port = address . port ;
2019-05-30 22:05:02 +00:00
const options = {
window : null ,
title : 'title' ,
message : 'message' ,
buttonLabel : 'buttonLabel' ,
nameFieldLabel : 'nameFieldLabel' ,
defaultPath : '/' ,
filters : [ {
name : '1' , extensions : [ '.1' , '.2' ]
} , {
name : '2' , extensions : [ '.3' , '.4' , '.5' ]
} ] ,
showsTagField : true ,
securityScopedBookmarks : true
2020-03-20 20:28:31 +00:00
} ;
2019-05-30 22:05:02 +00:00
2020-03-20 20:28:31 +00:00
const w = new BrowserWindow ( { show : false } ) ;
2019-05-30 22:05:02 +00:00
w . webContents . session . once ( 'will-download' , function ( e , item ) {
2020-03-20 20:28:31 +00:00
item . setSavePath ( filePath ) ;
item . setSaveDialogOptions ( options ) ;
2019-11-01 20:37:02 +00:00
item . on ( 'done' , function ( ) {
2020-06-30 22:10:36 +00:00
try {
expect ( item . getSaveDialogOptions ( ) ) . to . deep . equal ( options ) ;
done ( ) ;
} catch ( e ) {
done ( e ) ;
}
2020-03-20 20:28:31 +00:00
} ) ;
item . cancel ( ) ;
} ) ;
w . webContents . downloadURL ( ` ${ url } : ${ port } ` ) ;
} ) ;
2019-05-30 22:05:02 +00:00
describe ( 'when a save path is specified and the URL is unavailable' , ( ) = > {
it ( 'does not display a save dialog and reports the done state as interrupted' , ( done ) = > {
2020-03-20 20:28:31 +00:00
const w = new BrowserWindow ( { show : false } ) ;
2019-05-30 22:05:02 +00:00
w . webContents . session . once ( 'will-download' , function ( e , item ) {
2020-03-20 20:28:31 +00:00
item . savePath = downloadFilePath ;
2019-05-30 22:05:02 +00:00
if ( item . getState ( ) === 'interrupted' ) {
2020-03-20 20:28:31 +00:00
item . resume ( ) ;
2019-05-30 22:05:02 +00:00
}
item . on ( 'done' , function ( e , state ) {
2020-06-30 22:10:36 +00:00
try {
expect ( state ) . to . equal ( 'interrupted' ) ;
done ( ) ;
} catch ( e ) {
done ( e ) ;
}
2020-03-20 20:28:31 +00:00
} ) ;
} ) ;
w . webContents . downloadURL ( ` file:// ${ path . join ( __dirname , 'does-not-exist.txt' ) } ` ) ;
} ) ;
} ) ;
} ) ;
2019-05-30 22:05:02 +00:00
describe ( 'ses.createInterruptedDownload(options)' , ( ) = > {
2020-03-20 20:28:31 +00:00
afterEach ( closeAllWindows ) ;
2019-09-21 14:51:28 +00:00
it ( 'can create an interrupted download item' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const downloadFilePath = path . join ( __dirname , '..' , 'fixtures' , 'mock.pdf' ) ;
2019-05-30 22:05:02 +00:00
const options = {
path : downloadFilePath ,
urlChain : [ 'http://127.0.0.1/' ] ,
mimeType : 'application/pdf' ,
offset : 0 ,
length : 5242880
2020-03-20 20:28:31 +00:00
} ;
const w = new BrowserWindow ( { show : false } ) ;
const p = emittedOnce ( w . webContents . session , 'will-download' ) ;
w . webContents . session . createInterruptedDownload ( options ) ;
const [ , item ] = await p ;
expect ( item . getState ( ) ) . to . equal ( 'interrupted' ) ;
item . cancel ( ) ;
expect ( item . getURLChain ( ) ) . to . deep . equal ( options . urlChain ) ;
expect ( item . getMimeType ( ) ) . to . equal ( options . mimeType ) ;
expect ( item . getReceivedBytes ( ) ) . to . equal ( options . offset ) ;
expect ( item . getTotalBytes ( ) ) . to . equal ( options . length ) ;
expect ( item . savePath ) . to . equal ( downloadFilePath ) ;
} ) ;
2019-05-30 22:05:02 +00:00
it ( 'can be resumed' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const downloadFilePath = path . join ( fixtures , 'logo.png' ) ;
2019-05-30 22:05:02 +00:00
const rangeServer = http . createServer ( ( req , res ) = > {
2020-03-20 20:28:31 +00:00
const options = { root : fixtures } ;
2019-08-27 21:55:19 +00:00
send ( req , req . url ! , options )
2020-03-20 20:28:31 +00:00
. on ( 'error' , ( error : any ) = > { throw error ; } ) . pipe ( res ) ;
} ) ;
2019-05-30 22:05:02 +00:00
try {
2021-01-22 19:25:47 +00:00
await new Promise < void > ( resolve = > rangeServer . listen ( 0 , '127.0.0.1' , resolve ) ) ;
2020-03-20 20:28:31 +00:00
const port = ( rangeServer . address ( ) as AddressInfo ) . port ;
const w = new BrowserWindow ( { show : false } ) ;
2019-08-27 21:55:19 +00:00
const downloadCancelled : Promise < Electron.DownloadItem > = new Promise ( ( resolve ) = > {
2019-05-30 22:05:02 +00:00
w . webContents . session . once ( 'will-download' , function ( e , item ) {
2020-03-20 20:28:31 +00:00
item . setSavePath ( downloadFilePath ) ;
2019-11-01 20:37:02 +00:00
item . on ( 'done' , function ( ) {
2020-03-20 20:28:31 +00:00
resolve ( item ) ;
} ) ;
item . cancel ( ) ;
} ) ;
} ) ;
const downloadUrl = ` http://127.0.0.1: ${ port } /assets/logo.png ` ;
w . webContents . downloadURL ( downloadUrl ) ;
const item = await downloadCancelled ;
expect ( item . getState ( ) ) . to . equal ( 'cancelled' ) ;
2019-05-30 22:05:02 +00:00
const options = {
2019-06-20 17:04:57 +00:00
path : item.savePath ,
2019-05-30 22:05:02 +00:00
urlChain : item.getURLChain ( ) ,
mimeType : item.getMimeType ( ) ,
offset : item.getReceivedBytes ( ) ,
length : item.getTotalBytes ( ) ,
lastModified : item.getLastModifiedTime ( ) ,
2019-11-01 20:37:02 +00:00
eTag : item.getETag ( )
2020-03-20 20:28:31 +00:00
} ;
2019-08-27 21:55:19 +00:00
const downloadResumed : Promise < Electron.DownloadItem > = new Promise ( ( resolve ) = > {
2019-05-30 22:05:02 +00:00
w . webContents . session . once ( 'will-download' , function ( e , item ) {
2020-03-20 20:28:31 +00:00
expect ( item . getState ( ) ) . to . equal ( 'interrupted' ) ;
item . setSavePath ( downloadFilePath ) ;
item . resume ( ) ;
2019-11-01 20:37:02 +00:00
item . on ( 'done' , function ( ) {
2020-03-20 20:28:31 +00:00
resolve ( item ) ;
} ) ;
} ) ;
} ) ;
w . webContents . session . createInterruptedDownload ( options ) ;
const completedItem = await downloadResumed ;
expect ( completedItem . getState ( ) ) . to . equal ( 'completed' ) ;
expect ( completedItem . getFilename ( ) ) . to . equal ( 'logo.png' ) ;
expect ( completedItem . savePath ) . to . equal ( downloadFilePath ) ;
expect ( completedItem . getURL ( ) ) . to . equal ( downloadUrl ) ;
expect ( completedItem . getMimeType ( ) ) . to . equal ( 'image/png' ) ;
expect ( completedItem . getReceivedBytes ( ) ) . to . equal ( 14022 ) ;
expect ( completedItem . getTotalBytes ( ) ) . to . equal ( 14022 ) ;
expect ( fs . existsSync ( downloadFilePath ) ) . to . equal ( true ) ;
2019-05-30 22:05:02 +00:00
} finally {
2020-03-20 20:28:31 +00:00
rangeServer . close ( ) ;
2019-05-30 22:05:02 +00:00
}
2020-03-20 20:28:31 +00:00
} ) ;
} ) ;
2019-05-30 22:05:02 +00:00
describe ( 'ses.setPermissionRequestHandler(handler)' , ( ) = > {
2020-03-20 20:28:31 +00:00
afterEach ( closeAllWindows ) ;
2019-05-30 22:05:02 +00:00
it ( 'cancels any pending requests when cleared' , async ( ) = > {
2019-08-29 06:50:14 +00:00
const w = new BrowserWindow ( {
2019-07-03 01:22:09 +00:00
show : false ,
webPreferences : {
2020-03-20 15:12:18 +00:00
partition : 'very-temp-permision-handler' ,
2021-03-01 21:52:29 +00:00
nodeIntegration : true ,
contextIsolation : false
2019-07-03 01:22:09 +00:00
}
2020-03-20 20:28:31 +00:00
} ) ;
2019-07-03 01:22:09 +00:00
2020-03-20 20:28:31 +00:00
const ses = w . webContents . session ;
2019-05-30 22:05:02 +00:00
ses . setPermissionRequestHandler ( ( ) = > {
2020-03-20 20:28:31 +00:00
ses . setPermissionRequestHandler ( null ) ;
} ) ;
2019-05-30 22:05:02 +00:00
2019-07-03 01:22:09 +00:00
ses . protocol . interceptStringProtocol ( 'https' , ( req , cb ) = > {
2020-03-20 20:28:31 +00:00
cb ( ` <html><script>( ${ remote } )()</script></html> ` ) ;
} ) ;
2019-07-03 01:22:09 +00:00
2020-03-20 20:28:31 +00:00
const result = emittedOnce ( require ( 'electron' ) . ipcMain , 'message' ) ;
2019-05-30 22:05:02 +00:00
2019-11-01 20:37:02 +00:00
function remote ( ) {
( navigator as any ) . requestMIDIAccess ( { sysex : true } ) . then ( ( ) = > { } , ( err : any ) = > {
2020-03-20 20:28:31 +00:00
require ( 'electron' ) . ipcRenderer . send ( 'message' , err . name ) ;
} ) ;
2019-05-30 22:05:02 +00:00
}
2020-03-20 20:28:31 +00:00
await w . loadURL ( 'https://myfakesite' ) ;
2019-05-30 22:05:02 +00:00
2020-03-20 20:28:31 +00:00
const [ , name ] = await result ;
expect ( name ) . to . deep . equal ( 'SecurityError' ) ;
} ) ;
} ) ;
2019-08-29 06:50:14 +00:00
2020-03-11 07:02:22 +00:00
describe ( 'ses.isPersistent()' , ( ) = > {
2020-03-20 20:28:31 +00:00
afterEach ( closeAllWindows ) ;
2020-03-11 07:02:22 +00:00
it ( 'returns default session as persistent' , ( ) = > {
const w = new BrowserWindow ( {
show : false
2020-03-20 20:28:31 +00:00
} ) ;
2020-03-11 07:02:22 +00:00
2020-03-20 20:28:31 +00:00
const ses = w . webContents . session ;
2020-03-11 07:02:22 +00:00
2020-03-20 20:28:31 +00:00
expect ( ses . isPersistent ( ) ) . to . be . true ( ) ;
} ) ;
2020-03-11 07:02:22 +00:00
it ( 'returns persist: session as persistent' , ( ) = > {
2020-03-20 20:28:31 +00:00
const ses = session . fromPartition ( ` persist: ${ Math . random ( ) } ` ) ;
expect ( ses . isPersistent ( ) ) . to . be . true ( ) ;
} ) ;
2020-03-11 07:02:22 +00:00
it ( 'returns temporary session as not persistent' , ( ) = > {
2020-03-20 20:28:31 +00:00
const ses = session . fromPartition ( ` ${ Math . random ( ) } ` ) ;
expect ( ses . isPersistent ( ) ) . to . be . false ( ) ;
} ) ;
} ) ;
2020-03-11 07:02:22 +00:00
2019-08-29 06:50:14 +00:00
describe ( 'ses.setUserAgent()' , ( ) = > {
2020-03-20 20:28:31 +00:00
afterEach ( closeAllWindows ) ;
2019-08-29 06:50:14 +00:00
it ( 'can be retrieved with getUserAgent()' , ( ) = > {
2020-03-20 20:28:31 +00:00
const userAgent = 'test-agent' ;
const ses = session . fromPartition ( '' + Math . random ( ) ) ;
ses . setUserAgent ( userAgent ) ;
expect ( ses . getUserAgent ( ) ) . to . equal ( userAgent ) ;
} ) ;
2019-08-29 06:50:14 +00:00
it ( 'sets the User-Agent header for web requests made from renderers' , async ( ) = > {
2020-03-20 20:28:31 +00:00
const userAgent = 'test-agent' ;
const ses = session . fromPartition ( '' + Math . random ( ) ) ;
2020-06-04 11:05:37 +00:00
ses . setUserAgent ( userAgent , 'en-US,fr,de' ) ;
2020-03-20 20:28:31 +00:00
const w = new BrowserWindow ( { show : false , webPreferences : { session : ses } } ) ;
let headers : http.IncomingHttpHeaders | null = null ;
2019-08-29 06:50:14 +00:00
const server = http . createServer ( ( req , res ) = > {
2020-03-20 20:28:31 +00:00
headers = req . headers ;
res . end ( ) ;
server . close ( ) ;
} ) ;
2021-01-22 19:25:47 +00:00
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
2020-03-20 20:28:31 +00:00
await w . loadURL ( ` http://127.0.0.1: ${ ( server . address ( ) as AddressInfo ) . port } ` ) ;
expect ( headers ! [ 'user-agent' ] ) . to . equal ( userAgent ) ;
2020-06-04 11:05:37 +00:00
expect ( headers ! [ 'accept-language' ] ) . to . equal ( 'en-US,fr;q=0.9,de;q=0.8' ) ;
2020-03-20 20:28:31 +00:00
} ) ;
} ) ;
2020-05-19 17:18:12 +00:00
describe ( 'session-created event' , ( ) = > {
it ( 'is emitted when a session is created' , async ( ) = > {
2020-10-07 13:59:27 +00:00
const sessionCreated = emittedOnce ( app , 'session-created' ) ;
const session1 = session . fromPartition ( '' + Math . random ( ) ) ;
const [ session2 ] = await sessionCreated ;
expect ( session1 ) . to . equal ( session2 ) ;
2020-05-19 17:18:12 +00:00
} ) ;
} ) ;
2020-10-21 18:03:59 +00:00
2021-04-27 16:54:28 +00:00
describe ( 'session.storagePage' , ( ) = > {
it ( 'returns a string' , ( ) = > {
expect ( session . defaultSession . storagePath ) . to . be . a ( 'string' ) ;
} ) ;
it ( 'returns null for in memory sessions' , ( ) = > {
expect ( session . fromPartition ( 'in-memory' ) . storagePath ) . to . equal ( null ) ;
} ) ;
it ( 'returns different paths for partitions and the default session' , ( ) = > {
expect ( session . defaultSession . storagePath ) . to . not . equal ( session . fromPartition ( 'persist:two' ) . storagePath ) ;
} ) ;
it ( 'returns different paths for different partitions' , ( ) = > {
expect ( session . fromPartition ( 'persist:one' ) . storagePath ) . to . not . equal ( session . fromPartition ( 'persist:two' ) . storagePath ) ;
} ) ;
} ) ;
2022-03-15 20:34:53 +00:00
describe ( 'session.setCodeCachePath()' , ( ) = > {
it ( 'throws when relative or empty path is provided' , ( ) = > {
expect ( ( ) = > {
session . defaultSession . setCodeCachePath ( '../fixtures' ) ;
} ) . to . throw ( 'Absolute path must be provided to store code cache.' ) ;
expect ( ( ) = > {
session . defaultSession . setCodeCachePath ( '' ) ;
} ) . to . throw ( 'Absolute path must be provided to store code cache.' ) ;
expect ( ( ) = > {
2022-03-30 17:17:34 +00:00
session . defaultSession . setCodeCachePath ( path . join ( app . getPath ( 'userData' ) , 'electron-test-code-cache' ) ) ;
2022-03-15 20:34:53 +00:00
} ) . to . not . throw ( ) ;
} ) ;
} ) ;
2020-10-21 18:03:59 +00:00
describe ( 'ses.setSSLConfig()' , ( ) = > {
it ( 'can disable cipher suites' , async ( ) = > {
const ses = session . fromPartition ( '' + Math . random ( ) ) ;
const fixturesPath = path . resolve ( __dirname , '..' , 'spec' , 'fixtures' ) ;
const certPath = path . join ( fixturesPath , 'certificates' ) ;
const server = https . createServer ( {
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' ) )
] ,
minVersion : 'TLSv1.2' ,
maxVersion : 'TLSv1.2' ,
ciphers : 'AES128-GCM-SHA256'
} , ( req , res ) = > {
res . end ( 'hi' ) ;
} ) ;
2021-01-22 19:25:47 +00:00
await new Promise < void > ( resolve = > server . listen ( 0 , '127.0.0.1' , resolve ) ) ;
2020-10-21 18:03:59 +00:00
defer ( ( ) = > server . close ( ) ) ;
const { port } = server . address ( ) as AddressInfo ;
function request ( ) {
return new Promise ( ( resolve , reject ) = > {
const r = net . request ( {
url : ` https://127.0.0.1: ${ port } ` ,
session : ses
} ) ;
r . on ( 'response' , ( res ) = > {
let data = '' ;
res . on ( 'data' , ( chunk ) = > {
data += chunk . toString ( 'utf8' ) ;
} ) ;
res . on ( 'end' , ( ) = > {
resolve ( data ) ;
} ) ;
} ) ;
r . on ( 'error' , ( err ) = > {
reject ( err ) ;
} ) ;
r . end ( ) ;
} ) ;
}
await expect ( request ( ) ) . to . be . rejectedWith ( /ERR_CERT_AUTHORITY_INVALID/ ) ;
ses . setSSLConfig ( {
disabledCipherSuites : [ 0x009C ]
} ) ;
await expect ( request ( ) ) . to . be . rejectedWith ( /ERR_SSL_VERSION_OR_CIPHER_MISMATCH/ ) ;
} ) ;
} ) ;
2020-03-20 20:28:31 +00:00
} ) ;