Add some basic unit tests for the following files: (#1050)

* Add some basic unit tests for cluster, kube-auth-proxy, and kubeconfig-manager

- src/main/cluster.ts
- src/main/kube-auth-proxy.ts
- src/main/kubeconfig-manager.ts

Signed-off-by: Sebastian Malton <sebastian@malton.name>

src/main/__test__/cluster.test.ts

@@ -0,0 +1,165 @@
+const logger = {
+  silly: jest.fn(),
+  debug: jest.fn(),
+  log: jest.fn(),
+  info: jest.fn(),
+  error: jest.fn(),
+  crit: jest.fn(),
+};
+
+jest.mock("winston", () => ({
+  format: {
+    colorize: jest.fn(),
+    combine: jest.fn(),
+    simple: jest.fn(),
+    label: jest.fn(),
+    timestamp: jest.fn(),
+    printf: jest.fn()
+  },
+  createLogger: jest.fn().mockReturnValue(logger),
+  transports: {
+    Console: jest.fn(),
+    File: jest.fn(),
+  }
+}))
+
+
+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 { 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"
+
+const mockedRequest = request as jest.MockedFunction<typeof request>
+
+console = new Console(process.stdout, process.stderr) // fix mockFS
+
+describe("create clusters", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  beforeEach(() => {
+    const mockOpts = {
+      "minikube-config.yml": JSON.stringify({
+        apiVersion: "v1",
+        clusters: [{
+          name: "minikube",
+          cluster: {
+            server: "https://192.168.64.3:8443",
+          },
+        }],
+        contexts: [{
+          context: {
+            cluster: "minikube",
+            user: "minikube",
+          },
+          name: "minikube",
+        }],
+        users: [{
+          name: "minikube",
+        }],
+        kind: "Config",
+        preferences: {},
+      })
+    }
+    mockFs(mockOpts)
+  })
+
+  afterEach(() => {
+    mockFs.restore()
+  })
+
+  it("should be able to create a cluster from a cluster model and apiURL should be decoded", () => {
+    const c = new Cluster({
+      id: "foo",
+      contextName: "minikube",
+      kubeConfigPath: "minikube-config.yml",
+      workspace: workspaceStore.currentWorkspaceId
+    })
+    expect(c.apiUrl).toBe("https://192.168.64.3:8443")
+  })
+
+  it("init should not throw if everything is in order", async () => {
+    const c = new Cluster({
+      id: "foo",
+      contextName: "minikube",
+      kubeConfigPath: "minikube-config.yml",
+      workspace: workspaceStore.currentWorkspaceId
+    })
+    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()
+    jest.spyOn(ContextHandler.prototype, "ensureServer");
+
+    const mockListNSs = jest.fn()
+    const mockKC = {
+      makeApiClient() {
+        return {
+          listNamespace: mockListNSs,
+        }
+      }
+    }
+
+    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)
+      })
+      .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)
+    mockListNSs.mockImplementationOnce(() => ({
+      body: {
+        items: [{
+          metadata: {
+            name: "default",
+          }
+        }]
+      }
+    }))
+
+    mockedRequest.mockImplementationOnce(((uri: any, _options: any) => {
+      expect(uri).toBe(`http://localhost:${port}/api-kube/version`)
+      return Promise.resolve({ gitVersion: "1.2.3" })
+    }) as any)
+
+    const c = new Cluster({
+      id: "foo",
+      contextName: "minikube",
+      kubeConfigPath: "minikube-config.yml",
+      workspace: workspaceStore.currentWorkspaceId
+    })
+    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)
+
+    jest.resetAllMocks()
+  })
+})

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

@@ -0,0 +1,130 @@
+const logger = {
+  silly: jest.fn(),
+  debug: jest.fn(),
+  log: jest.fn(),
+  info: jest.fn(),
+  error: jest.fn(),
+  crit: jest.fn(),
+};
+
+jest.mock("winston", () => ({
+  format: {
+    colorize: jest.fn(),
+    combine: jest.fn(),
+    simple: jest.fn(),
+    label: jest.fn(),
+    timestamp: jest.fn(),
+    printf: jest.fn()
+  },
+  createLogger: jest.fn().mockReturnValue(logger),
+  transports: {
+    Console: jest.fn(),
+    File: jest.fn(),
+  }
+}))
+
+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 { broadcastIpc } from "../../common/ipc"
+import { ChildProcess, spawn, SpawnOptions } from "child_process"
+import { Kubectl } from "../kubectl"
+import { mock, MockProxy } from 'jest-mock-extended';
+import { waitUntilUsed } from 'tcp-port-used';
+import { Readable } from "stream"
+
+const mockBroadcastIpc = broadcastIpc as jest.MockedFunction<typeof broadcastIpc>
+const mockSpawn = spawn as jest.MockedFunction<typeof spawn>
+const mockWaitUntilUsed = waitUntilUsed as jest.MockedFunction<typeof waitUntilUsed>
+
+describe("kube auth proxy tests", () => {
+  beforeEach(() => {
+    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()
+  })
+
+  describe("spawn tests", () => {
+    let port: number
+    let mockedCP: MockProxy<ChildProcess>
+    let listeners: Record<string, (...args: any[]) => void>
+
+    beforeEach(async () => {
+      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))
+      mockedCP.on.mockImplementation((event: string, listener: (message: any, sendHandle: any) => void): ChildProcess => {
+        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>()
+      mockedCP.stdout.on.mockImplementation((event: string, listener: (message: any, sendHandle: any) => void): Readable => {
+        listeners[`stdout/${event}`] = listener
+        return mockedCP.stdout
+      })
+      mockSpawn.mockImplementationOnce((command: string, args: readonly string[], options: SpawnOptions): ChildProcess => {
+        expect(command).toBe(Kubectl.bundledKubectlPath)
+        return mockedCP
+      })
+      mockWaitUntilUsed.mockReturnValueOnce(Promise.resolve())
+    })
+
+    it("should call spawn and broadcast errors", async () => {
+      const kap = new KubeAuthProxy(new Cluster({ id: "foobar", kubeConfigPath: "fake-path.yml" }), port, {})
+      await kap.run()
+      listeners["error"]({ message: "foobarbat" })
+
+      expect(mockBroadcastIpc).toBeCalledWith({ channel: "kube-auth:foobar", args: [{ data: "foobarbat", error: true }] })
+    })
+
+    it("should call spawn and broadcast exit", async () => {
+      const kap = new KubeAuthProxy(new Cluster({ id: "foobar", kubeConfigPath: "fake-path.yml" }), port, {})
+      await kap.run()
+      listeners["exit"](0)
+
+      expect(mockBroadcastIpc).toBeCalledWith({ channel: "kube-auth:foobar", args: [{ data: "proxy exited with code: 0", error: false }] })
+    })
+
+    it("should call spawn and broadcast errors from stderr", async () => {
+      const kap = new KubeAuthProxy(new Cluster({ id: "foobar", kubeConfigPath: "fake-path.yml" }), port, {})
+      await kap.run()
+      listeners["stderr/data"]("an error")
+
+      expect(mockBroadcastIpc).toBeCalledWith({ channel: "kube-auth:foobar", args: [{ data: "an error", error: true }] })
+    })
+
+    it("should call spawn and broadcast stdout serving info", async () => {
+      const kap = new KubeAuthProxy(new Cluster({ id: "foobar", kubeConfigPath: "fake-path.yml" }), port, {})
+      await kap.run()
+      listeners["stdout/data"]("Starting to serve on")
+
+      expect(mockBroadcastIpc).toBeCalledWith({ channel: "kube-auth:foobar", args: [{ data: "Authentication proxy started\n" }] })
+    })
+
+    it("should call spawn and broadcast stdout other info", async () => {
+      const kap = new KubeAuthProxy(new Cluster({ id: "foobar", kubeConfigPath: "fake-path.yml" }), port, {})
+      await kap.run()
+      listeners["stdout/data"]("some info")
+
+      expect(mockBroadcastIpc).toBeCalledWith({ channel: "kube-auth:foobar", args: [{ data: "some info" }] })
+    })
+  })
+})

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

@@ -0,0 +1,112 @@
+const logger = {
+  silly: jest.fn(),
+  debug: jest.fn(),
+  log: jest.fn(),
+  info: jest.fn(),
+  error: jest.fn(),
+  crit: jest.fn(),
+};
+
+jest.mock("winston", () => ({
+  format: {
+    colorize: jest.fn(),
+    combine: jest.fn(),
+    simple: jest.fn(),
+    label: jest.fn(),
+    timestamp: jest.fn(),
+    printf: jest.fn()
+  },
+  createLogger: jest.fn().mockReturnValue(logger),
+  transports: {
+    Console: jest.fn(),
+    File: jest.fn(),
+  }
+}))
+
+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 { loadYaml } from "@kubernetes/client-node";
+import { Console } from "console";
+
+console = new Console(process.stdout, process.stderr) // fix mockFS
+
+describe("kubeconfig manager tests", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  beforeEach(() => {
+    const mockOpts = {
+      "minikube-config.yml": JSON.stringify({
+        apiVersion: "v1",
+        clusters: [{
+          name: "minikube",
+          cluster: {
+            server: "https://192.168.64.3:8443",
+          },
+        }],
+        contexts: [{
+          context: {
+            cluster: "minikube",
+            user: "minikube",
+          },
+          name: "minikube",
+        }],
+        users: [{
+          name: "minikube",
+        }],
+        kind: "Config",
+        preferences: {},
+      })
+    }
+    mockFs(mockOpts)
+  })
+
+  afterEach(() => {
+    mockFs.restore()
+  })
+
+  it("should create 'temp' kube config with proxy", async () => {
+    const cluster = new Cluster({
+      id: "foo",
+      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)
+
+    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({
+      id: "foo",
+      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 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()
+  })
+})

src/main/cluster.ts

@@ -93,7 +93,7 @@ export class Cluster implements ClusterModel {
   async init(port: number) {
     try {
       this.contextHandler = new ContextHandler(this);
-      this.kubeconfigManager = new KubeconfigManager(this, this.contextHandler, port);
+      this.kubeconfigManager = await KubeconfigManager.create(this, this.contextHandler, port);
       this.kubeProxyUrl = `http://localhost:${port}${apiKubePrefix}`;
       this.initialized = true;
       logger.info(`[CLUSTER]: "${this.contextName}" init success`, {

src/main/kubeconfig-manager.ts

@@ -11,8 +11,12 @@ export class KubeconfigManager {
   protected configDir = app.getPath("temp")
   protected tempFile: string;
 
-  constructor(protected cluster: Cluster, protected contextHandler: ContextHandler, protected port: number) {
-    this.init();
+  private constructor(protected cluster: Cluster, protected contextHandler: ContextHandler, protected port: number) { }
+
+  static async create(cluster: Cluster, contextHandler: ContextHandler, port: number) {
+    const kcm = new KubeconfigManager(cluster, contextHandler, port)
+    await kcm.init()
+    return kcm
   }
 
   protected async init() {
@@ -72,8 +76,13 @@ export class KubeconfigManager {
     return tempFile;
   }
 
-  unlink() {
+  async unlink() {
+    if (!this.tempFile) {
+      return
+    }
+
     logger.info('Deleting temporary kubeconfig: ' + this.tempFile)
-    fs.unlinkSync(this.tempFile)
+    await fs.unlink(this.tempFile)
+    this.tempFile = undefined
   }
 }