import { BrowserWindow, ipcMain } from 'electron/main';
import { contextBridge } from 'electron/renderer';
import { expect } from 'chai';
import * as fs from 'fs-extra';
import * as http from 'http';
import * as os from 'os';
import * as path from 'path';
import * as cp from 'child_process';

import { closeWindow } from './window-helpers';
import { emittedOnce } from './events-helpers';
import { AddressInfo } from 'net';

const fixturesPath = path.resolve(__dirname, 'fixtures', 'api', 'context-bridge');

describe('contextBridge', () => {
  let w: BrowserWindow;
  let dir: string;
  let server: http.Server;

  before(async () => {
    server = http.createServer((req, res) => {
      res.setHeader('Content-Type', 'text/html');
      res.end('');
    });
    await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
  });

  after(async () => {
    if (server) await new Promise(resolve => server.close(resolve));
    server = null as any;
  });

  afterEach(async () => {
    await closeWindow(w);
    if (dir) await fs.remove(dir);
  });

  it('should not be accessible when contextIsolation is disabled', async () => {
    w = new BrowserWindow({
      show: false,
      webPreferences: {
        contextIsolation: false,
        preload: path.resolve(fixturesPath, 'can-bind-preload.js')
      }
    });
    const [, bound] = await emittedOnce(ipcMain, 'context-bridge-bound', () => w.loadFile(path.resolve(fixturesPath, 'empty.html')));
    expect(bound).to.equal(false);
  });

  it('should be accessible when contextIsolation is enabled', async () => {
    w = new BrowserWindow({
      show: false,
      webPreferences: {
        contextIsolation: true,
        preload: path.resolve(fixturesPath, 'can-bind-preload.js')
      }
    });
    const [, bound] = await emittedOnce(ipcMain, 'context-bridge-bound', () => w.loadFile(path.resolve(fixturesPath, 'empty.html')));
    expect(bound).to.equal(true);
  });

  const generateTests = (useSandbox: boolean) => {
    describe(`with sandbox=${useSandbox}`, () => {
      const makeBindingWindow = async (bindingCreator: Function) => {
        const preloadContent = `const renderer_1 = require('electron');
        ${useSandbox ? '' : `require('v8').setFlagsFromString('--expose_gc');
        const gc=require('vm').runInNewContext('gc');
        renderer_1.contextBridge.exposeInMainWorld('GCRunner', {
          run: () => gc()
        });`}
        (${bindingCreator.toString()})();`;
        const tmpDir = await fs.mkdtemp(path.resolve(os.tmpdir(), 'electron-spec-preload-'));
        dir = tmpDir;
        await fs.writeFile(path.resolve(tmpDir, 'preload.js'), preloadContent);
        w = new BrowserWindow({
          show: false,
          webPreferences: {
            contextIsolation: true,
            nodeIntegration: true,
            sandbox: useSandbox,
            preload: path.resolve(tmpDir, 'preload.js'),
            additionalArguments: ['--unsafely-expose-electron-internals-for-testing']
          }
        });
        await w.loadURL(`http://127.0.0.1:${(server.address() as AddressInfo).port}`);
      };

      const callWithBindings = (fn: Function) =>
        w.webContents.executeJavaScript(`(${fn.toString()})(window)`);

      const getGCInfo = async (): Promise<{
        trackedValues: number;
      }> => {
        const [, info] = await emittedOnce(ipcMain, 'gc-info', () => w.webContents.send('get-gc-info'));
        return info;
      };

      const forceGCOnWindow = async () => {
        w.webContents.debugger.attach();
        await w.webContents.debugger.sendCommand('HeapProfiler.enable');
        await w.webContents.debugger.sendCommand('HeapProfiler.collectGarbage');
        await w.webContents.debugger.sendCommand('HeapProfiler.disable');
        w.webContents.debugger.detach();
      };

      it('should proxy numbers', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', 123);
        });
        const result = await callWithBindings((root: any) => {
          return root.example;
        });
        expect(result).to.equal(123);
      });

      it('should make global properties read-only', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', 123);
        });
        const result = await callWithBindings((root: any) => {
          root.example = 456;
          return root.example;
        });
        expect(result).to.equal(123);
      });

      it('should proxy nested numbers', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            myNumber: 123
          });
        });
        const result = await callWithBindings((root: any) => {
          return root.example.myNumber;
        });
        expect(result).to.equal(123);
      });

      it('should make properties unwriteable', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            myNumber: 123
          });
        });
        const result = await callWithBindings((root: any) => {
          root.example.myNumber = 456;
          return root.example.myNumber;
        });
        expect(result).to.equal(123);
      });

      it('should proxy strings', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', 'my-words');
        });
        const result = await callWithBindings((root: any) => {
          return root.example;
        });
        expect(result).to.equal('my-words');
      });

      it('should proxy nested strings', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            myString: 'my-words'
          });
        });
        const result = await callWithBindings((root: any) => {
          return root.example.myString;
        });
        expect(result).to.equal('my-words');
      });

      it('should proxy arrays', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', [123, 'my-words']);
        });
        const result = await callWithBindings((root: any) => {
          return [root.example, Array.isArray(root.example)];
        });
        expect(result).to.deep.equal([[123, 'my-words'], true]);
      });

      it('should proxy nested arrays', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            myArr: [123, 'my-words']
          });
        });
        const result = await callWithBindings((root: any) => {
          return root.example.myArr;
        });
        expect(result).to.deep.equal([123, 'my-words']);
      });

      it('should make arrays immutable', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', [123, 'my-words']);
        });
        const immutable = await callWithBindings((root: any) => {
          try {
            root.example.push(456);
            return false;
          } catch {
            return true;
          }
        });
        expect(immutable).to.equal(true);
      });

      it('should make nested arrays immutable', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            myArr: [123, 'my-words']
          });
        });
        const immutable = await callWithBindings((root: any) => {
          try {
            root.example.myArr.push(456);
            return false;
          } catch {
            return true;
          }
        });
        expect(immutable).to.equal(true);
      });

      it('should proxy booleans', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', true);
        });
        const result = await callWithBindings((root: any) => {
          return root.example;
        });
        expect(result).to.equal(true);
      });

      it('should proxy nested booleans', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            myBool: true
          });
        });
        const result = await callWithBindings((root: any) => {
          return root.example.myBool;
        });
        expect(result).to.equal(true);
      });

      it('should proxy promises and resolve with the correct value', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example',
            Promise.resolve('i-resolved')
          );
        });
        const result = await callWithBindings((root: any) => {
          return root.example;
        });
        expect(result).to.equal('i-resolved');
      });

      it('should proxy nested promises and resolve with the correct value', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            myPromise: Promise.resolve('i-resolved')
          });
        });
        const result = await callWithBindings((root: any) => {
          return root.example.myPromise;
        });
        expect(result).to.equal('i-resolved');
      });

      it('should proxy promises and reject with the correct value', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', Promise.reject(new Error('i-rejected')));
        });
        const result = await callWithBindings(async (root: any) => {
          try {
            await root.example;
            return null;
          } catch (err) {
            return err;
          }
        });
        expect(result).to.be.an.instanceOf(Error).with.property('message', 'i-rejected');
      });

      it('should proxy nested promises and reject with the correct value', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            myPromise: Promise.reject(new Error('i-rejected'))
          });
        });
        const result = await callWithBindings(async (root: any) => {
          try {
            await root.example.myPromise;
            return null;
          } catch (err) {
            return err;
          }
        });
        expect(result).to.be.an.instanceOf(Error).with.property('message', 'i-rejected');
      });

      it('should proxy promises and resolve with the correct value if it resolves later', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            myPromise: () => new Promise(resolve => setTimeout(() => resolve('delayed'), 20))
          });
        });
        const result = await callWithBindings((root: any) => {
          return root.example.myPromise();
        });
        expect(result).to.equal('delayed');
      });

      it('should proxy nested promises correctly', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            myPromise: () => new Promise(resolve => setTimeout(() => resolve(Promise.resolve(123)), 20))
          });
        });
        const result = await callWithBindings((root: any) => {
          return root.example.myPromise();
        });
        expect(result).to.equal(123);
      });

      it('should proxy methods', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            getNumber: () => 123,
            getString: () => 'help',
            getBoolean: () => false,
            getPromise: async () => 'promise'
          });
        });
        const result = await callWithBindings(async (root: any) => {
          return [root.example.getNumber(), root.example.getString(), root.example.getBoolean(), await root.example.getPromise()];
        });
        expect(result).to.deep.equal([123, 'help', false, 'promise']);
      });

      it('should proxy functions', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', () => 'return-value');
        });
        const result = await callWithBindings(async (root: any) => {
          return root.example();
        });
        expect(result).equal('return-value');
      });

      it('should not double-proxy functions when they are returned to their origin side of the bridge', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', (fn: any) => fn);
        });
        const result = await callWithBindings(async (root: any) => {
          const fn = () => null;
          return root.example(fn) === fn;
        });
        expect(result).equal(true);
      });

      it('should properly handle errors thrown in proxied functions', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', () => { throw new Error('oh no'); });
        });
        const result = await callWithBindings(async (root: any) => {
          try {
            root.example();
          } catch (e) {
            return (e as Error).message;
          }
        });
        expect(result).equal('oh no');
      });

      it('should proxy methods that are callable multiple times', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            doThing: () => 123
          });
        });
        const result = await callWithBindings(async (root: any) => {
          return [root.example.doThing(), root.example.doThing(), root.example.doThing()];
        });
        expect(result).to.deep.equal([123, 123, 123]);
      });

      it('should proxy methods in the reverse direction', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            callWithNumber: (fn: any) => fn(123)
          });
        });
        const result = await callWithBindings(async (root: any) => {
          return root.example.callWithNumber((n: number) => n + 1);
        });
        expect(result).to.equal(124);
      });

      it('should proxy promises in the reverse direction', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            getPromiseValue: (p: Promise<any>) => p
          });
        });
        const result = await callWithBindings((root: any) => {
          return root.example.getPromiseValue(Promise.resolve('my-proxied-value'));
        });
        expect(result).to.equal('my-proxied-value');
      });

      it('should proxy objects with number keys', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            1: 123,
            2: 456,
            3: 789
          });
        });
        const result = await callWithBindings(async (root: any) => {
          return [root.example[1], root.example[2], root.example[3], Array.isArray(root.example)];
        });
        expect(result).to.deep.equal([123, 456, 789, false]);
      });

      it('it should proxy null', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', null);
        });
        const result = await callWithBindings((root: any) => {
          // Convert to strings as although the context bridge keeps the right value
          // IPC does not
          return `${root.example}`;
        });
        expect(result).to.deep.equal('null');
      });

      it('it should proxy undefined', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', undefined);
        });
        const result = await callWithBindings((root: any) => {
          // Convert to strings as although the context bridge keeps the right value
          // IPC does not
          return `${root.example}`;
        });
        expect(result).to.deep.equal('undefined');
      });

      it('it should proxy nested null and undefined correctly', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            values: [null, undefined]
          });
        });
        const result = await callWithBindings((root: any) => {
          // Convert to strings as although the context bridge keeps the right value
          // IPC does not
          return root.example.values.map((val: any) => `${val}`);
        });
        expect(result).to.deep.equal(['null', 'undefined']);
      });

      it('should proxy symbols', async () => {
        await makeBindingWindow(() => {
          const mySymbol = Symbol('unique');
          const isSymbol = (s: Symbol) => s === mySymbol;
          contextBridge.exposeInMainWorld('symbol', mySymbol);
          contextBridge.exposeInMainWorld('isSymbol', isSymbol);
        });
        const result = await callWithBindings((root: any) => {
          return root.isSymbol(root.symbol);
        });
        expect(result).to.equal(true, 'symbols should be equal across contexts');
      });

      it('should proxy symbols such that symbol equality works', async () => {
        await makeBindingWindow(() => {
          const mySymbol = Symbol('unique');
          contextBridge.exposeInMainWorld('example', {
            getSymbol: () => mySymbol,
            isSymbol: (s: Symbol) => s === mySymbol
          });
        });
        const result = await callWithBindings((root: any) => {
          return root.example.isSymbol(root.example.getSymbol());
        });
        expect(result).to.equal(true, 'symbols should be equal across contexts');
      });

      it('should proxy symbols such that symbol key lookup works', async () => {
        await makeBindingWindow(() => {
          const mySymbol = Symbol('unique');
          contextBridge.exposeInMainWorld('example', {
            getSymbol: () => mySymbol,
            getObject: () => ({ [mySymbol]: 123 })
          });
        });
        const result = await callWithBindings((root: any) => {
          return root.example.getObject()[root.example.getSymbol()];
        });
        expect(result).to.equal(123, 'symbols key lookup should work across contexts');
      });

      it('should proxy typed arrays', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', new Uint8Array(100));
        });
        const result = await callWithBindings((root: any) => {
          return Object.getPrototypeOf(root.example) === Uint8Array.prototype;
        });
        expect(result).equal(true);
      });

      it('should proxy regexps', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', /a/g);
        });
        const result = await callWithBindings((root: any) => {
          return Object.getPrototypeOf(root.example) === RegExp.prototype;
        });
        expect(result).equal(true);
      });

      it('should proxy typed arrays and regexps through the serializer', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            arr: new Uint8Array(100),
            regexp: /a/g
          });
        });
        const result = await callWithBindings((root: any) => {
          return [
            Object.getPrototypeOf(root.example.arr) === Uint8Array.prototype,
            Object.getPrototypeOf(root.example.regexp) === RegExp.prototype
          ];
        });
        expect(result).to.deep.equal([true, true]);
      });

      it('should handle recursive objects', async () => {
        await makeBindingWindow(() => {
          const o: any = { value: 135 };
          o.o = o;
          contextBridge.exposeInMainWorld('example', {
            o
          });
        });
        const result = await callWithBindings((root: any) => {
          return [root.example.o.value, root.example.o.o.value, root.example.o.o.o.value];
        });
        expect(result).to.deep.equal([135, 135, 135]);
      });

      it('should handle DOM elements', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            getElem: () => document.body
          });
        });
        const result = await callWithBindings((root: any) => {
          return [root.example.getElem().tagName, root.example.getElem().constructor.name, typeof root.example.getElem().querySelector];
        });
        expect(result).to.deep.equal(['BODY', 'HTMLBodyElement', 'function']);
      });

      it('should handle DOM elements going backwards over the bridge', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            getElemInfo: (fn: Function) => {
              const elem = fn();
              return [elem.tagName, elem.constructor.name, typeof elem.querySelector];
            }
          });
        });
        const result = await callWithBindings((root: any) => {
          return root.example.getElemInfo(() => document.body);
        });
        expect(result).to.deep.equal(['BODY', 'HTMLBodyElement', 'function']);
      });

      it('should handle Blobs', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            getBlob: () => new Blob(['ab', 'cd'])
          });
        });
        const result = await callWithBindings(async (root: any) => {
          return [await root.example.getBlob().text()];
        });
        expect(result).to.deep.equal(['abcd']);
      });

      it('should handle Blobs going backwards over the bridge', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            getBlobText: async (fn: Function) => {
              const blob = fn();
              return [await blob.text()];
            }
          });
        });
        const result = await callWithBindings((root: any) => {
          return root.example.getBlobText(() => new Blob(['12', '45']));
        });
        expect(result).to.deep.equal(['1245']);
      });

      // Can only run tests which use the GCRunner in non-sandboxed environments
      if (!useSandbox) {
        it('should release the global hold on methods sent across contexts', async () => {
          await makeBindingWindow(() => {
            const trackedValues: WeakRef<object>[] = [];
            require('electron').ipcRenderer.on('get-gc-info', e => e.sender.send('gc-info', { trackedValues: trackedValues.filter(value => value.deref()).length }));
            contextBridge.exposeInMainWorld('example', {
              getFunction: () => () => 123,
              track: (value: object) => { trackedValues.push(new WeakRef(value)); }
            });
          });
          await callWithBindings(async (root: any) => {
            root.GCRunner.run();
          });
          expect((await getGCInfo()).trackedValues).to.equal(0);
          await callWithBindings(async (root: any) => {
            const fn = root.example.getFunction();
            root.example.track(fn);
            root.x = [fn];
          });
          expect((await getGCInfo()).trackedValues).to.equal(1);
          await callWithBindings(async (root: any) => {
            root.x = [];
            root.GCRunner.run();
          });
          expect((await getGCInfo()).trackedValues).to.equal(0);
        });
      }

      if (useSandbox) {
        it('should not leak the global hold on methods sent across contexts when reloading a sandboxed renderer', async () => {
          await makeBindingWindow(() => {
            const trackedValues: WeakRef<object>[] = [];
            require('electron').ipcRenderer.on('get-gc-info', e => e.sender.send('gc-info', { trackedValues: trackedValues.filter(value => value.deref()).length }));
            contextBridge.exposeInMainWorld('example', {
              getFunction: () => () => 123,
              track: (value: object) => { trackedValues.push(new WeakRef(value)); }
            });
            require('electron').ipcRenderer.send('window-ready-for-tasking');
          });
          const loadPromise = emittedOnce(ipcMain, 'window-ready-for-tasking');
          expect((await getGCInfo()).trackedValues).to.equal(0);
          await callWithBindings((root: any) => {
            root.example.track(root.example.getFunction());
          });
          expect((await getGCInfo()).trackedValues).to.equal(1);
          await callWithBindings((root: any) => {
            root.location.reload();
          });
          await loadPromise;
          await forceGCOnWindow();
          // If this is ever "2" it means we leaked the exposed function and
          // therefore the entire context after a reload
          expect((await getGCInfo()).trackedValues).to.equal(0);
        });
      }

      it('it should not let you overwrite existing exposed things', async () => {
        await makeBindingWindow(() => {
          let threw = false;
          contextBridge.exposeInMainWorld('example', {
            attempt: 1,
            getThrew: () => threw
          });
          try {
            contextBridge.exposeInMainWorld('example', {
              attempt: 2,
              getThrew: () => threw
            });
          } catch {
            threw = true;
          }
        });
        const result = await callWithBindings((root: any) => {
          return [root.example.attempt, root.example.getThrew()];
        });
        expect(result).to.deep.equal([1, true]);
      });

      it('should work with complex nested methods and promises', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            first: (second: Function) => second((fourth: Function) => {
              return fourth();
            })
          });
        });
        const result = await callWithBindings((root: any) => {
          return root.example.first((third: Function) => {
            return third(() => Promise.resolve('final value'));
          });
        });
        expect(result).to.equal('final value');
      });

      it('should work with complex nested methods and promises attached directly to the global', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example',
            (second: Function) => second((fourth: Function) => {
              return fourth();
            })
          );
        });
        const result = await callWithBindings((root: any) => {
          return root.example((third: Function) => {
            return third(() => Promise.resolve('final value'));
          });
        });
        expect(result).to.equal('final value');
      });

      it('should throw an error when recursion depth is exceeded', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            doThing: (a: any) => console.log(a)
          });
        });
        let threw = await callWithBindings((root: any) => {
          try {
            let a: any = [];
            for (let i = 0; i < 999; i++) {
              a = [a];
            }
            root.example.doThing(a);
            return false;
          } catch {
            return true;
          }
        });
        expect(threw).to.equal(false);
        threw = await callWithBindings((root: any) => {
          try {
            let a: any = [];
            for (let i = 0; i < 1000; i++) {
              a = [a];
            }
            root.example.doThing(a);
            return false;
          } catch {
            return true;
          }
        });
        expect(threw).to.equal(true);
      });

      it('should copy thrown errors into the other context', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            throwNormal: () => {
              throw new Error('whoops');
            },
            throwWeird: () => {
              throw 'this is no error...'; // eslint-disable-line no-throw-literal
            },
            throwNotClonable: () => {
              return Object(Symbol('foo'));
            },
            argumentConvert: () => {}
          });
        });
        const result = await callWithBindings((root: any) => {
          const getError = (fn: Function) => {
            try {
              fn();
            } catch (e) {
              return e;
            }
            return null;
          };
          const normalIsError = Object.getPrototypeOf(getError(root.example.throwNormal)) === Error.prototype;
          const weirdIsError = Object.getPrototypeOf(getError(root.example.throwWeird)) === Error.prototype;
          const notClonableIsError = Object.getPrototypeOf(getError(root.example.throwNotClonable)) === Error.prototype;
          const argumentConvertIsError = Object.getPrototypeOf(getError(() => root.example.argumentConvert(Object(Symbol('test'))))) === Error.prototype;
          return [normalIsError, weirdIsError, notClonableIsError, argumentConvertIsError];
        });
        expect(result).to.deep.equal([true, true, true, true], 'should all be errors in the current context');
      });

      it('should not leak prototypes', async () => {
        await makeBindingWindow(() => {
          contextBridge.exposeInMainWorld('example', {
            number: 123,
            string: 'string',
            boolean: true,
            arr: [123, 'string', true, ['foo']],
            symbol: Symbol('foo'),
            bigInt: 10n,
            getObject: () => ({ thing: 123 }),
            getNumber: () => 123,
            getString: () => 'string',
            getBoolean: () => true,
            getArr: () => [123, 'string', true, ['foo']],
            getPromise: async () => ({ number: 123, string: 'string', boolean: true, fn: () => 'string', arr: [123, 'string', true, ['foo']] }),
            getFunctionFromFunction: async () => () => null,
            object: {
              number: 123,
              string: 'string',
              boolean: true,
              arr: [123, 'string', true, ['foo']],
              getPromise: async () => ({ number: 123, string: 'string', boolean: true, fn: () => 'string', arr: [123, 'string', true, ['foo']] })
            },
            receiveArguments: (fn: any) => fn({ key: 'value' }),
            symbolKeyed: {
              [Symbol('foo')]: 123
            },
            getBody: () => document.body,
            getBlob: () => new Blob(['ab', 'cd'])
          });
        });
        const result = await callWithBindings(async (root: any) => {
          const { example } = root;
          let arg: any;
          example.receiveArguments((o: any) => { arg = o; });
          const protoChecks = [
            ...Object.keys(example).map(key => [key, String]),
            ...Object.getOwnPropertySymbols(example.symbolKeyed).map(key => [key, Symbol]),
            [example, Object],
            [example.number, Number],
            [example.string, String],
            [example.boolean, Boolean],
            [example.arr, Array],
            [example.arr[0], Number],
            [example.arr[1], String],
            [example.arr[2], Boolean],
            [example.arr[3], Array],
            [example.arr[3][0], String],
            [example.symbol, Symbol],
            [example.bigInt, BigInt],
            [example.getNumber, Function],
            [example.getNumber(), Number],
            [example.getObject(), Object],
            [example.getString(), String],
            [example.getBoolean(), Boolean],
            [example.getArr(), Array],
            [example.getArr()[0], Number],
            [example.getArr()[1], String],
            [example.getArr()[2], Boolean],
            [example.getArr()[3], Array],
            [example.getArr()[3][0], String],
            [example.getFunctionFromFunction, Function],
            [example.getFunctionFromFunction(), Promise],
            [await example.getFunctionFromFunction(), Function],
            [example.getPromise(), Promise],
            [await example.getPromise(), Object],
            [(await example.getPromise()).number, Number],
            [(await example.getPromise()).string, String],
            [(await example.getPromise()).boolean, Boolean],
            [(await example.getPromise()).fn, Function],
            [(await example.getPromise()).fn(), String],
            [(await example.getPromise()).arr, Array],
            [(await example.getPromise()).arr[0], Number],
            [(await example.getPromise()).arr[1], String],
            [(await example.getPromise()).arr[2], Boolean],
            [(await example.getPromise()).arr[3], Array],
            [(await example.getPromise()).arr[3][0], String],
            [example.object, Object],
            [example.object.number, Number],
            [example.object.string, String],
            [example.object.boolean, Boolean],
            [example.object.arr, Array],
            [example.object.arr[0], Number],
            [example.object.arr[1], String],
            [example.object.arr[2], Boolean],
            [example.object.arr[3], Array],
            [example.object.arr[3][0], String],
            [await example.object.getPromise(), Object],
            [(await example.object.getPromise()).number, Number],
            [(await example.object.getPromise()).string, String],
            [(await example.object.getPromise()).boolean, Boolean],
            [(await example.object.getPromise()).fn, Function],
            [(await example.object.getPromise()).fn(), String],
            [(await example.object.getPromise()).arr, Array],
            [(await example.object.getPromise()).arr[0], Number],
            [(await example.object.getPromise()).arr[1], String],
            [(await example.object.getPromise()).arr[2], Boolean],
            [(await example.object.getPromise()).arr[3], Array],
            [(await example.object.getPromise()).arr[3][0], String],
            [arg, Object],
            [arg.key, String],
            [example.getBody(), HTMLBodyElement],
            [example.getBlob(), Blob]
          ];
          return {
            protoMatches: protoChecks.map(([a, Constructor]) => Object.getPrototypeOf(a) === Constructor.prototype)
          };
        });
        // Every protomatch should be true
        expect(result.protoMatches).to.deep.equal(result.protoMatches.map(() => true));
      });

      it('should not leak prototypes when attaching directly to the global', async () => {
        await makeBindingWindow(() => {
          const toExpose = {
            number: 123,
            string: 'string',
            boolean: true,
            arr: [123, 'string', true, ['foo']],
            symbol: Symbol('foo'),
            bigInt: 10n,
            getObject: () => ({ thing: 123 }),
            getNumber: () => 123,
            getString: () => 'string',
            getBoolean: () => true,
            getArr: () => [123, 'string', true, ['foo']],
            getPromise: async () => ({ number: 123, string: 'string', boolean: true, fn: () => 'string', arr: [123, 'string', true, ['foo']] }),
            getFunctionFromFunction: async () => () => null,
            getError: () => new Error('foo'),
            getWeirdError: () => {
              const e = new Error('foo');
              e.message = { garbage: true } as any;
              return e;
            },
            object: {
              number: 123,
              string: 'string',
              boolean: true,
              arr: [123, 'string', true, ['foo']],
              getPromise: async () => ({ number: 123, string: 'string', boolean: true, fn: () => 'string', arr: [123, 'string', true, ['foo']] })
            },
            receiveArguments: (fn: any) => fn({ key: 'value' }),
            symbolKeyed: {
              [Symbol('foo')]: 123
            }
          };
          const keys: string[] = [];
          Object.entries(toExpose).forEach(([key, value]) => {
            keys.push(key);
            contextBridge.exposeInMainWorld(key, value);
          });
          contextBridge.exposeInMainWorld('keys', keys);
        });
        const result = await callWithBindings(async (root: any) => {
          const { keys } = root;
          const cleanedRoot: any = {};
          for (const [key, value] of Object.entries(root)) {
            if (keys.includes(key)) {
              cleanedRoot[key] = value;
            }
          }

          let arg: any;
          cleanedRoot.receiveArguments((o: any) => { arg = o; });
          const protoChecks = [
            ...Object.keys(cleanedRoot).map(key => [key, String]),
            ...Object.getOwnPropertySymbols(cleanedRoot.symbolKeyed).map(key => [key, Symbol]),
            [cleanedRoot, Object],
            [cleanedRoot.number, Number],
            [cleanedRoot.string, String],
            [cleanedRoot.boolean, Boolean],
            [cleanedRoot.arr, Array],
            [cleanedRoot.arr[0], Number],
            [cleanedRoot.arr[1], String],
            [cleanedRoot.arr[2], Boolean],
            [cleanedRoot.arr[3], Array],
            [cleanedRoot.arr[3][0], String],
            [cleanedRoot.symbol, Symbol],
            [cleanedRoot.bigInt, BigInt],
            [cleanedRoot.getNumber, Function],
            [cleanedRoot.getNumber(), Number],
            [cleanedRoot.getObject(), Object],
            [cleanedRoot.getString(), String],
            [cleanedRoot.getBoolean(), Boolean],
            [cleanedRoot.getArr(), Array],
            [cleanedRoot.getArr()[0], Number],
            [cleanedRoot.getArr()[1], String],
            [cleanedRoot.getArr()[2], Boolean],
            [cleanedRoot.getArr()[3], Array],
            [cleanedRoot.getArr()[3][0], String],
            [cleanedRoot.getFunctionFromFunction, Function],
            [cleanedRoot.getFunctionFromFunction(), Promise],
            [await cleanedRoot.getFunctionFromFunction(), Function],
            [cleanedRoot.getError(), Error],
            [cleanedRoot.getError().message, String],
            [cleanedRoot.getWeirdError(), Error],
            [cleanedRoot.getWeirdError().message, String],
            [cleanedRoot.getPromise(), Promise],
            [await cleanedRoot.getPromise(), Object],
            [(await cleanedRoot.getPromise()).number, Number],
            [(await cleanedRoot.getPromise()).string, String],
            [(await cleanedRoot.getPromise()).boolean, Boolean],
            [(await cleanedRoot.getPromise()).fn, Function],
            [(await cleanedRoot.getPromise()).fn(), String],
            [(await cleanedRoot.getPromise()).arr, Array],
            [(await cleanedRoot.getPromise()).arr[0], Number],
            [(await cleanedRoot.getPromise()).arr[1], String],
            [(await cleanedRoot.getPromise()).arr[2], Boolean],
            [(await cleanedRoot.getPromise()).arr[3], Array],
            [(await cleanedRoot.getPromise()).arr[3][0], String],
            [cleanedRoot.object, Object],
            [cleanedRoot.object.number, Number],
            [cleanedRoot.object.string, String],
            [cleanedRoot.object.boolean, Boolean],
            [cleanedRoot.object.arr, Array],
            [cleanedRoot.object.arr[0], Number],
            [cleanedRoot.object.arr[1], String],
            [cleanedRoot.object.arr[2], Boolean],
            [cleanedRoot.object.arr[3], Array],
            [cleanedRoot.object.arr[3][0], String],
            [await cleanedRoot.object.getPromise(), Object],
            [(await cleanedRoot.object.getPromise()).number, Number],
            [(await cleanedRoot.object.getPromise()).string, String],
            [(await cleanedRoot.object.getPromise()).boolean, Boolean],
            [(await cleanedRoot.object.getPromise()).fn, Function],
            [(await cleanedRoot.object.getPromise()).fn(), String],
            [(await cleanedRoot.object.getPromise()).arr, Array],
            [(await cleanedRoot.object.getPromise()).arr[0], Number],
            [(await cleanedRoot.object.getPromise()).arr[1], String],
            [(await cleanedRoot.object.getPromise()).arr[2], Boolean],
            [(await cleanedRoot.object.getPromise()).arr[3], Array],
            [(await cleanedRoot.object.getPromise()).arr[3][0], String],
            [arg, Object],
            [arg.key, String]
          ];
          return {
            protoMatches: protoChecks.map(([a, Constructor]) => Object.getPrototypeOf(a) === Constructor.prototype)
          };
        });
        // Every protomatch should be true
        expect(result.protoMatches).to.deep.equal(result.protoMatches.map(() => true));
      });

      describe('internalContextBridge', () => {
        describe('overrideGlobalValueFromIsolatedWorld', () => {
          it('should override top level properties', async () => {
            await makeBindingWindow(() => {
              contextBridge.internalContextBridge!.overrideGlobalValueFromIsolatedWorld(['open'], () => ({ you: 'are a wizard' }));
            });
            const result = await callWithBindings(async (root: any) => {
              return root.open();
            });
            expect(result).to.deep.equal({ you: 'are a wizard' });
          });

          it('should override deep properties', async () => {
            await makeBindingWindow(() => {
              contextBridge.internalContextBridge!.overrideGlobalValueFromIsolatedWorld(['document', 'foo'], () => 'I am foo');
            });
            const result = await callWithBindings(async (root: any) => {
              return root.document.foo();
            });
            expect(result).to.equal('I am foo');
          });
        });

        describe('overrideGlobalPropertyFromIsolatedWorld', () => {
          it('should call the getter correctly', async () => {
            await makeBindingWindow(() => {
              let callCount = 0;
              const getter = () => {
                callCount++;
                return true;
              };
              contextBridge.internalContextBridge!.overrideGlobalPropertyFromIsolatedWorld(['isFun'], getter);
              contextBridge.exposeInMainWorld('foo', {
                callCount: () => callCount
              });
            });
            const result = await callWithBindings(async (root: any) => {
              return [root.isFun, root.foo.callCount()];
            });
            expect(result[0]).to.equal(true);
            expect(result[1]).to.equal(1);
          });

          it('should not make a setter if none is provided', async () => {
            await makeBindingWindow(() => {
              contextBridge.internalContextBridge!.overrideGlobalPropertyFromIsolatedWorld(['isFun'], () => true);
            });
            const result = await callWithBindings(async (root: any) => {
              root.isFun = 123;
              return root.isFun;
            });
            expect(result).to.equal(true);
          });

          it('should call the setter correctly', async () => {
            await makeBindingWindow(() => {
              const callArgs: any[] = [];
              const setter = (...args: any[]) => {
                callArgs.push(args);
                return true;
              };
              contextBridge.internalContextBridge!.overrideGlobalPropertyFromIsolatedWorld(['isFun'], () => true, setter);
              contextBridge.exposeInMainWorld('foo', {
                callArgs: () => callArgs
              });
            });
            const result = await callWithBindings(async (root: any) => {
              root.isFun = 123;
              return root.foo.callArgs();
            });
            expect(result).to.have.lengthOf(1);
            expect(result[0]).to.have.lengthOf(1);
            expect(result[0][0]).to.equal(123);
          });
        });

        describe('overrideGlobalValueWithDynamicPropsFromIsolatedWorld', () => {
          it('should not affect normal values', async () => {
            await makeBindingWindow(() => {
              contextBridge.internalContextBridge!.overrideGlobalValueWithDynamicPropsFromIsolatedWorld(['thing'], {
                a: 123,
                b: () => 2,
                c: () => ({ d: 3 })
              });
            });
            const result = await callWithBindings(async (root: any) => {
              return [root.thing.a, root.thing.b(), root.thing.c()];
            });
            expect(result).to.deep.equal([123, 2, { d: 3 }]);
          });

          it('should work with getters', async () => {
            await makeBindingWindow(() => {
              contextBridge.internalContextBridge!.overrideGlobalValueWithDynamicPropsFromIsolatedWorld(['thing'], {
                get foo () {
                  return 'hi there';
                }
              });
            });
            const result = await callWithBindings(async (root: any) => {
              return root.thing.foo;
            });
            expect(result).to.equal('hi there');
          });

          it('should work with nested getters', async () => {
            await makeBindingWindow(() => {
              contextBridge.internalContextBridge!.overrideGlobalValueWithDynamicPropsFromIsolatedWorld(['thing'], {
                get foo () {
                  return {
                    get bar () {
                      return 'hi there';
                    }
                  };
                }
              });
            });
            const result = await callWithBindings(async (root: any) => {
              return root.thing.foo.bar;
            });
            expect(result).to.equal('hi there');
          });

          it('should work with setters', async () => {
            await makeBindingWindow(() => {
              let a: any = null;
              contextBridge.internalContextBridge!.overrideGlobalValueWithDynamicPropsFromIsolatedWorld(['thing'], {
                get foo () {
                  return a;
                },
                set foo (arg: any) {
                  a = arg + 1;
                }
              });
            });
            const result = await callWithBindings(async (root: any) => {
              root.thing.foo = 123;
              return root.thing.foo;
            });
            expect(result).to.equal(124);
          });

          it('should work with nested getter / setter combos', async () => {
            await makeBindingWindow(() => {
              let a: any = null;
              contextBridge.internalContextBridge!.overrideGlobalValueWithDynamicPropsFromIsolatedWorld(['thing'], {
                get thingy () {
                  return {
                    get foo () {
                      return a;
                    },
                    set foo (arg: any) {
                      a = arg + 1;
                    }
                  };
                }
              });
            });
            const result = await callWithBindings(async (root: any) => {
              root.thing.thingy.foo = 123;
              return root.thing.thingy.foo;
            });
            expect(result).to.equal(124);
          });

          it('should work with deep properties', async () => {
            await makeBindingWindow(() => {
              contextBridge.internalContextBridge!.overrideGlobalValueWithDynamicPropsFromIsolatedWorld(['thing'], {
                a: () => ({
                  get foo () {
                    return 'still here';
                  }
                })
              });
            });
            const result = await callWithBindings(async (root: any) => {
              return root.thing.a().foo;
            });
            expect(result).to.equal('still here');
          });
        });
      });
    });
  };

  generateTests(true);
  generateTests(false);
});

describe('ContextBridgeMutability', () => {
  it('should not make properties unwriteable and read-only if ContextBridgeMutability is on', async () => {
    const appPath = path.join(fixturesPath, 'context-bridge-mutability');
    const appProcess = cp.spawn(process.execPath, ['--enable-logging', '--enable-features=ContextBridgeMutability', appPath]);

    let output = '';
    appProcess.stdout.on('data', data => { output += data; });
    await emittedOnce(appProcess, 'exit');

    expect(output).to.include('some-modified-text');
    expect(output).to.include('obj-modified-prop');
    expect(output).to.include('1,2,5,3,4');
  });

  it('should make properties unwriteable and read-only if ContextBridgeMutability is off', async () => {
    const appPath = path.join(fixturesPath, 'context-bridge-mutability');
    const appProcess = cp.spawn(process.execPath, ['--enable-logging', appPath]);

    let output = '';
    appProcess.stdout.on('data', data => { output += data; });
    await emittedOnce(appProcess, 'exit');

    expect(output).to.include('some-text');
    expect(output).to.include('obj-prop');
    expect(output).to.include('1,2,3,4');
  });
});
