const assert = require('assert')

const chai = require('chai')

const dirtyChai = require('dirty-chai')

const fs = require('fs')

const path = require('path')

const os = require('os')

const qs = require('querystring')

const http = require('http')

const { closeWindow } = require('./window-helpers')

const { emittedOnce } = require('./events-helpers')

const { resolveGetters } = require('./assert-helpers')

const { ipcRenderer, remote, screen } = require('electron')

const { app, ipcMain, BrowserWindow, BrowserView, protocol, session, webContents } = remote

const features = process.atomBinding('features')

const { expect } = chai

const isCI = remote.getGlobal('isCi')

const nativeModulesEnabled = remote.getGlobal('nativeModulesEnabled')

describe('BrowserWindow module', () => {

const fixtures = path.resolve(__dirname, 'fixtures')

let w = null

let iw = null

let ws = null

let server

let postData

const defaultOptions = {

show: false,

width: 400,

height: 400,

webPreferences: {

backgroundThrottling: false

}

}

const openTheWindow = async (options = defaultOptions) => {

}

const closeTheWindow = function () {

return closeWindow(w).then(() => { w = null })

}

before((done) => {

const filePath = path.join(fixtures, 'pages', 'a.html')

const fileStats = fs.statSync(filePath)

postData = [

{

type: 'rawData',

bytes: Buffer.from('username=test&file=')

},

{

type: 'file',

filePath: filePath,

offset: 0,

length: fileStats.size,

modificationTime: fileStats.mtime.getTime() / 1000

}

]

server = http.createServer((req, res) => {

function respond () {

}

setTimeout(respond, req.url.includes('slow') ? 200 : 0)

})

server.listen(0, '127.0.0.1', () => {

server.url = `http://127.0.0.1:${server.address().port}`

done()

})

})

after(() => {

server.close()

server = null

})

beforeEach(openTheWindow)

afterEach(closeTheWindow)

describe('BrowserWindow constructor', () => {

it('allows passing void 0 as the webContents', () => {

openTheWindow({

webContents: void 0

})

})

})

describe('BrowserWindow.close()', () => {

let server

before((done) => {

server = http.createServer((request, response) => {

switch (request.url) {

case '/404':

response.statusCode = '404'

response.end()

break

case '/301':

response.statusCode = '301'

response.setHeader('Location', '/200')

response.end()

break

case '/200':

response.statusCode = '200'

response.end('hello')

break

case '/title':

response.statusCode = '200'

response.end('<title>Hello</title>')

break

default:

done('unsupported endpoint')

}

}).listen(0, '127.0.0.1', () => {

server.url = 'http://127.0.0.1:' + server.address().port

done()

})

})

after(() => {

server.close()

server = null

})

it('should emit unload handler', (done) => {

w.webContents.on('did-finish-load', () => { w.close() })

w.once('closed', () => {

const test = path.join(fixtures, 'api', 'unload')

const content = fs.readFileSync(test)

fs.unlinkSync(test)

assert.strictEqual(String(content), 'unload')

done()

})

w.loadFile(path.join(fixtures, 'api', 'unload.html'))

})

it('should emit beforeunload handler', (done) => {

w.once('onbeforeunload', () => { done() })

w.webContents.on('did-finish-load', () => { w.close() })

w.loadFile(path.join(fixtures, 'api', 'beforeunload-false.html'))

})

it('should not crash when invoked synchronously inside navigation observer', (done) => {

const events = [

{ name: 'did-start-loading', url: `${server.url}/200` },

{ name: 'dom-ready', url: `${server.url}/200` },

{ name: 'page-title-updated', url: `${server.url}/title` },

{ name: 'did-stop-loading', url: `${server.url}/200` },

{ name: 'did-finish-load', url: `${server.url}/200` },

{ name: 'did-frame-finish-load', url: `${server.url}/200` },

{ name: 'did-fail-load', url: `${server.url}/404` }

]

const responseEvent = 'window-webContents-destroyed'

function * genNavigationEvent () {

}

const gen = genNavigationEvent()

ipcRenderer.on(responseEvent, () => {

if (!gen.next().value) done()

})

gen.next()

})

})

describe('window.close()', () => {

it('should emit unload handler', (done) => {

w.once('closed', () => {

const test = path.join(fixtures, 'api', 'close')

const content = fs.readFileSync(test)

fs.unlinkSync(test)

assert.strictEqual(String(content), 'close')

done()

})

w.loadFile(path.join(fixtures, 'api', 'close.html'))

})

it('should emit beforeunload handler', (done) => {

w.once('onbeforeunload', () => { done() })

w.loadFile(path.join(fixtures, 'api', 'close-beforeunload-false.html'))

})

})

describe('BrowserWindow.destroy()', () => {

it('prevents users to access methods of webContents', () => {

const contents = w.webContents

w.destroy()

assert.throws(() => {

contents.getProcessId()

}, /Object has been destroyed/)

})

it('should not crash when destroying windows with pending events', (done) => {

const responseEvent = 'destroy-test-completed'

ipcRenderer.on(responseEvent, () => done())

ipcRenderer.send('test-browserwindow-destroy', { responseEvent })

})

})

describe('BrowserWindow.loadURL(url)', () => {

it('should emit did-start-loading event', (done) => {

w.webContents.on('did-start-loading', () => { done() })

w.loadURL('about:blank')

})

it('should emit ready-to-show event', (done) => {

w.on('ready-to-show', () => { done() })

w.loadURL('about:blank')

})

it('should emit did-fail-load event for files that do not exist', (done) => {

w.webContents.on('did-fail-load', (event, code, desc, url, isMainFrame) => {

assert.strictEqual(code, -6)

assert.strictEqual(desc, 'ERR_FILE_NOT_FOUND')

assert.strictEqual(isMainFrame, true)

done()

})

w.loadURL('file://a.txt')

})

it('should emit did-fail-load event for invalid URL', (done) => {

w.webContents.on('did-fail-load', (event, code, desc, url, isMainFrame) => {

assert.strictEqual(desc, 'ERR_INVALID_URL')

assert.strictEqual(code, -300)

assert.strictEqual(isMainFrame, true)

done()

})

w.loadURL('http://example:port')

})

it('should set `mainFrame = false` on did-fail-load events in iframes', (done) => {

w.webContents.on('did-fail-load', (event, code, desc, url, isMainFrame) => {

assert.strictEqual(isMainFrame, false)

done()

})

w.loadFile(path.join(fixtures, 'api', 'did-fail-load-iframe.html'))

})

it('does not crash in did-fail-provisional-load handler', (done) => {

w.webContents.once('did-fail-provisional-load', () => {

w.loadURL('http://127.0.0.1:11111')

done()

})

w.loadURL('http://127.0.0.1:11111')

})

it('should emit did-fail-load event for URL exceeding character limit', (done) => {

w.webContents.on('did-fail-load', (event, code, desc, url, isMainFrame) => {

assert.strictEqual(desc, 'ERR_INVALID_URL')

assert.strictEqual(code, -300)

assert.strictEqual(isMainFrame, true)

done()

})

const data = Buffer.alloc(2 * 1024 * 1024).toString('base64')

w.loadURL(`data:image/png;base64,${data}`)

})

describe('POST navigations', () => {

afterEach(() => { w.webContents.session.webRequest.onBeforeSendHeaders(null) })

it('supports specifying POST data', (done) => {

w.webContents.on('did-finish-load', () => done())

w.loadURL(server.url, { postData: postData })

})

it('sets the content type header on URL encoded forms', (done) => {

w.webContents.on('did-finish-load', () => {

w.webContents.session.webRequest.onBeforeSendHeaders((details, callback) => {

assert.strictEqual(details.requestHeaders['content-type'], 'application/x-www-form-urlencoded')

done()

})

w.webContents.executeJavaScript(`

})

w.loadURL(server.url)

})

it('sets the content type header on multi part forms', (done) => {

w.webContents.on('did-finish-load', () => {

w.webContents.session.webRequest.onBeforeSendHeaders((details, callback) => {

assert(details.requestHeaders['content-type'].startsWith('multipart/form-data; boundary=----WebKitFormBoundary'))

done()

})

w.webContents.executeJavaScript(`

})

w.loadURL(server.url)

})

})

it('should support support base url for data urls', (done) => {

ipcMain.once('answer', (event, test) => {

assert.strictEqual(test, 'test')

done()

})

w.loadURL('data:text/html,<script src="loaded-from-dataurl.js"></script>', { baseURLForDataURL: `file://${path.join(fixtures, 'api')}${path.sep}` })

})

})

describe('will-navigate event', () => {

it('allows the window to be closed from the event listener', (done) => {

ipcRenderer.send('close-on-will-navigate', w.id)

ipcRenderer.once('closed-on-will-navigate', () => { done() })

w.loadFile(path.join(fixtures, 'pages', 'will-navigate.html'))

})

})

describe('will-redirect event', () => {

it('is emitted on redirects', (done) => {

w.webContents.on('will-redirect', (event, url) => {

done()

})

w.loadURL(`${server.url}/302`)

})

it('is emitted after will-navigate on redirects', (done) => {

let navigateCalled = false

w.webContents.on('will-navigate', () => {

navigateCalled = true

})

w.webContents.on('will-redirect', (event, url) => {

expect(navigateCalled).to.equal(true, 'should have called will-navigate first')

done()

})

w.loadURL(`${server.url}/navigate-302`)

})

it('is emitted before did-stop-loading on redirects', (done) => {

let stopCalled = false

w.webContents.on('did-stop-loading', () => {

stopCalled = true

})

w.webContents.on('will-redirect', (event, url) => {

expect(stopCalled).to.equal(false, 'should not have called did-stop-loading first')

done()

})

w.loadURL(`${server.url}/302`)

})

it('allows the window to be closed from the event listener', (done) => {

ipcRenderer.send('close-on-will-redirect', w.id)

ipcRenderer.once('closed-on-will-redirect', () => { done() })

w.loadURL(`${server.url}/302`)

})

it('can be prevented', (done) => {

ipcRenderer.send('prevent-will-redirect', w.id)

w.webContents.on('will-navigate', (e, url) => {

expect(url).to.equal(`${server.url}/302`)

})

w.webContents.on('did-stop-loading', () => {

expect(w.webContents.getURL()).to.equal(

`${server.url}/navigate-302`,

'url should not have changed after navigation event'

)

done()

})

w.webContents.on('will-redirect', (e, url) => {

expect(url).to.equal(`${server.url}/200`)

})

w.loadURL(`${server.url}/navigate-302`)

})

})

describe('BrowserWindow.show()', () => {

before(function () {

if (isCI) {

this.skip()

}

})

it('should focus on window', () => {

w.show()

assert(w.isFocused())

})

it('should make the window visible', () => {

w.show()

assert(w.isVisible())

})

it('emits when window is shown', (done) => {

w.once('show', () => {

assert.strictEqual(w.isVisible(), true)

done()

})

w.show()

})

})

describe('BrowserWindow.hide()', () => {

before(function () {

if (isCI) {

this.skip()

}

})

it('should defocus on window', () => {

w.hide()

assert(!w.isFocused())

})

it('should make the window not visible', () => {

w.show()

w.hide()

assert(!w.isVisible())

})

it('emits when window is hidden', (done) => {

w.show()

w.once('hide', () => {

assert.strictEqual(w.isVisible(), false)

done()

})

w.hide()

})

})

describe('BrowserWindow.showInactive()', () => {

it('should not focus on window', () => {

w.showInactive()

assert(!w.isFocused())

})

})

describe('BrowserWindow.focus()', () => {

it('does not make the window become visible', () => {

assert.strictEqual(w.isVisible(), false)

w.focus()

assert.strictEqual(w.isVisible(), false)

})

})

describe('BrowserWindow.blur()', () => {

it('removes focus from window', () => {

w.blur()

assert(!w.isFocused())

})

})

describe('BrowserWindow.getFocusedWindow()', (done) => {

it('returns the opener window when dev tools window is focused', (done) => {

w.show()

w.webContents.once('devtools-focused', () => {

assert.deepStrictEqual(BrowserWindow.getFocusedWindow(), w)

done()

})

w.webContents.openDevTools({ mode: 'undocked' })

})

})

describe('BrowserWindow.capturePage(rect, callback)', () => {

it('calls the callback with a Buffer', async () => {

const image = await new Promise((resolve) => {

w.capturePage({

x: 0,

y: 0,

width: 100,

height: 100

}, resolve)

})

expect(image.isEmpty()).to.be.true()

})

it('preserves transparency', async () => {

const w = await openTheWindow({

show: false,

width: 400,

height: 400,

transparent: true

})

const p = emittedOnce(w, 'ready-to-show')

w.loadURL('data:text/html,<html><body background-color: rgba(255,255,255,0)></body></html>')

await p

w.show()

const image = await new Promise((resolve) => w.capturePage(resolve))

const imgBuffer = image.toPNG()

// Check the 25th byte in the PNG.

// Values can be 0,2,3,4, or 6. We want 6, which is RGB + Alpha

expect(imgBuffer[25]).to.equal(6)

})

})

describe('BrowserWindow.setBounds(bounds[, animate])', () => {

it('sets the window bounds with full bounds', () => {

const fullBounds = { x: 440, y: 225, width: 500, height: 400 }

w.setBounds(fullBounds)

assertBoundsEqual(w.getBounds(), fullBounds)

})

it('sets the window bounds with partial bounds', () => {

const fullBounds = { x: 440, y: 225, width: 500, height: 400 }

w.setBounds(fullBounds)

const boundsUpdate = { width: 200 }

w.setBounds(boundsUpdate)

const expectedBounds = Object.assign(fullBounds, boundsUpdate)

assertBoundsEqual(w.getBounds(), expectedBounds)

})

})

describe('BrowserWindow.setSize(width, height)', () => {

it('sets the window size', async () => {

const size = [300, 400]

const resized = emittedOnce(w, 'resize')

w.setSize(size[0], size[1])

await resized

assertBoundsEqual(w.getSize(), size)

})

})

describe('BrowserWindow.setMinimum/MaximumSize(width, height)', () => {

it('sets the maximum and minimum size of the window', () => {

assert.deepStrictEqual(w.getMinimumSize(), [0, 0])

assert.deepStrictEqual(w.getMaximumSize(), [0, 0])

w.setMinimumSize(100, 100)

assertBoundsEqual(w.getMinimumSize(), [100, 100])

assertBoundsEqual(w.getMaximumSize(), [0, 0])

w.setMaximumSize(900, 600)

assertBoundsEqual(w.getMinimumSize(), [100, 100])

assertBoundsEqual(w.getMaximumSize(), [900, 600])

})

})

describe('BrowserWindow.setAspectRatio(ratio)', () => {

it('resets the behaviour when passing in 0', (done) => {

const size = [300, 400]

w.setAspectRatio(1 / 2)

w.setAspectRatio(0)

w.once('resize', () => {

assertBoundsEqual(w.getSize(), size)

done()

})

w.setSize(size[0], size[1])

})

})

describe('BrowserWindow.setPosition(x, y)', () => {

it('sets the window position', (done) => {

const pos = [10, 10]

w.once('move', () => {

const newPos = w.getPosition()

assert.strictEqual(newPos[0], pos[0])

assert.strictEqual(newPos[1], pos[1])

done()

})

w.setPosition(pos[0], pos[1])

})

})

describe('BrowserWindow.setContentSize(width, height)', () => {

it('sets the content size', () => {

const size = [400, 400]

w.setContentSize(size[0], size[1])

const after = w.getContentSize()

assert.strictEqual(after[0], size[0])

assert.strictEqual(after[1], size[1])

})

it('works for a frameless window', () => {

w.destroy()

w = new BrowserWindow({

show: false,

frame: false,

width: 400,

height: 400

})

const size = [400, 400]

w.setContentSize(size[0], size[1])

const after = w.getContentSize()

assert.strictEqual(after[0], size[0])

assert.strictEqual(after[1], size[1])

})

})

describe('BrowserWindow.setContentBounds(bounds)', () => {

it('sets the content size and position', (done) => {

const bounds = { x: 10, y: 10, width: 250, height: 250 }

w.once('resize', () => {

assertBoundsEqual(w.getContentBounds(), bounds)

done()

})

w.setContentBounds(bounds)

})

it('works for a frameless window', (done) => {

w.destroy()

w = new BrowserWindow({

show: false,

frame: false,

width: 300,

height: 300

})

const bounds = { x: 10, y: 10, width: 250, height: 250 }

w.once('resize', () => {

assert.deepStrictEqual(w.getContentBounds(), bounds)

done()

})

w.setContentBounds(bounds)

})

})

describe(`BrowserWindow.getNormalBounds()`, () => {

describe(`Normal state`, () => {

it(`checks normal bounds after resize`, (done) => {

const size = [300, 400]

w.once('resize', () => {

assertBoundsEqual(w.getNormalBounds(), w.getBounds())

done()

})

w.setSize(size[0], size[1])

})

it(`checks normal bounds after move`, (done) => {

const pos = [10, 10]

w.once('move', () => {

assertBoundsEqual(w.getNormalBounds(), w.getBounds())

done()

})

w.setPosition(pos[0], pos[1])

})

})

describe(`Maximized state`, () => {

before(function () {

if (isCI) {

this.skip()

}

})

it(`checks normal bounds when maximized`, (done) => {

const bounds = w.getBounds()

w.once('maximize', () => {

assertBoundsEqual(w.getNormalBounds(), bounds)

done()

})

w.show()

w.maximize()

})

it(`checks normal bounds when unmaximized`, (done) => {

const bounds = w.getBounds()

w.once('maximize', () => {

w.unmaximize()

})

w.once('unmaximize', () => {

assertBoundsEqual(w.getNormalBounds(), bounds)

done()

})

w.show()

w.maximize()

})

})

describe(`Minimized state`, () => {

before(function () {

if (isCI) {

this.skip()

}

})

it(`checks normal bounds when minimized`, (done) => {

const bounds = w.getBounds()

w.once('minimize', () => {

assertBoundsEqual(w.getNormalBounds(), bounds)

done()

})

w.show()

w.minimize()

})

it(`checks normal bounds when restored`, (done) => {

const bounds = w.getBounds()

w.once('minimize', () => {

w.restore()

})

w.once('restore', () => {

assertBoundsEqual(w.getNormalBounds(), bounds)

done()

})

w.show()

w.minimize()

})

})

describe(`Fullscreen state`, () => {

before(function () {

if (isCI) {

this.skip()

}

if (process.platform === 'darwin') {

this.skip()

}

})

it(`checks normal bounds when fullscreen'ed`, (done) => {

const bounds = w.getBounds()

w.once('enter-full-screen', () => {

assertBoundsEqual(w.getNormalBounds(), bounds)

done()

})

w.show()

w.setFullScreen(true)

})

it(`checks normal bounds when unfullscreen'ed`, (done) => {