electron/spec-main/api-session-spec.js
Electron Bot 50b9c7051e chore: bump chromium to f1d9522c04ca8fa0a906f88ababe9 (master) (#18648)
* chore: bump chromium in DEPS to 675d7dc9f3334b15c3ec28c27db3dc19b26bd12e

* chore: update patches

* chore: bump chromium in DEPS to dce3562696f165a324273fcb6893f0e1fef42ab1

* chore: const interfaces are being removed from //content

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/1631749
Bug: https://bugs.chromium.org/p/chromium/issues/detail?id=908139

* chore: update patches

* chore: blink::MediaStreamType is now consistent and deduplicated

* chore: update patches and printing code for ref -> uniq

* chore: bridge_impl() --> GetInProcessNSWindowBridge

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/1642988

* fixme: TotalMarkedObjectSize has been removed

* chore: fix linting

* chore: bump chromium in DEPS to 9503e1a2fcbf17db08094d8caae3e1407e918af3

* chore: fix slightly broken printing patch

* chore: update patches for SiteInstanceImpl changes

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/1612025

* chore: update patches for SiteInstanceImpl changes

* chore: bump chromium in DEPS to 6801e6c1ddd1b7b73e594e97157ddd539ca335d7

* chore: update patches

* chore: bump chromium in DEPS to 27e198912d7c1767052ec785c22e2e88b2cb4d8b

* chore: remove system_request_context

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/1647172

* chore: creation of FtpProtocolHandler needs an auth cache

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/1639683

* fixme: disable marked spec

* chore: bump chromium in DEPS to 3dcd7fe453ad13a22b114b95f05590eba74c5471

* chore: bump chromium in DEPS to bdc24128b75008743d819e298557a53205706e7c

* chore: bump chromium in DEPS to 7da330b58fbe0ba94b9b94abbb8085bead220228

* update patches

* remove TotalMarkedObjectSize

https://chromium-review.googlesource.com/c/chromium/src/+/1631708

* add libvulkan.so to dist zip manifest on linux

* chore: bump chromium in DEPS to 1e85d0f45b52649efd0010cc9dab6d2804f24443

* update patches

* add angle features to gpuinfo

https://chromium-review.googlesource.com/c/chromium/src/+/1638658

* mark 'marked' property as deprecated

* disable webview resize test

* FIXME: disable vulkan on 32-bit arm

* chore: bump chromium in DEPS to cd0297c6a83fdd2b1f6bc312e7d5acca736a3c56

* Revert "FIXME: disable vulkan on 32-bit arm"

This reverts commit 5c1e0ef302a6db1e72231d4e823f91bb08e281af.

* backport from upstream: fix swiftshader build on arm

https://swiftshader-review.googlesource.com/c/SwiftShader/+/32768/

* update patches

* viz: update OutputDeviceWin to new shared memory api

https://chromium-review.googlesource.com/c/chromium/src/+/1649574

* base::Contains{Key,Value} => base::Contains

https://chromium-review.googlesource.com/c/chromium/src/+/1649478

* fixup! viz: update OutputDeviceWin to new shared memory api

* stub out StatusIconLinuxDbus-related delegate methods

https://chromium-review.googlesource.com/c/chromium/src/+/1638180

* chore: bump chromium in DEPS to 964ea3fd4bdc006d62533f5755043076220181f1

* Remove the BrowserContext methods to create URLRequestContexts for main/media partitions when a partition_domain is specified

https://chromium-review.googlesource.com/c/chromium/src/+/1655087

* fixup! stub out StatusIconLinuxDbus-related delegate methods

* add remote_cocoa to chromium_src deps

https://chromium-review.googlesource.com/c/chromium/src/+/1657068

* fixup! stub out StatusIconLinuxDbus-related delegate methods

* attempt at fix linux-debug build

* add swiftshader/libvulkan.so to arm manifest

* chore: bump chromium in DEPS to 28688f76afef27c36631aa274691e333ddecdc22

* update patches

* chore: bump chromium in DEPS to fe7450e1578a9584189f87d59d0d1a8548bf6b90

* chore: bump chromium in DEPS to f304dfd682dc86a755a6c49a16ee6876e0db45fb

* chore: bump chromium in DEPS to f0fd4d6c365aad9edd83bdfff9954c47d271b75c

* Update patches

* Remove no longer needed WOA patch

* Put back IOThread in BrowserProcess

We need this until we enable the network service.

* move atom.ico to inputs

* Update to latest LKGR to fix no template named 'bitset' in namespace 'std'

* fixup! Put back IOThread in BrowserProcess

* chore: bump chromium in DEPS to dcf9662dc9a896a175d791001350324167b1cad3

* Update patches

content_allow_embedder_to_prevent_locking_scheme_registry.patch is no longer necessary as it was upstreamed via https://chromium-review.googlesource.com/c/chromium/src/+/1637040

* Fix renamed enum

* Use newer docker container

Contains updated dependencies

* Try to track down arm test failures

* Fix arm tests

* chore: bump chromium in DEPS to 8cbceef57b37ee14b9c4c3405a3f7663922c5b5d

* Update patches

* Add needed dependencies for testing 32-bit linux

* Remove arm debugging.

* Remove additional debugging

* Fix compiler errors

* Handle new macOS helper

* Fix compile error on Linux

* chore: bump chromium in DEPS to 66a93991ddaff6a9f1b13d110959947cb03a1860

* Add new helper files to manifests

* fix BUILD.gn for macOS

* Fix compile errors

* Add patch to put back colors needed for autofill/datalist

* chore: bump chromium in DEPS to e89617079f11e33f33cdb3924f719a579c73704b

* Updated patches

* Remove no longer needed patch

* Remove no longer needed patch

* Fix compile error with patch

* Really fix the patch

* chore: bump chromium in DEPS to c70f12476a45840408f1d5ff5968e7f7ceaad9d4

* chore: bump chromium in DEPS to 06d2dd7a8933b41545a7c26349c802f570563fd5

* chore: bump chromium in DEPS to b0b9ff8f727deb519ccbec7cf1c8d9ed543d88ab

* Update patches

* Fix compiler errors

* Fix removed ChromeNetLog

* Revert "Fix removed ChromeNetLog"

This reverts commit 426dfd90b5ab0a9c1df415d71c88e8aed2bd5bbe.

* Remove ChromeNetLog.

https://chromium-review.googlesource.com/c/chromium/src/+/1663846

* chore: bump chromium in DEPS to fefcc4926d58dccd59ac95be65eab3a4ebfe2f29

* Update patches

* Update v8 patches

* Fix lint error

* Fix compile errors

* chore: bump chromium in DEPS to 4de815ef92ef2eef515506fe09bdc466526a8fd9

* Use custom protocol to test baseURLForDataURL

* Use newer SDK (10.0.18362) for Windows

* Update patches

* Update arm manifest since swiftshader reenabled.

* Don't delete dir that isn't ever there.

* Fix compile errors.

* Need src dir created

* Update for removed InspectorFrontendAPI.addExtensions

* Revert "Use newer SDK (10.0.18362) for Windows"

This reverts commit 68763a0c88cdc44b971462e49662aecc167d3d99.

* Revert "Need src dir created"

This reverts commit 7daedc29d0844316d4097648dde7f40f1a3848fb.

* Revert "Don't delete dir that isn't ever there."

This reverts commit bf424bc30ffcb23b1d9a634d4df410342536640e.

* chore: bump chromium in DEPS to 97dab6b0124ea53244caf123921b5d14893bcca7

* chore: bump chromium in DEPS to c87d16d49a85dc7122781f6c979d354c20f7f78b

* chore: bump chromium in DEPS to 004bcee2ea336687cedfda8f8a151806ac757d15

* chore: bump chromium in DEPS to 24428b26a9d15a013b2a253e1084ec3cb54b660b

* chore: bump chromium in DEPS to fd25914e875237df88035a6abf89a70bf1360b57

* Update patches

* Update node to fix build error

* Fix compile errors

* chore: bump chromium in DEPS to 3062b7cf090f1d9522c04ca8fa0a906f88ababe9

* chore: update node ref for pushed tags

* chore: update patches for new chromium

* chore: fix printing patches

* Use new (10.0.18362) Windows SDK

* roll node to fix v8 build issues in debug build

* Add support for plugin helper

* fix: add patch to fix gpu info enumeration

Can be removed once CL lands upstream.

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/1685993

* spec: navigator.requestMIDIAccess now requires a secure origin

This test requires a secure origin so we fake one.

Refs: https://chromium-review.googlesource.com/c/chromium/src/+/1657952

* FIXME: temporarily disable SharedWorker tests

* use released version of node-abstractsocket

* fix abstract-socket
2019-07-02 18:22:09 -07:00

847 lines
30 KiB
JavaScript

const chai = require('chai')
const http = require('http')
const https = require('https')
const path = require('path')
const fs = require('fs')
const send = require('send')
const auth = require('basic-auth')
const ChildProcess = require('child_process')
const { closeWindow } = require('./window-helpers')
const { emittedOnce } = require('./events-helpers')
const { session, BrowserWindow, net, ipcMain } = require('electron')
const { expect } = chai
/* The whole session API doesn't use standard callbacks */
/* eslint-disable standard/no-callback-literal */
describe('session module', () => {
const fixtures = path.resolve(__dirname, '..', 'spec', 'fixtures')
let w = null
const url = 'http://127.0.0.1'
beforeEach(() => {
w = new BrowserWindow({
show: false,
width: 400,
height: 400,
webPreferences: {
nodeIntegration: true,
webviewTag: true,
}
})
})
afterEach(() => {
return closeWindow(w).then(() => { w = null })
})
describe('session.defaultSession', () => {
it('returns the default session', () => {
expect(session.defaultSession).to.equal(session.fromPartition(''))
})
})
describe('session.fromPartition(partition, options)', () => {
it('returns existing session with same partition', () => {
expect(session.fromPartition('test')).to.equal(session.fromPartition('test'))
})
it('created session is ref-counted', () => {
const partition = 'test2'
const userAgent = 'test-agent'
const ses1 = session.fromPartition(partition)
ses1.setUserAgent(userAgent)
expect(ses1.getUserAgent()).to.equal(userAgent)
ses1.destroy()
const ses2 = session.fromPartition(partition)
expect(ses2.getUserAgent()).to.not.equal(userAgent)
})
})
describe('ses.cookies', () => {
const name = '0'
const value = '0'
it('should get cookies', async () => {
const server = http.createServer((req, res) => {
res.setHeader('Set-Cookie', [`${name}=${value}`])
res.end('finished')
server.close()
})
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve))
const { port } = server.address()
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)
})
it('sets cookies', async () => {
const { cookies } = session.defaultSession
const name = '1'
const value = '1'
await cookies.set({ url, name, value, expirationDate: (+new Date) / 1000 + 120 })
const cs = await cookies.get({ url })
expect(cs.some(c => c.name === name && c.value === value)).to.equal(true)
})
it('yields an error when setting a cookie with missing required fields', async () => {
const { cookies } = session.defaultSession
const name = '1'
const value = '1'
await expect(
cookies.set({ url: '', name, value })
).to.eventually.be.rejectedWith('Failed to get cookie domain')
})
it('yields an error when setting a cookie with an invalid URL', async () => {
const { cookies } = session.defaultSession
const name = '1'
const value = '1'
await expect(
cookies.set({ url: 'asdf', name, value })
).to.eventually.be.rejectedWith('Failed to get cookie domain')
})
it('should overwrite previous cookies', async () => {
const { cookies } = session.defaultSession
const name = 'DidOverwrite'
for (const value of [ 'No', 'Yes' ]) {
await cookies.set({ url, name, value, expirationDate: (+new Date()) / 1000 + 120 })
const list = await cookies.get({ url })
expect(list.some(cookie => cookie.name === name && cookie.value === value)).to.equal(true)
}
})
it('should remove cookies', async () => {
const { cookies } = session.defaultSession
const name = '2'
const value = '2'
await cookies.set({ url, name, value, expirationDate: (+new Date()) / 1000 + 120 })
await cookies.remove(url, name)
const list = await cookies.get({ url })
expect(list.some(cookie => cookie.name === name && cookie.value === value)).to.equal(false)
})
it('should set cookie for standard scheme', async () => {
const { cookies } = session.defaultSession
const standardScheme = global.standardScheme
const domain = 'fake-host'
const url = `${standardScheme}://${domain}`
const name = 'custom'
const value = '1'
await cookies.set({ url, name, value, expirationDate: (+new Date()) / 1000 + 120 })
const list = await cookies.get({ url })
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)
})
it('emits a changed event when a cookie is added or removed', async () => {
const changes = []
const { cookies } = session.fromPartition('cookies-changed')
const name = 'foo'
const value = 'bar'
const listener = (event, cookie, cause, removed) => { changes.push({ cookie, cause, removed }) }
const a = emittedOnce(cookies, 'changed')
await cookies.set({ url, name, value, expirationDate: (+new Date()) / 1000 + 120 })
const [, setEventCookie, setEventCause, setEventRemoved] = await a
const b = emittedOnce(cookies, 'changed')
await cookies.remove(url, name)
const [, removeEventCookie, removeEventCause, removeEventRemoved] = await b
expect(setEventCookie.name).to.equal(name)
expect(setEventCookie.value).to.equal(value)
expect(setEventCause).to.equal('explicit')
expect(setEventRemoved).to.equal(false)
expect(removeEventCookie.name).to.equal(name)
expect(removeEventCookie.value).to.equal(value)
expect(removeEventCause).to.equal('explicit')
expect(removeEventRemoved).to.equal(true)
})
describe('ses.cookies.flushStore()', async () => {
it('flushes the cookies to disk', async () => {
const name = 'foo'
const value = 'bar'
const { cookies } = session.defaultSession
await cookies.set({ url, name, value })
await cookies.flushStore()
})
})
it('should survive an app restart for persistent partition', async () => {
const appPath = path.join(fixtures, 'api', 'cookie-app')
const runAppWithPhase = (phase) => {
return new Promise((resolve, reject) => {
let output = ''
const appProcess = ChildProcess.spawn(
process.execPath,
[appPath],
{ env: { PHASE: phase, ...process.env } }
)
appProcess.stdout.on('data', data => { output += data })
appProcess.stdout.on('end', () => {
resolve(output.replace(/(\r\n|\n|\r)/gm, ''))
})
})
}
expect(await runAppWithPhase('one')).to.equal('011')
expect(await runAppWithPhase('two')).to.equal('110')
})
})
describe('ses.clearStorageData(options)', () => {
it('clears localstorage data', async () => {
await w.loadFile(path.join(fixtures, 'api', 'localstorage.html'))
const options = {
origin: 'file://',
storages: ['localstorage'],
quotas: ['persistent']
}
await w.webContents.session.clearStorageData(options)
while (await w.webContents.executeJavaScript('localStorage.length') !== 0) {
// The storage clear isn't instantly visible to the renderer, so keep
// trying until it is.
}
})
})
describe('will-download event', () => {
it('can cancel default download behavior', async () => {
const mockFile = Buffer.alloc(1024)
const contentDisposition = 'inline; filename="mockFile.txt"'
const downloadServer = http.createServer((req, res) => {
res.writeHead(200, {
'Content-Length': mockFile.length,
'Content-Type': 'application/plain',
'Content-Disposition': contentDisposition
})
res.end(mockFile)
downloadServer.close()
})
await new Promise(resolve => downloadServer.listen(0, '127.0.0.1', resolve))
const port = downloadServer.address().port
const url = `http://127.0.0.1:${port}/`
const downloadPrevented = new Promise(resolve => {
w.webContents.session.once('will-download', function (e, item) {
e.preventDefault()
resolve(item)
})
})
w.loadURL(url)
const item = await downloadPrevented
expect(item.getURL()).to.equal(url)
expect(item.getFilename()).to.equal('mockFile.txt')
await new Promise(setImmediate)
expect(() => item.getURL()).to.throw('Object has been destroyed')
})
})
describe('ses.protocol', () => {
const partitionName = 'temp'
const protocolName = 'sp'
let customSession = null
const protocol = session.defaultSession.protocol
const handler = (ignoredError, callback) => {
callback({ data: `<script>require('electron').ipcRenderer.send('hello')</script>`, mimeType: 'text/html' })
}
beforeEach(async () => {
if (w != null) w.destroy()
w = new BrowserWindow({
show: false,
webPreferences: {
partition: partitionName,
nodeIntegration: true,
}
})
customSession = session.fromPartition(partitionName)
await customSession.protocol.registerStringProtocol(protocolName, handler)
})
afterEach(async () => {
await customSession.protocol.unregisterProtocol(protocolName)
customSession = null
})
it('does not affect defaultSession', async () => {
const result1 = await protocol.isProtocolHandled(protocolName)
expect(result1).to.equal(false)
const result2 = await customSession.protocol.isProtocolHandled(protocolName)
expect(result2).to.equal(true)
})
it('handles requests from partition', async () => {
w.loadURL(`${protocolName}://fake-host`)
await emittedOnce(ipcMain, 'hello')
})
})
describe('ses.setProxy(options)', () => {
let server = null
let customSession = null
beforeEach(async () => {
customSession = session.fromPartition('proxyconfig')
// FIXME(deepak1556): This is just a hack to force
// creation of request context which in turn initializes
// the network context, can be removed with network
// service enabled.
await customSession.clearHostResolverCache()
})
afterEach(() => {
if (server) {
server.close()
}
if (customSession) {
customSession.destroy()
}
})
it('allows configuring proxy settings', async () => {
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')
})
it('allows removing the implicit bypass rules for localhost', async () => {
const config = {
proxyRules: 'http=myproxy:80',
proxyBypassRules: '<-loopback>'
}
await customSession.setProxy(config)
const proxy = await customSession.resolveProxy('http://localhost')
expect(proxy).to.equal('PROXY myproxy:80')
})
it('allows configuring proxy settings with pacScript', async () => {
server = http.createServer((req, res) => {
const pac = `
function FindProxyForURL(url, host) {
return "PROXY myproxy:8132";
}
`
res.writeHead(200, {
'Content-Type': 'application/x-ns-proxy-autoconfig'
})
res.end(pac)
})
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve))
const config = { pacScript: `http://127.0.0.1:${server.address().port}` }
await customSession.setProxy(config)
const proxy = await customSession.resolveProxy('https://google.com')
expect(proxy).to.equal('PROXY myproxy:8132')
})
it('allows bypassing proxy settings', async () => {
const config = {
proxyRules: 'http=myproxy:80',
proxyBypassRules: '<local>'
}
await customSession.setProxy(config)
const proxy = await customSession.resolveProxy('http://example/')
expect(proxy).to.equal('DIRECT')
})
})
describe('ses.getBlobData()', () => {
const scheme = 'cors-blob'
const protocol = session.defaultSession.protocol
const url = `${scheme}://host`
after(async () => {
await protocol.unregisterProtocol(scheme)
})
it('returns blob data for uuid', (done) => {
const postData = JSON.stringify({
type: 'blob',
value: 'hello'
})
const content = `<html>
<script>
let fd = new FormData();
fd.append('file', new Blob(['${postData}'], {type:'application/json'}));
fetch('${url}', {method:'POST', body: fd });
</script>
</html>`
protocol.registerStringProtocol(scheme, (request, callback) => {
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 => {
expect(result.toString()).to.equal(postData)
done()
})
}
}, (error) => {
if (error) return done(error)
w.loadURL(url)
})
})
})
describe('ses.setCertificateVerifyProc(callback)', (done) => {
let server = null
beforeEach((done) => {
const certPath = path.join(fixtures, '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
}
server = https.createServer(options, (req, res) => {
res.writeHead(200)
res.end('<title>hello</title>')
})
server.listen(0, '127.0.0.1', done)
})
afterEach((done) => {
session.defaultSession.setCertificateVerifyProc(null)
server.close(done)
})
it('accepts the request when the callback is called with 0', async () => {
session.defaultSession.setCertificateVerifyProc(({ hostname, certificate, verificationResult, errorCode }, callback) => {
expect(['net::ERR_CERT_AUTHORITY_INVALID', 'net::ERR_CERT_COMMON_NAME_INVALID'].includes(verificationResult)).to.be.true
expect([-202, -200].includes(errorCode)).to.be.true
callback(0)
})
await w.loadURL(`https://127.0.0.1:${server.address().port}`)
expect(w.webContents.getTitle()).to.equal('hello')
})
it('rejects the request when the callback is called with -2', async () => {
session.defaultSession.setCertificateVerifyProc(({ hostname, certificate, verificationResult }, callback) => {
expect(hostname).to.equal('127.0.0.1')
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(['net::ERR_CERT_AUTHORITY_INVALID', 'net::ERR_CERT_COMMON_NAME_INVALID'].includes(verificationResult)).to.be.true
callback(-2)
})
const url = `https://127.0.0.1:${server.address().port}`
await expect(w.loadURL(url)).to.eventually.be.rejectedWith(/ERR_FAILED/)
expect(w.webContents.getTitle()).to.equal(url)
})
it('saves cached results', async () => {
let numVerificationRequests = 0
session.defaultSession.setCertificateVerifyProc(({ hostname, certificate, verificationResult }, callback) => {
numVerificationRequests++
callback(-2)
})
const url = `https://127.0.0.1:${server.address().port}`
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')
// TODO(nornagon): there's no way to check if the network service is
// enabled from JS, so once we switch it on by default just change this
// test :)
const networkServiceEnabled = false
expect(numVerificationRequests).to.equal(networkServiceEnabled ? 1 : 2)
})
})
describe('ses.clearAuthCache(options)', () => {
it('can clear http auth info from cache', (done) => {
const ses = session.fromPartition('auth-cache')
const server = http.createServer((req, res) => {
const credentials = auth(req)
if (!credentials || credentials.name !== 'test' || credentials.pass !== 'test') {
res.statusCode = 401
res.setHeader('WWW-Authenticate', 'Basic realm="Restricted"')
res.end()
} else {
res.end('authenticated')
}
})
server.listen(0, '127.0.0.1', () => {
const port = server.address().port
function issueLoginRequest (attempt = 1) {
if (attempt > 2) {
server.close()
return done()
}
const request = net.request({
url: `http://127.0.0.1:${port}`,
session: ses
})
request.on('login', (info, callback) => {
attempt += 1
expect(info.scheme).to.equal('basic')
expect(info.realm).to.equal('Restricted')
callback('test', 'test')
})
request.on('response', (response) => {
let data = ''
response.pause()
response.on('data', (chunk) => {
data += chunk
})
response.on('end', () => {
expect(data).to.equal('authenticated')
ses.clearAuthCache({ type: 'password' }).then(() => {
issueLoginRequest(attempt)
})
})
response.on('error', (error) => { done(error) })
response.resume()
})
// Internal api to bypass cache for testing.
request.urlRequest._setLoadFlags(1 << 1)
request.end()
}
issueLoginRequest()
})
})
})
describe('DownloadItem', () => {
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 = null
let downloadServer = null
before(async () => {
downloadServer = http.createServer((req, res) => {
address = downloadServer.address()
res.writeHead(200, {
'Content-Length': mockPDF.length,
'Content-Type': 'application/pdf',
'Content-Disposition': req.url === '/?testFilename' ? 'inline' : contentDisposition
})
res.end(mockPDF)
})
await new Promise(resolve => downloadServer.listen(0, '127.0.0.1', resolve))
})
after(async () => {
await new Promise(resolve => downloadServer.close(resolve))
})
const isPathEqual = (path1, path2) => {
return path.relative(path1, path2) === ''
}
const assertDownload = (state, item, isCustom = false) => {
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)
if (isCustom) {
expect(item.getURL()).to.equal(`${protocolName}://item`)
} else {
expect(item.getURL()).to.be.equal(`${url}:${address.port}/`)
}
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)
}
it('can download using WebContents.downloadURL', (done) => {
const port = downloadServer.address().port
w.webContents.session.once('will-download', function (e, item) {
item.savePath = downloadFilePath
item.on('done', function (e, state) {
assertDownload(state, item)
done()
})
})
w.webContents.downloadURL(`${url}:${port}`)
})
it('can download from custom protocols using WebContents.downloadURL', (done) => {
const protocol = session.defaultSession.protocol
const port = downloadServer.address().port
const handler = (ignoredError, callback) => {
callback({ url: `${url}:${port}` })
}
protocol.registerHttpProtocol(protocolName, handler, (error) => {
if (error) return done(error)
w.webContents.session.once('will-download', function (e, item) {
item.savePath = downloadFilePath
item.on('done', function (e, state) {
assertDownload(state, item, true)
done()
})
})
w.webContents.downloadURL(`${protocolName}://item`)
})
})
it('can download using WebView.downloadURL', async () => {
const port = downloadServer.address().port
await w.loadURL('about:blank')
function webviewDownload({fixtures, url, port}) {
const webview = new WebView()
webview.addEventListener('did-finish-load', () => {
webview.downloadURL(`${url}:${port}/`)
})
webview.src = `file://${fixtures}/api/blank.html`
document.body.appendChild(webview)
}
const done = new Promise(resolve => {
w.webContents.session.once('will-download', function (e, item) {
item.savePath = downloadFilePath
item.on('done', function (e, state) {
resolve([state, item])
})
})
})
await w.webContents.executeJavaScript(`(${webviewDownload})(${JSON.stringify({fixtures, url, port})})`)
const [state, item] = await done
assertDownload(state, item)
})
it('can cancel download', (done) => {
const port = downloadServer.address().port
w.webContents.session.once('will-download', function (e, item) {
item.savePath = downloadFilePath
item.on('done', function (e, state) {
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()
})
item.cancel()
})
w.webContents.downloadURL(`${url}:${port}/`)
})
it('can generate a default filename', function (done) {
if (process.env.APPVEYOR === 'True') {
// FIXME(alexeykuzmin): Skip the test.
// this.skip()
return done()
}
const port = downloadServer.address().port
w.webContents.session.once('will-download', function (e, item) {
item.savePath = downloadFilePath
item.on('done', function (e, state) {
expect(item.getFilename()).to.equal('download.pdf')
done()
})
item.cancel()
})
w.webContents.downloadURL(`${url}:${port}/?testFilename`)
})
it('can set options for the save dialog', (done) => {
const filePath = path.join(__dirname, 'fixtures', 'mock.pdf')
const port = downloadServer.address().port
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
}
w.webContents.session.once('will-download', function (e, item) {
item.setSavePath(filePath)
item.setSaveDialogOptions(options)
item.on('done', function (e, state) {
expect(item.getSaveDialogOptions()).to.deep.equal(options)
done()
})
item.cancel()
})
w.webContents.downloadURL(`${url}:${port}`)
})
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) => {
w.webContents.session.once('will-download', function (e, item) {
item.savePath = downloadFilePath
if (item.getState() === 'interrupted') {
item.resume()
}
item.on('done', function (e, state) {
expect(state).to.equal('interrupted')
done()
})
})
w.webContents.downloadURL(`file://${path.join(__dirname, 'does-not-exist.txt')}`)
})
})
})
describe('ses.createInterruptedDownload(options)', () => {
it('can create an interrupted download item', (done) => {
const downloadFilePath = path.join(__dirname, '..', 'fixtures', 'mock.pdf')
const options = {
path: downloadFilePath,
urlChain: ['http://127.0.0.1/'],
mimeType: 'application/pdf',
offset: 0,
length: 5242880
}
w.webContents.session.once('will-download', function (e, item) {
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)
done()
})
w.webContents.session.createInterruptedDownload(options)
})
it('can be resumed', async () => {
const downloadFilePath = path.join(fixtures, 'logo.png')
const rangeServer = http.createServer((req, res) => {
const options = { root: fixtures }
send(req, req.url, options)
.on('error', (error) => { done(error) }).pipe(res)
})
try {
await new Promise(resolve => rangeServer.listen(0, '127.0.0.1', resolve))
const port = rangeServer.address().port
const downloadCancelled = new Promise((resolve) => {
w.webContents.session.once('will-download', function (e, item) {
item.setSavePath(downloadFilePath)
item.on('done', function (e, state) {
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')
const options = {
path: item.savePath,
urlChain: item.getURLChain(),
mimeType: item.getMimeType(),
offset: item.getReceivedBytes(),
length: item.getTotalBytes(),
lastModified: item.getLastModifiedTime(),
eTag: item.getETag(),
}
const downloadResumed = new Promise((resolve) => {
w.webContents.session.once('will-download', function (e, item) {
expect(item.getState()).to.equal('interrupted')
item.setSavePath(downloadFilePath)
item.resume()
item.on('done', function (e, state) {
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)
} finally {
rangeServer.close()
}
})
})
describe('ses.setPermissionRequestHandler(handler)', () => {
it('cancels any pending requests when cleared', async () => {
if (w != null) w.destroy()
w = new BrowserWindow({
show: false,
webPreferences: {
partition: `very-temp-permision-handler`,
nodeIntegration: true,
}
})
const ses = w.webContents.session
ses.setPermissionRequestHandler(() => {
ses.setPermissionRequestHandler(null)
})
ses.protocol.interceptStringProtocol('https', (req, cb) => {
cb(`<html><script>(${remote})()</script></html>`)
})
const result = emittedOnce(require('electron').ipcMain, 'message')
function remote() {
navigator.requestMIDIAccess({sysex: true}).then(() => {}, (err) => {
require('electron').ipcRenderer.send('message', err.name);
});
}
await w.loadURL('https://myfakesite')
const [,name] = await result
expect(name).to.deep.equal('SecurityError')
})
})
})