hendrik/lens
1
0
Fork 0
mirror of https://github.com/lensapp/lens.git synced 2025-05-20 05:10:56 +00:00
Code Issues Projects Releases Wiki Activity

Restore reliancy on existing windows for resolving proxy for fears of Electron events misbehaving because of a temp-window used in case no windows are open

Browse Source 
Co-authored-by: Janne Savolainen <janne.savolainen@live.fi>

Signed-off-by: Iku-turso <mikko.aspiala@gmail.com>
This commit is contained in:
Iku-turso 2022-06-21 13:11:03 +03:00
parent 07eaf835de
commit 01c9c740bf
3 changed files with 3 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/behaviours/proxy/resolve-proxy/main/create-temporary-browser-window.injectable.ts
View File

@ -1,14 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { BrowserWindow } from "electron";
const createTemporaryBrowserWindowInjectable = getInjectable({
id: "create-temporary-browser-window",
instantiate: () => () => new BrowserWindow({ show: false }),
causesSideEffects: true,
});
export default createTemporaryBrowserWindowInjectable;

14
src/behaviours/proxy/resolve-proxy/main/resolve-proxy-from-electron.injectable.ts
View File

@ -3,31 +3,23 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import electronInjectable from "./electron.injectable";
import createTemporaryBrowserWindowInjectable from "./create-temporary-browser-window.injectable";
const resolveProxyFromElectronInjectable = getInjectable({
id: "resolve-proxy-from-electron",
instantiate: (di) => {
const electron = di.inject(electronInjectable);
const createTemporaryBrowserWindow = di.inject(createTemporaryBrowserWindowInjectable);
return async (url: string) => {
const webContent = electron.webContents
.getAllWebContents()
.find((x) => !x.isDestroyed());
if(!webContent) {
const tempWindow = createTemporaryBrowserWindow();
const proxy = await tempWindow.webContents.session.resolveProxy(url);
assert(webContent);
tempWindow.destroy();
return proxy;
}
return webContent?.session.resolveProxy(url);
return await webContent.session.resolveProxy(url);
};
},
});

89
src/behaviours/proxy/resolve-proxy/main/resolve-proxy-from-electron.test.ts
View File

@ -10,7 +10,6 @@ import type { AsyncFnMock } from "@async-fn/jest";
import asyncFn from "@async-fn/jest";
import type electron from "electron";
import { getPromiseStatus } from "../../../../common/test-utils/get-promise-status";
import createTemporaryBrowserWindowInjectable from "./create-temporary-browser-window.injectable";
describe("technical: resolve-proxy-from-electron", () => {
let resolveProxyMock: AsyncFnMock<(url: string) => Promise<string>>;
@ -59,10 +58,6 @@ describe("technical: resolve-proxy-from-electron", () => {
} as unknown as typeof electron),
);
di.override(createTemporaryBrowserWindowInjectable, () => () => {
throw new Error("should never come here");
});
const resolveProxyFromElectron = di.inject(
resolveProxyFromElectronInjectable,
);
@ -86,88 +81,4 @@ describe("technical: resolve-proxy-from-electron", () => {
expect(await actualPromise).toBe("some-proxy");
});
});
describe("given there are only destroyed Lens windows, when called with URL", () => {
let actualPromise: Promise<string>;
let createTemporaryBrowserWindowMock: jest.Mock;
let destroyTempWindowMock: jest.Mock;
beforeEach(() => {
const di = getDiForUnitTesting();
di.override(
electronInjectable,
() =>
({
webContents: {
getAllWebContents: () => [
{
isDestroyed: () => true,
session: {
resolveProxy: () => {
throw new Error("should never come here");
},
},
},
],
},
} as unknown as typeof electron),
);
resolveProxyMock = asyncFn();
destroyTempWindowMock = jest.fn();
createTemporaryBrowserWindowMock = jest.fn(() => ({
webContents: {
session: {
resolveProxy: resolveProxyMock,
},
},
destroy: destroyTempWindowMock,
}));
di.override(createTemporaryBrowserWindowInjectable, () => createTemporaryBrowserWindowMock);
const resolveProxyFromElectron = di.inject(
resolveProxyFromElectronInjectable,
);
actualPromise = resolveProxyFromElectron("some-url");
});
it("creates a new temporary window for resolving proxy", () => {
expect(createTemporaryBrowserWindowMock).toHaveBeenCalledWith();
});
it("calls for proxy from the temporary window", () => {
expect(resolveProxyMock).toHaveBeenCalledWith("some-url");
});
it("does not resolve yet", async () => {
const promiseStatus = await getPromiseStatus(actualPromise);
expect(promiseStatus.fulfilled).toBe(false);
});
it("does not destroy the temp window yet", () => {
expect(destroyTempWindowMock).not.toHaveBeenCalled();
});
describe("when the call resolves", () => {
beforeEach(async () => {
await resolveProxyMock.resolve("some-proxy-from-temp-window");
});
it("destroys the temp window", () => {
expect(destroyTempWindowMock).toHaveBeenCalled();
});
it("resolves with the proxy", async () => {
expect(await actualPromise).toBe("some-proxy-from-temp-window");
});
});
});
});