Enforce semicolons in eslint

Signed-off-by: Panu Horsmalahti <phorsmalahti@mirantis.com>

src/main/__test__/cluster.test.ts

@@ -21,35 +21,35 @@ jest.mock("winston", () => ({
     Console: jest.fn(),
     File: jest.fn(),
   }
-}))
+}));
 
 
-jest.mock("../../common/ipc")
-jest.mock("../context-handler")
-jest.mock("request")
-jest.mock("request-promise-native")
+jest.mock("../../common/ipc");
+jest.mock("../context-handler");
+jest.mock("request");
+jest.mock("request-promise-native");
 
 import { Console } from "console";
 import mockFs from "mock-fs";
 import { workspaceStore } from "../../common/workspace-store";
-import { Cluster } from "../cluster"
+import { Cluster } from "../cluster";
 import { ContextHandler } from "../context-handler";
 import { getFreePort } from "../port";
 import { V1ResourceAttributes } from "@kubernetes/client-node";
 import { apiResources } from "../../common/rbac";
-import request from "request-promise-native"
+import request from "request-promise-native";
 import { Kubectl } from "../kubectl";
 
-const mockedRequest = request as jest.MockedFunction<typeof request>
+const mockedRequest = request as jest.MockedFunction<typeof request>;
 
-console = new Console(process.stdout, process.stderr) // fix mockFS
+console = new Console(process.stdout, process.stderr); // fix mockFS
 
 describe("create clusters", () => {
   beforeEach(() => {
-    jest.clearAllMocks()
-  })
+    jest.clearAllMocks();
+  });
 
-  let c: Cluster
+  let c: Cluster;
 
   beforeEach(() => {
     const mockOpts = {
@@ -74,68 +74,68 @@ describe("create clusters", () => {
         kind: "Config",
         preferences: {},
       })
-    }
-    mockFs(mockOpts)
-    jest.spyOn(Kubectl.prototype, "ensureKubectl").mockReturnValue(Promise.resolve(true))
+    };
+    mockFs(mockOpts);
+    jest.spyOn(Kubectl.prototype, "ensureKubectl").mockReturnValue(Promise.resolve(true));
     c = new Cluster({
       id: "foo",
       contextName: "minikube",
       kubeConfigPath: "minikube-config.yml",
       workspace: workspaceStore.currentWorkspaceId
-    })
-  })
+    });
+  });
 
   afterEach(() => {
-    mockFs.restore()
-  })
+    mockFs.restore();
+  });
 
   it("should be able to create a cluster from a cluster model and apiURL should be decoded", () => {
-    expect(c.apiUrl).toBe("https://192.168.64.3:8443")
-  })
+    expect(c.apiUrl).toBe("https://192.168.64.3:8443");
+  });
 
   it("reconnect should not throw if contextHandler is missing", () => {
-    expect(() => c.reconnect()).not.toThrowError()
-  })
+    expect(() => c.reconnect()).not.toThrowError();
+  });
 
   it("disconnect should not throw if contextHandler is missing", () => {
-    expect(() => c.disconnect()).not.toThrowError()
-  })
+    expect(() => c.disconnect()).not.toThrowError();
+  });
 
   it("init should not throw if everything is in order", async () => {
-    await c.init(await getFreePort())
+    await c.init(await getFreePort());
     expect(logger.info).toBeCalledWith(expect.stringContaining("init success"), {
       id: "foo",
       apiUrl: "https://192.168.64.3:8443",
       context: "minikube",
-    })
-  })
+    });
+  });
 
   it("activating cluster should try to connect to cluster and do a refresh", async () => {
-    const port = await getFreePort()
+    const port = await getFreePort();
     jest.spyOn(ContextHandler.prototype, "ensureServer");
 
-    const mockListNSs = jest.fn()
+    const mockListNSs = jest.fn();
     const mockKC = {
       makeApiClient() {
         return {
           listNamespace: mockListNSs,
-        }
+        };
       }
-    }
-    jest.spyOn(Cluster.prototype, "isClusterAdmin").mockReturnValue(Promise.resolve(true))
+    };
+    jest.spyOn(Cluster.prototype, "isClusterAdmin").mockReturnValue(Promise.resolve(true));
     jest.spyOn(Cluster.prototype, "canI")
       .mockImplementationOnce((attr: V1ResourceAttributes): Promise<boolean> => {
-        expect(attr.namespace).toBe("default")
-        expect(attr.resource).toBe("pods")
-        expect(attr.verb).toBe("list")
-        return Promise.resolve(true)
+        expect(attr.namespace).toBe("default");
+        expect(attr.resource).toBe("pods");
+        expect(attr.verb).toBe("list");
+        return Promise.resolve(true);
       })
       .mockImplementation((attr: V1ResourceAttributes): Promise<boolean> => {
-        expect(attr.namespace).toBe("default")
-        expect(attr.verb).toBe("list")
-        return Promise.resolve(true)
-      })
-    jest.spyOn(Cluster.prototype, "getProxyKubeconfig").mockReturnValue(mockKC as any)
+        expect(attr.namespace).toBe("default");
+        expect(attr.verb).toBe("list");
+        return Promise.resolve(true);
+      });
+    jest.spyOn(Cluster.prototype, "getProxyKubeconfig").mockReturnValue(mockKC as any);
     mockListNSs.mockImplementationOnce(() => ({
       body: {
         items: [{
@@ -144,36 +144,36 @@ describe("create clusters", () => {
           }
         }]
       }
-    }))
+    }));
 
     mockedRequest.mockImplementationOnce(((uri: any, _options: any) => {
-      expect(uri).toBe(`http://localhost:${port}/api-kube/version`)
-      return Promise.resolve({ gitVersion: "1.2.3" })
-    }) as any)
+      expect(uri).toBe(`http://localhost:${port}/api-kube/version`);
+      return Promise.resolve({ gitVersion: "1.2.3" });
+    }) as any);
 
     const c = new class extends Cluster {
       // only way to mock protected methods, without these we leak promises
       protected bindEvents() {
-        return
+        return;
       }
       protected async ensureKubectl() {
-        return Promise.resolve(true)
+        return Promise.resolve(true);
       }
     }({
       id: "foo",
       contextName: "minikube",
       kubeConfigPath: "minikube-config.yml",
       workspace: workspaceStore.currentWorkspaceId
-    })
-    await c.init(port)
-    await c.activate()
+    });
+    await c.init(port);
+    await c.activate();
 
-    expect(ContextHandler.prototype.ensureServer).toBeCalled()
-    expect(mockedRequest).toBeCalled()
-    expect(c.accessible).toBe(true)
-    expect(c.allowedNamespaces.length).toBe(1)
-    expect(c.allowedResources.length).toBe(apiResources.length)
-    c.disconnect()
-    jest.resetAllMocks()
-  })
-})
+    expect(ContextHandler.prototype.ensureServer).toBeCalled();
+    expect(mockedRequest).toBeCalled();
+    expect(c.accessible).toBe(true);
+    expect(c.allowedNamespaces.length).toBe(1);
+    expect(c.allowedResources.length).toBe(apiResources.length);
+    c.disconnect();
+    jest.resetAllMocks();
+  });
+});

src/main/__test__/kube-auth-proxy.test.ts

@@ -21,109 +21,109 @@ jest.mock("winston", () => ({
     Console: jest.fn(),
     File: jest.fn(),
   }
-}))
+}));
 
-jest.mock("../../common/ipc")
-jest.mock("child_process")
-jest.mock("tcp-port-used")
+jest.mock("../../common/ipc");
+jest.mock("child_process");
+jest.mock("tcp-port-used");
 
-import { Cluster } from "../cluster"
-import { KubeAuthProxy } from "../kube-auth-proxy"
-import { getFreePort } from "../port"
-import { broadcastMessage } from "../../common/ipc"
-import { ChildProcess, spawn, SpawnOptions } from "child_process"
-import { bundledKubectlPath, Kubectl } from "../kubectl"
+import { Cluster } from "../cluster";
+import { KubeAuthProxy } from "../kube-auth-proxy";
+import { getFreePort } from "../port";
+import { broadcastMessage } from "../../common/ipc";
+import { ChildProcess, spawn, SpawnOptions } from "child_process";
+import { bundledKubectlPath, Kubectl } from "../kubectl";
 import { mock, MockProxy } from 'jest-mock-extended';
 import { waitUntilUsed } from 'tcp-port-used';
-import { Readable } from "stream"
+import { Readable } from "stream";
 
-const mockBroadcastIpc = broadcastMessage as jest.MockedFunction<typeof broadcastMessage>
-const mockSpawn = spawn as jest.MockedFunction<typeof spawn>
-const mockWaitUntilUsed = waitUntilUsed as jest.MockedFunction<typeof waitUntilUsed>
+const mockBroadcastIpc = broadcastMessage as jest.MockedFunction<typeof broadcastMessage>;
+const mockSpawn = spawn as jest.MockedFunction<typeof spawn>;
+const mockWaitUntilUsed = waitUntilUsed as jest.MockedFunction<typeof waitUntilUsed>;
 
 describe("kube auth proxy tests", () => {
   beforeEach(() => {
-    jest.clearAllMocks()
-  })
+    jest.clearAllMocks();
+  });
 
   it("calling exit multiple times shouldn't throw", async () => {
-    const port = await getFreePort()
-    const kap = new KubeAuthProxy(new Cluster({ id: "foobar", kubeConfigPath: "fake-path.yml" }), port, {})
-    kap.exit()
-    kap.exit()
-    kap.exit()
-  })
+    const port = await getFreePort();
+    const kap = new KubeAuthProxy(new Cluster({ id: "foobar", kubeConfigPath: "fake-path.yml" }), port, {});
+    kap.exit();
+    kap.exit();
+    kap.exit();
+  });
 
   describe("spawn tests", () => {
-    let port: number
-    let mockedCP: MockProxy<ChildProcess>
-    let listeners: Record<string, (...args: any[]) => void>
-    let proxy: KubeAuthProxy
+    let port: number;
+    let mockedCP: MockProxy<ChildProcess>;
+    let listeners: Record<string, (...args: any[]) => void>;
+    let proxy: KubeAuthProxy;
 
     beforeEach(async () => {
-      port = await getFreePort()
-      mockedCP = mock<ChildProcess>()
-      listeners = {}
+      port = await getFreePort();
+      mockedCP = mock<ChildProcess>();
+      listeners = {};
 
-      jest.spyOn(Kubectl.prototype, "checkBinary").mockReturnValueOnce(Promise.resolve(true))
-      jest.spyOn(Kubectl.prototype, "ensureKubectl").mockReturnValueOnce(Promise.resolve(false))
+      jest.spyOn(Kubectl.prototype, "checkBinary").mockReturnValueOnce(Promise.resolve(true));
+      jest.spyOn(Kubectl.prototype, "ensureKubectl").mockReturnValueOnce(Promise.resolve(false));
       mockedCP.on.mockImplementation((event: string, listener: (message: any, sendHandle: any) => void): ChildProcess => {
-        listeners[event] = listener
-        return mockedCP
-      })
-      mockedCP.stderr = mock<Readable>()
+        listeners[event] = listener;
+        return mockedCP;
+      });
+      mockedCP.stderr = mock<Readable>();
       mockedCP.stderr.on.mockImplementation((event: string, listener: (message: any, sendHandle: any) => void): Readable => {
-        listeners[`stderr/${event}`] = listener
-        return mockedCP.stderr
-      })
-      mockedCP.stdout = mock<Readable>()
+        listeners[`stderr/${event}`] = listener;
+        return mockedCP.stderr;
+      });
+      mockedCP.stdout = mock<Readable>();
       mockedCP.stdout.on.mockImplementation((event: string, listener: (message: any, sendHandle: any) => void): Readable => {
-        listeners[`stdout/${event}`] = listener
-        return mockedCP.stdout
-      })
+        listeners[`stdout/${event}`] = listener;
+        return mockedCP.stdout;
+      });
       mockSpawn.mockImplementationOnce((command: string, args: readonly string[], options: SpawnOptions): ChildProcess => {
-        expect(command).toBe(bundledKubectlPath())
-        return mockedCP
-      })
-      mockWaitUntilUsed.mockReturnValueOnce(Promise.resolve())
-      const cluster = new Cluster({ id: "foobar", kubeConfigPath: "fake-path.yml" })
-      jest.spyOn(cluster, "apiUrl", "get").mockReturnValue("https://fake.k8s.internal")
-      proxy = new KubeAuthProxy(cluster, port, {})
-    })
+        expect(command).toBe(bundledKubectlPath());
+        return mockedCP;
+      });
+      mockWaitUntilUsed.mockReturnValueOnce(Promise.resolve());
+      const cluster = new Cluster({ id: "foobar", kubeConfigPath: "fake-path.yml" });
+      jest.spyOn(cluster, "apiUrl", "get").mockReturnValue("https://fake.k8s.internal");
+      proxy = new KubeAuthProxy(cluster, port, {});
+    });
 
     it("should call spawn and broadcast errors", async () => {
-      await proxy.run()
-      listeners["error"]({ message: "foobarbat" })
+      await proxy.run();
+      listeners["error"]({ message: "foobarbat" });
 
-      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "foobarbat", error: true })
-    })
+      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "foobarbat", error: true });
+    });
 
     it("should call spawn and broadcast exit", async () => {
-      await proxy.run()
-      listeners["exit"](0)
+      await proxy.run();
+      listeners["exit"](0);
 
-      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "proxy exited with code: 0", error: false })
-    })
+      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "proxy exited with code: 0", error: false });
+    });
 
     it("should call spawn and broadcast errors from stderr", async () => {
-      await proxy.run()
-      listeners["stderr/data"]("an error")
+      await proxy.run();
+      listeners["stderr/data"]("an error");
 
-      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "an error", error: true })
-    })
+      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "an error", error: true });
+    });
 
     it("should call spawn and broadcast stdout serving info", async () => {
-      await proxy.run()
-      listeners["stdout/data"]("Starting to serve on")
+      await proxy.run();
+      listeners["stdout/data"]("Starting to serve on");
 
-      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "Authentication proxy started\n" })
-    })
+      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "Authentication proxy started\n" });
+    });
 
     it("should call spawn and broadcast stdout other info", async () => {
-      await proxy.run()
-      listeners["stdout/data"]("some info")
+      await proxy.run();
+      listeners["stdout/data"]("some info");
 
-      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "some info" })
-    })
-  })
-})
+      expect(mockBroadcastIpc).toBeCalledWith("kube-auth:foobar", { data: "some info" });
+    });
+  });
+});

src/main/__test__/kubeconfig-manager.test.ts

@@ -21,24 +21,24 @@ jest.mock("winston", () => ({
     Console: jest.fn(),
     File: jest.fn(),
   }
-}))
+}));
 
-import { KubeconfigManager } from "../kubeconfig-manager"
-import mockFs from "mock-fs"
+import { KubeconfigManager } from "../kubeconfig-manager";
+import mockFs from "mock-fs";
 import { Cluster } from "../cluster";
 import { workspaceStore } from "../../common/workspace-store";
 import { ContextHandler } from "../context-handler";
 import { getFreePort } from "../port";
-import fse from "fs-extra"
+import fse from "fs-extra";
 import { loadYaml } from "@kubernetes/client-node";
 import { Console } from "console";
 
-console = new Console(process.stdout, process.stderr) // fix mockFS
+console = new Console(process.stdout, process.stderr); // fix mockFS
 
 describe("kubeconfig manager tests", () => {
   beforeEach(() => {
-    jest.clearAllMocks()
-  })
+    jest.clearAllMocks();
+  });
 
   beforeEach(() => {
     const mockOpts = {
@@ -63,13 +63,13 @@ describe("kubeconfig manager tests", () => {
         kind: "Config",
         preferences: {},
       })
-    }
-    mockFs(mockOpts)
-  })
+    };
+    mockFs(mockOpts);
+  });
 
   afterEach(() => {
-    mockFs.restore()
-  })
+    mockFs.restore();
+  });
 
   it("should create 'temp' kube config with proxy", async () => {
     const cluster = new Cluster({
@@ -77,19 +77,19 @@ describe("kubeconfig manager tests", () => {
       contextName: "minikube",
       kubeConfigPath: "minikube-config.yml",
       workspace: workspaceStore.currentWorkspaceId
-    })
-    const contextHandler = new ContextHandler(cluster)
-    const port = await getFreePort()
-    const kubeConfManager = await KubeconfigManager.create(cluster, contextHandler, port)
+    });
+    const contextHandler = new ContextHandler(cluster);
+    const port = await getFreePort();
+    const kubeConfManager = await KubeconfigManager.create(cluster, contextHandler, port);
 
-    expect(logger.error).not.toBeCalled()
-    expect(kubeConfManager.getPath()).toBe("tmp/kubeconfig-foo")
-    const file = await fse.readFile(kubeConfManager.getPath())
-    const yml = loadYaml<any>(file.toString())
-    expect(yml["current-context"]).toBe("minikube")
-    expect(yml["clusters"][0]["cluster"]["server"]).toBe(`http://127.0.0.1:${port}/foo`)
-    expect(yml["users"][0]["name"]).toBe("proxy")
-  })
+    expect(logger.error).not.toBeCalled();
+    expect(kubeConfManager.getPath()).toBe("tmp/kubeconfig-foo");
+    const file = await fse.readFile(kubeConfManager.getPath());
+    const yml = loadYaml<any>(file.toString());
+    expect(yml["current-context"]).toBe("minikube");
+    expect(yml["clusters"][0]["cluster"]["server"]).toBe(`http://127.0.0.1:${port}/foo`);
+    expect(yml["users"][0]["name"]).toBe("proxy");
+  });
 
   it("should remove 'temp' kube config on unlink and remove reference from inside class", async () => {
     const cluster = new Cluster({
@@ -97,16 +97,16 @@ describe("kubeconfig manager tests", () => {
       contextName: "minikube",
       kubeConfigPath: "minikube-config.yml",
       workspace: workspaceStore.currentWorkspaceId
-    })
-    const contextHandler = new ContextHandler(cluster)
-    const port = await getFreePort()
-    const kubeConfManager = await KubeconfigManager.create(cluster, contextHandler, port)
+    });
+    const contextHandler = new ContextHandler(cluster);
+    const port = await getFreePort();
+    const kubeConfManager = await KubeconfigManager.create(cluster, contextHandler, port);
 
-    const configPath = kubeConfManager.getPath()
-    expect(await fse.pathExists(configPath)).toBe(true)
-    await kubeConfManager.unlink()
-    expect(await fse.pathExists(configPath)).toBe(false)
-    await kubeConfManager.unlink() // doesn't throw
-    expect(kubeConfManager.getPath()).toBeUndefined()
-  })
-})
+    const configPath = kubeConfManager.getPath();
+    expect(await fse.pathExists(configPath)).toBe(true);
+    await kubeConfManager.unlink();
+    expect(await fse.pathExists(configPath)).toBe(false);
+    await kubeConfManager.unlink(); // doesn't throw
+    expect(kubeConfManager.getPath()).toBeUndefined();
+  });
+});