kubernetes-fluent-client 3.1.2 → 3.1.3

package/src/fetch.test.ts

@@ -1,115 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
-
-import { expect, test, beforeEach } from "@jest/globals";
-
-import { StatusCodes } from "http-status-codes";
-import nock from "nock";
-import { RequestInit } from "node-fetch";
-import { fetch } from "./fetch";
-
-beforeEach(() => {
-  nock("https://jsonplaceholder.typicode.com")
-    .get("/todos/1")
-    .reply(200, {
-      userId: 1,
-      id: 1,
-      title: "Example title",
-      completed: false,
-    })
-    .post("/todos", {
-      title: "test todo",
-      userId: 1,
-      completed: false,
-    })
-    .reply(200, (uri, requestBody) => requestBody)
-    .get("/todos/empty-null")
-    .reply(200, undefined)
-    .get("/todos/empty-string")
-    .reply(200, "")
-    .get("/todos/empty-object")
-    .reply(200, {})
-    .get("/todos/invalid")
-    .replyWithError("Something bad happened");
-});
-
-test("fetch: should return without type data", async () => {
-  const url = "https://jsonplaceholder.typicode.com/todos/1";
-  const { data, ok } = await fetch<{ title: string }>(url);
-  expect(ok).toBe(true);
-  expect(data["title"]).toBe("Example title");
-});
-
-test("fetch: should return parsed JSON response as a specific type", async () => {
-  interface Todo {
-    userId: number;
-    id: number;
-    title: string;
-    completed: boolean;
-  }
-
-  const url = "https://jsonplaceholder.typicode.com/todos/1";
-  const { data, ok } = await fetch<Todo>(url);
-  expect(ok).toBe(true);
-  expect(data.id).toBe(1);
-  expect(typeof data.title).toBe("string");
-  expect(typeof data.completed).toBe("boolean");
-});
-
-test("fetch: should handle additional request options", async () => {
-  const url = "https://jsonplaceholder.typicode.com/todos";
-  const requestOptions: RequestInit = {
-    method: "POST",
-    body: JSON.stringify({
-      title: "test todo",
-      userId: 1,
-      completed: false,
-    }),
-    headers: {
-      "Content-type": "application/json; charset=UTF-8",
-    },
-  };
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const { data, ok } = await fetch<any>(url, requestOptions);
-  expect(ok).toBe(true);
-  expect(data["title"]).toBe("test todo");
-  expect(data["userId"]).toBe(1);
-  expect(data["completed"]).toBe(false);
-});
-
-test("fetch: should handle empty (null) responses", async () => {
-  const url = "https://jsonplaceholder.typicode.com/todos/empty-null";
-  const resp = await fetch(url);
-
-  expect(resp.data).toBe("");
-  expect(resp.ok).toBe(true);
-  expect(resp.status).toBe(StatusCodes.OK);
-});
-
-test("fetch: should handle empty (string) responses", async () => {
-  const url = "https://jsonplaceholder.typicode.com/todos/empty-string";
-  const resp = await fetch(url);
-
-  expect(resp.data).toBe("");
-  expect(resp.ok).toBe(true);
-  expect(resp.status).toBe(StatusCodes.OK);
-});
-
-test("fetch: should handle empty (object) responses", async () => {
-  const url = "https://jsonplaceholder.typicode.com/todos/empty-object";
-  const resp = await fetch(url);
-
-  expect(resp.data).toEqual({});
-  expect(resp.ok).toBe(true);
-  expect(resp.status).toBe(StatusCodes.OK);
-});
-
-test("fetch: should handle failed requests without throwing an error", async () => {
-  const url = "https://jsonplaceholder.typicode.com/todos/invalid";
-  const resp = await fetch(url);
-
-  expect(resp.data).toBe(undefined);
-  expect(resp.ok).toBe(false);
-  expect(resp.status).toBe(StatusCodes.BAD_REQUEST);
-});

package/src/fileSystem.test.ts

@@ -1,67 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
-
-import * as fs from "fs";
-import { NodeFileSystem } from "./fileSystem";
-import { beforeEach, describe, expect, jest, test } from "@jest/globals";
-
-// Mock the fs module
-jest.mock("fs");
-
-describe("NodeFileSystem", () => {
-  let nodeFileSystem: NodeFileSystem;
-
-  beforeEach(() => {
-    nodeFileSystem = new NodeFileSystem();
-    jest.clearAllMocks(); // Clear all mocks before each test
-  });
-
-  describe("readFile", () => {
-    test("should call fs.readFileSync with correct arguments", () => {
-      const mockFilePath = "test-file.txt";
-      const mockFileContent = "This is a test file";
-
-      // Mock the fs.readFileSync method to return the mock file content
-      (fs.readFileSync as jest.Mock).mockReturnValue(mockFileContent);
-
-      const result = nodeFileSystem.readFile(mockFilePath);
-
-      // Assert that fs.readFileSync was called with the correct file path and encoding
-      expect(fs.readFileSync).toHaveBeenCalledWith(mockFilePath, "utf8");
-
-      // Assert that the returned content matches the mock file content
-      expect(result).toBe(mockFileContent);
-    });
-  });
-
-  describe("writeFile", () => {
-    test("should call fs.writeFileSync with correct arguments", () => {
-      const mockFilePath = "test-file.txt";
-      const mockFileContent = "This is a test file";
-
-      // Call the writeFile method
-      nodeFileSystem.writeFile(mockFilePath, mockFileContent);
-
-      // Assert that fs.writeFileSync was called with the correct arguments
-      expect(fs.writeFileSync).toHaveBeenCalledWith(mockFilePath, mockFileContent, "utf8");
-    });
-  });
-
-  describe("readdirSync", () => {
-    test("should call fs.readdirSync with correct arguments and return file list", () => {
-      const mockDirectoryPath = "test-directory";
-      const mockFileList = ["file1.txt", "file2.txt"];
-
-      // Mock the fs.readdirSync method to return the mock file list
-      (fs.readdirSync as jest.Mock).mockReturnValue(mockFileList);
-
-      const result = nodeFileSystem.readdirSync(mockDirectoryPath);
-
-      // Assert that fs.readdirSync was called with the correct directory path
-      expect(fs.readdirSync).toHaveBeenCalledWith(mockDirectoryPath);
-
-      // Assert that the returned file list matches the mock file list
-      expect(result).toEqual(mockFileList);
-    });
-  });
-});

package/src/fluent/http2-watch.spec.ts

@@ -1,335 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
-import http2 from "http2";
-import { Watcher } from "./watch";
-import { WatchEvent, kind } from "..";
-import { WatchPhase } from "./types";
-import { K8s } from ".";
-
-jest.mock("http2");
-
-describe("Watcher HTTP2", () => {
-  let watcher: Watcher<typeof kind.Pod>;
-  let mockClient: jest.Mocked<http2.ClientHttp2Session>;
-  let mockReq: jest.Mocked<http2.ClientHttp2Stream>;
-  const evtMock = jest.fn<(update: kind.Pod, phase: WatchPhase) => void>();
-  const errMock = jest.fn<(err: Error) => void>();
-
-  const setupAndStartWatcher = (eventType: WatchEvent, handler: (...args: any[]) => void) => {
-    watcher.events.on(eventType, handler);
-    watcher.start().catch(errMock);
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-
-    // http2.client
-    mockClient = {
-      request: jest.fn(),
-      close: jest.fn(),
-      on: jest.fn(),
-      destroy: jest.fn(),
-    } as unknown as jest.Mocked<http2.ClientHttp2Session>;
-
-    // http2.request stream
-    mockReq = {
-      on: jest.fn(),
-      end: jest.fn(),
-      setEncoding: jest.fn(),
-    } as unknown as jest.Mocked<http2.ClientHttp2Stream>;
-
-    // http2.connect function to return the mocked client session
-    (http2.connect as jest.Mock).mockReturnValue(mockClient);
-  });
-
-  afterEach(() => {
-    watcher.close();
-  });
-
-  it("should watch named resources", done => {
-    const pod = createMockPod("pod-1", "1");
-    const response = { type: "ADDED", object: pod };
-
-    watcher = K8s(kind.Pod).Watch(evtMock, {
-      useHTTP2: true,
-    });
-
-    mockReq.on.mockImplementation((event, callback) => {
-      switch (event) {
-        case "response":
-          callback(
-            { ":status": 200 } as http2.IncomingHttpHeaders & http2.IncomingHttpStatusHeader,
-            0,
-          );
-          break;
-        case "data":
-          setTimeout(() => {
-            (callback as (chunk: Buffer) => void)(Buffer.from(JSON.stringify(response)));
-          }, 10);
-          break;
-        case "end":
-          setTimeout(() => {
-            (callback as () => void)();
-            done();
-          }, 20);
-          break;
-        case "error":
-          errMock(new Error("HTTP2 connection error"));
-          break;
-      }
-      return mockReq;
-    });
-
-    mockClient.request.mockReturnValue(mockReq);
-
-    setupAndStartWatcher(WatchEvent.CONNECT, () => {
-      setupAndStartWatcher(WatchEvent.DATA, (receivedPod, phase) => {
-        expect(receivedPod.metadata?.name).toBe("pod-1");
-        expect(receivedPod.metadata?.resourceVersion).toBe("1");
-        expect(phase).toBe(WatchPhase.Added);
-        done();
-      });
-    });
-  });
-
-  it("should handle resource version is too old", done => {
-    const errorResponse = {
-      type: "ERROR",
-      object: {
-        kind: "Status",
-        apiVersion: "v1",
-        metadata: {},
-        status: "Failure",
-        message: "too old resource version: 123 (391079)",
-        reason: "Gone",
-        code: 410,
-      },
-    };
-
-    watcher = K8s(kind.Pod).Watch(evtMock, {
-      useHTTP2: true,
-    });
-
-    mockReq.on.mockImplementation((event, callback) => {
-      switch (event) {
-        case "response":
-          callback(
-            { ":status": 200 } as http2.IncomingHttpHeaders & http2.IncomingHttpStatusHeader,
-            0,
-          );
-          break;
-        case "data":
-          setTimeout(() => {
-            (callback as (chunk: Buffer) => void)(Buffer.from(JSON.stringify(errorResponse)));
-          }, 10);
-          break;
-        case "end":
-          setTimeout(() => {
-            (callback as () => void)();
-            done();
-          }, 20);
-          break;
-        case "error":
-          errMock(new Error("HTTP2 connection error"));
-          break;
-      }
-      return mockReq;
-    });
-
-    mockClient.request.mockReturnValue(mockReq);
-
-    setupAndStartWatcher(WatchEvent.OLD_RESOURCE_VERSION, res => {
-      expect(res).toEqual("123");
-      done();
-    });
-  });
-
-  it("should call the event handler for each event", done => {
-    const pod = createMockPod("pod-0", "1");
-    const response = { type: "ADDED", object: pod };
-
-    watcher = K8s(kind.Pod).Watch(
-      (evt, phase) => {
-        expect(evt.metadata?.name).toEqual("pod-0");
-        expect(phase).toEqual(WatchPhase.Added);
-      },
-      { useHTTP2: true },
-    );
-
-    mockReq.on.mockImplementation((event, callback) => {
-      switch (event) {
-        case "response":
-          callback(
-            { ":status": 200 } as http2.IncomingHttpHeaders & http2.IncomingHttpStatusHeader,
-            0,
-          );
-          break;
-        case "data":
-          setTimeout(() => {
-            (callback as (chunk: Buffer) => void)(Buffer.from(JSON.stringify(response)));
-          }, 10);
-          break;
-        case "end":
-          setTimeout(() => {
-            (callback as () => void)();
-          }, 20);
-          break;
-        case "error":
-          errMock(new Error("HTTP2 connection error"));
-          break;
-      }
-      return mockReq;
-    });
-
-    mockClient.request.mockReturnValue(mockReq);
-
-    watcher.start().catch(errMock);
-    done();
-  });
-
-  it("should return the cache id", () => {
-    watcher = K8s(kind.Pod).Watch(evtMock, {
-      resyncDelaySec: 1,
-      useHTTP2: true,
-    });
-    expect(watcher.getCacheID()).toEqual("d69b75a611");
-  });
-
-  it("should handle the CONNECT event", done => {
-    watcher = K8s(kind.Pod).Watch(evtMock, {
-      resyncDelaySec: 1,
-      useHTTP2: true,
-    });
-    setupAndStartWatcher(WatchEvent.CONNECT, () => {});
-    done();
-  });
-
-  it("should handle the DATA event", done => {
-    watcher = K8s(kind.Pod).Watch(evtMock, {
-      resyncDelaySec: 1,
-      useHTTP2: true,
-    });
-    setupAndStartWatcher(WatchEvent.DATA, (pod, phase) => {
-      expect(pod.metadata?.name).toEqual("pod-0");
-      expect(phase).toEqual(WatchPhase.Added);
-    });
-    done();
-  });
-
-  it("should handle the NETWORK_ERROR event", done => {
-    const errorMessage = "Something bad happened";
-    watcher = K8s(kind.Pod).Watch(evtMock, {
-      useHTTP2: true,
-      resyncDelaySec: 1,
-    });
-
-    mockReq.on.mockImplementation((event, callback) => {
-      if (event === "response") {
-        callback(
-          { ":status": 200 } as http2.IncomingHttpHeaders & http2.IncomingHttpStatusHeader,
-          0,
-        );
-      } else if (event === "error") {
-        (callback as (err: Error) => void)(new Error(errorMessage));
-      }
-      return mockReq;
-    });
-
-    mockClient.request.mockReturnValue(mockReq);
-
-    setupAndStartWatcher(WatchEvent.NETWORK_ERROR, error => {
-      expect(error.message).toEqual(errorMessage);
-    });
-
-    watcher.start().catch(errMock);
-    done();
-  });
-
-  it("should handle the RECONNECT event on an error", done => {
-    const errorMessage = "Something bad happened";
-
-    watcher = K8s(kind.Pod).Watch(evtMock, {
-      useHTTP2: true,
-      resyncDelaySec: 0.01,
-    });
-
-    let reconnectCount = 0;
-
-    mockReq.on.mockImplementation((event, callback) => {
-      if (event === "response") {
-        callback(
-          { ":status": 200 } as http2.IncomingHttpHeaders & http2.IncomingHttpStatusHeader,
-          0,
-        );
-      } else if (event === "error") {
-        reconnectCount += 1;
-        (callback as (err: Error) => void)(new Error(errorMessage));
-      }
-      return mockReq;
-    });
-
-    mockClient.request.mockReturnValue(mockReq);
-
-    setupAndStartWatcher(WatchEvent.RECONNECT, count => {
-      expect(count).toEqual(reconnectCount);
-    });
-
-    watcher.start().catch(errMock);
-    done();
-  });
-  it("should perform a resync after the resync interval", done => {
-    watcher = K8s(kind.Pod).Watch(evtMock, {
-      useHTTP2: true,
-      resyncDelaySec: 1,
-    });
-    watcher.start().catch(errMock);
-    done();
-  });
-  it("should handle the GIVE_UP event", done => {
-    watcher = K8s(kind.Pod).Watch(evtMock, {
-      useHTTP2: true,
-      lastSeenLimitSeconds: 0.01,
-      resyncDelaySec: 0.01,
-      resyncFailureMax: 1,
-    });
-    setupAndStartWatcher(WatchEvent.GIVE_UP, () => {
-      expect(errMock).toBeCalled();
-    });
-    watcher.start().catch(errMock);
-    done();
-  });
-});
-
-/**
- * Creates a mock pod object
- *
- * @param name The name of the pod
- * @param resourceVersion The resource version of the pod
- * @returns A mock pod object
- */
-function createMockPod(name: string, resourceVersion: string): kind.Pod {
-  return {
-    kind: "Pod",
-    apiVersion: "v1",
-    metadata: {
-      name,
-      resourceVersion,
-      uid: "abc-123-xyz",
-    },
-    spec: {
-      containers: [
-        {
-          name: "nginx",
-          image: "nginx:1.14.2",
-          ports: [
-            {
-              containerPort: 80,
-              protocol: "TCP",
-            },
-          ],
-        },
-      ],
-    },
-    status: {},
-  };
-}