kubernetes-fluent-client 3.1.1 → 3.1.3

package/src/fluent/index.test.ts

@@ -1,268 +0,0 @@
-import { beforeEach, describe, expect, it, jest } from "@jest/globals";
-import { V1APIGroup } from "@kubernetes/client-node";
-import { Operation } from "fast-json-patch";
-
-import { K8s } from ".";
-import { fetch } from "../fetch";
-import { Pod } from "../upstream";
-import { k8sCfg, k8sExec } from "./utils";
-
-// Setup mocks
-jest.mock("./utils");
-jest.mock("../fetch");
-
-const generateFakePodManagedFields = (manager: string) => {
-  return [
-    {
-      apiVersion: "v1",
-      fieldsType: "FieldsV1",
-      fieldsV1: {
-        "f:metadata": {
-          "f:labels": {
-            "f:fake": {},
-          },
-          "f:spec": {
-            "f:containers": {
-              'k:{"name":"fake"}': {
-                "f:image": {},
-                "f:name": {},
-                "f:resources": {
-                  "f:limits": {
-                    "f:cpu": {},
-                    "f:memory": {},
-                  },
-                  "f:requests": {
-                    "f:cpu": {},
-                    "f:memory": {},
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-      manager: manager,
-      operation: "Apply",
-    },
-  ];
-};
-describe("Kube", () => {
-  const fakeResource = {
-    metadata: {
-      name: "fake",
-      namespace: "default",
-      managedFields: generateFakePodManagedFields("pepr"),
-    },
-  };
-
-  const mockedKubeCfg = jest.mocked(k8sCfg);
-  const mockedKubeExec = jest.mocked(k8sExec).mockResolvedValue(fakeResource);
-
-  beforeEach(() => {
-    // Clear all instances and calls to constructor and all methods:
-    mockedKubeExec.mockClear();
-  });
-
-  it("should create a resource", async () => {
-    const result = await K8s(Pod).Create(fakeResource);
-
-    expect(result).toEqual(fakeResource);
-    expect(mockedKubeExec).toHaveBeenCalledWith(
-      Pod,
-      expect.objectContaining({
-        name: "fake",
-        namespace: "default",
-      }),
-      "POST",
-      fakeResource,
-    );
-  });
-
-  it("should delete a resource", async () => {
-    await K8s(Pod).Delete(fakeResource);
-
-    expect(mockedKubeExec).toHaveBeenCalledWith(
-      Pod,
-      expect.objectContaining({
-        name: "fake",
-        namespace: "default",
-      }),
-      "DELETE",
-    );
-  });
-
-  it("should patch a resource", async () => {
-    const patchOperations: Operation[] = [
-      { op: "replace", path: "/metadata/name", value: "new-fake" },
-    ];
-
-    const result = await K8s(Pod).Patch(patchOperations);
-
-    expect(result).toEqual(fakeResource);
-    expect(mockedKubeExec).toHaveBeenCalledWith(Pod, {}, "PATCH", patchOperations);
-  });
-
-  it("should patch the status of a resource", async () => {
-    await K8s(Pod).PatchStatus({
-      metadata: {
-        name: "fake",
-        namespace: "default",
-        managedFields: generateFakePodManagedFields("pepr"),
-      },
-      spec: { priority: 3 },
-      status: {
-        phase: "Ready",
-      },
-    });
-
-    expect(k8sExec).toBeCalledWith(
-      Pod,
-      expect.objectContaining({
-        name: "fake",
-        namespace: "default",
-      }),
-      "PATCH_STATUS",
-      {
-        apiVersion: "v1",
-        kind: "Pod",
-        metadata: {
-          name: "fake",
-          namespace: "default",
-          managedFields: generateFakePodManagedFields("pepr"),
-        },
-        spec: { priority: 3 },
-        status: {
-          phase: "Ready",
-        },
-      },
-    );
-  });
-
-  it("should filter with WithField", async () => {
-    await K8s(Pod).WithField("metadata.name", "fake").Get();
-
-    expect(mockedKubeExec).toHaveBeenCalledWith(
-      Pod,
-      expect.objectContaining({
-        fields: {
-          "metadata.name": "fake",
-        },
-      }),
-      "GET",
-    );
-  });
-
-  it("should filter with WithLabel", async () => {
-    await K8s(Pod).WithLabel("app", "fakeApp").Get();
-
-    expect(mockedKubeExec).toHaveBeenCalledWith(
-      Pod,
-      expect.objectContaining({
-        labels: {
-          app: "fakeApp",
-        },
-      }),
-      "GET",
-    );
-  });
-
-  it("should use InNamespace", async () => {
-    await K8s(Pod).InNamespace("fakeNamespace").Get();
-
-    expect(mockedKubeExec).toHaveBeenCalledWith(
-      Pod,
-      expect.objectContaining({
-        namespace: "fakeNamespace",
-      }),
-      "GET",
-    );
-  });
-
-  it("should throw an error if namespace is already specified", async () => {
-    expect(() => K8s(Pod, { namespace: "default" }).InNamespace("fakeNamespace")).toThrow(
-      "Namespace already specified: default",
-    );
-  });
-
-  it("should handle Delete when the resource doesn't exist", async () => {
-    mockedKubeExec.mockRejectedValueOnce({ status: 404 }); // Not Found on first call
-    await expect(K8s(Pod).Delete("fakeResource")).resolves.toBeUndefined();
-  });
-
-  it("should handle Get", async () => {
-    const result = await K8s(Pod).Get("fakeResource");
-
-    expect(result).toEqual(fakeResource);
-    expect(mockedKubeExec).toHaveBeenCalledWith(
-      Pod,
-      expect.objectContaining({
-        name: "fakeResource",
-      }),
-      "GET",
-    );
-  });
-
-  it("should thrown an error if Get is called with a name and filters are already specified a name", async () => {
-    await expect(K8s(Pod, { name: "fake" }).Get("fakeResource")).rejects.toThrow(
-      "Name already specified: fake",
-    );
-  });
-
-  it("should throw an error if no patch operations provided", async () => {
-    await expect(K8s(Pod).Patch([])).rejects.toThrow("No operations specified");
-  });
-
-  it("should allow Apply of deep partials", async () => {
-    const result = await K8s(Pod).Apply({ metadata: { name: "fake" }, spec: { priority: 3 } });
-    expect(result).toEqual(fakeResource);
-  });
-
-  it("should allow force apply to resolve FieldManagerConflict", async () => {
-    const result = await K8s(Pod).Apply(
-      {
-        metadata: { name: "fake", managedFields: generateFakePodManagedFields("kubectl") },
-        spec: { priority: 3 },
-      },
-      { force: true },
-    );
-    expect(result).toEqual(fakeResource);
-  });
-
-  it("should throw an error if a Delete failed for a reason other than Not Found", async () => {
-    mockedKubeExec.mockRejectedValueOnce({ status: 500 }); // Internal Server Error on first call
-    await expect(K8s(Pod).Delete("fakeResource")).rejects.toEqual(
-      expect.objectContaining({ status: 500 }),
-    );
-  });
-
-  it("should create a raw api request", async () => {
-    mockedKubeCfg.mockReturnValue(
-      new Promise(r =>
-        r({
-          serverUrl: "http://localhost:8080",
-          opts: {},
-        }),
-      ),
-    );
-    const mockResp = {
-      kind: "APIVersions",
-      versions: ["v1"],
-      serverAddressByClientCIDRs: [
-        {
-          serverAddress: "172.27.0.3:6443",
-        },
-      ],
-    };
-
-    jest.mocked(fetch).mockResolvedValue({
-      ok: true,
-      data: mockResp,
-      status: 200,
-      statusText: "OK",
-    });
-
-    const result = await K8s(V1APIGroup).Raw("/api");
-
-    expect(result).toEqual(mockResp);
-  });
-});

package/src/fluent/utils.test.ts

@@ -1,276 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
-
-import { beforeEach, describe, expect, it, jest } from "@jest/globals";
-import { Headers } from "node-fetch";
-
-import { fetch } from "../fetch";
-import { RegisterKind } from "../kinds";
-import { GenericClass } from "../types";
-import { ClusterRole, Ingress, Pod } from "../upstream";
-import { Filters } from "./types";
-import { k8sExec, pathBuilder } from "./utils";
-
-jest.mock("https");
-jest.mock("../fetch");
-
-describe("pathBuilder Function", () => {
-  const serverUrl = "https://jest-test:8080";
-  it("should throw an error if the kind is not specified and the model is not a KubernetesObject", () => {
-    const model = { name: "Unknown" } as unknown as GenericClass;
-    const filters: Filters = {};
-    expect(() => pathBuilder("", model, filters)).toThrow("Kind not specified for Unknown");
-  });
-
-  it("should generate a path with a set-based label selector", () => {
-    const filters: Filters = {
-      namespace: "default",
-      name: "mypod",
-      labels: { iamalabel: "" },
-    };
-    const result = pathBuilder(serverUrl, Pod, filters);
-    const expected = new URL(
-      "/api/v1/namespaces/default/pods/mypod?labelSelector=iamalabel",
-      serverUrl,
-    );
-
-    expect(result.toString()).toEqual(expected.toString());
-  });
-
-  it("should generate a path for core group kinds (with custom filters)", () => {
-    const filters: Filters = {
-      namespace: "default",
-      name: "mypod",
-      fields: { iamafield: "iamavalue" },
-      labels: { iamalabel: "iamalabelvalue" },
-    };
-    const result = pathBuilder(serverUrl, Pod, filters);
-    const expected = new URL(
-      "/api/v1/namespaces/default/pods/mypod?fieldSelector=iamafield%3Diamavalue&labelSelector=iamalabel%3Diamalabelvalue",
-      serverUrl,
-    );
-
-    expect(result.toString()).toEqual(expected.toString());
-  });
-
-  it("Version not specified in a Kind", () => {
-    const filters: Filters = {
-      namespace: "default",
-      name: "mypod",
-    };
-    class Fake {
-      name: string;
-      constructor() {
-        this.name = "Fake";
-      }
-    }
-    RegisterKind(Fake, {
-      kind: "Fake",
-      version: "",
-      group: "fake",
-    });
-    try {
-      pathBuilder(serverUrl, Fake, filters);
-    } catch (e) {
-      expect(e.message).toEqual(`Version not specified for Fake`);
-    }
-  });
-
-  it("should generate a path for core group kinds", () => {
-    const filters: Filters = { namespace: "default", name: "mypod" };
-    const result = pathBuilder(serverUrl, Pod, filters);
-    const expected = new URL("/api/v1/namespaces/default/pods/mypod", serverUrl);
-    expect(result).toEqual(expected);
-  });
-
-  it("should generate a path for non-core group kinds", () => {
-    const filters: Filters = {
-      namespace: "default",
-      name: "myingress",
-    };
-    const result = pathBuilder(serverUrl, Ingress, filters);
-    const expected = new URL(
-      "/apis/networking.k8s.io/v1/namespaces/default/ingresses/myingress",
-      serverUrl,
-    );
-    expect(result).toEqual(expected);
-  });
-
-  it("should generate a path without a namespace if not provided", () => {
-    const filters: Filters = { name: "tester" };
-    const result = pathBuilder(serverUrl, ClusterRole, filters);
-    const expected = new URL("/apis/rbac.authorization.k8s.io/v1/clusterroles/tester", serverUrl);
-    expect(result).toEqual(expected);
-  });
-
-  it("should generate a path without a name if excludeName is true", () => {
-    const filters: Filters = { namespace: "default", name: "mypod" };
-    const result = pathBuilder(serverUrl, Pod, filters, true);
-    const expected = new URL("/api/v1/namespaces/default/pods", serverUrl);
-    expect(result).toEqual(expected);
-  });
-});
-
-describe("kubeExec Function", () => {
-  const mockedFetch = jest.mocked(fetch);
-
-  const fakeFilters: Filters = { name: "fake", namespace: "default" };
-  const fakeMethod = "GET";
-  const fakePayload = {
-    metadata: { name: "fake", namespace: "default" },
-    status: { phase: "Ready" },
-  };
-  const fakeUrl = new URL("http://jest-test:8080/api/v1/namespaces/default/pods/fake");
-  const fakeOpts = {
-    body: JSON.stringify(fakePayload),
-    compress: true,
-    headers: new Headers({
-      "Content-Type": "application/json",
-      "User-Agent": `kubernetes-fluent-client`,
-    }),
-    method: fakeMethod,
-  };
-
-  beforeEach(() => {
-    mockedFetch.mockClear();
-  });
-
-  it("should make a successful fetch call", async () => {
-    mockedFetch.mockResolvedValueOnce({
-      ok: true,
-      data: fakePayload,
-      status: 200,
-      statusText: "OK",
-    });
-
-    const result = await k8sExec(Pod, fakeFilters, fakeMethod, fakePayload);
-
-    expect(result).toEqual(fakePayload);
-    expect(mockedFetch).toHaveBeenCalledWith(fakeUrl, expect.objectContaining(fakeOpts));
-  });
-
-  it("should handle PATCH_STATUS", async () => {
-    mockedFetch.mockResolvedValueOnce({
-      ok: true,
-      data: fakePayload,
-      status: 200,
-      statusText: "OK",
-    });
-
-    const result = await k8sExec(Pod, fakeFilters, "PATCH_STATUS", fakePayload);
-
-    expect(result).toEqual(fakePayload);
-    expect(mockedFetch).toHaveBeenCalledWith(
-      new URL("http://jest-test:8080/api/v1/namespaces/default/pods/fake/status"),
-      expect.objectContaining({
-        method: "PATCH",
-        compress: true,
-        headers: new Headers({
-          "Content-Type": "application/merge-patch+json",
-          "User-Agent": `kubernetes-fluent-client`,
-        }),
-        body: JSON.stringify({ status: fakePayload.status }),
-      }),
-    );
-  });
-
-  it("should handle PATCH", async () => {
-    mockedFetch.mockResolvedValueOnce({
-      ok: true,
-      data: fakePayload,
-      status: 200,
-      statusText: "OK",
-    });
-
-    const patchPayload = [{ op: "replace", path: "/status/phase", value: "Ready" }];
-
-    const result = await k8sExec(Pod, fakeFilters, "PATCH", patchPayload);
-
-    expect(result).toEqual(fakePayload);
-    expect(mockedFetch).toHaveBeenCalledWith(
-      new URL("http://jest-test:8080/api/v1/namespaces/default/pods/fake"),
-      expect.objectContaining({
-        method: "PATCH",
-        compress: true,
-        headers: new Headers({
-          "Content-Type": "application/json-patch+json",
-          "User-Agent": `kubernetes-fluent-client`,
-        }),
-        body: JSON.stringify(patchPayload),
-      }),
-    );
-  });
-
-  it("should handle APPLY", async () => {
-    mockedFetch.mockResolvedValueOnce({
-      ok: true,
-      data: fakePayload,
-      status: 200,
-      statusText: "OK",
-    });
-
-    const result = await k8sExec(Pod, fakeFilters, "APPLY", fakePayload);
-
-    expect(result).toEqual(fakePayload);
-    expect(mockedFetch).toHaveBeenCalledWith(
-      new URL(
-        "http://jest-test:8080/api/v1/namespaces/default/pods/fake?fieldManager=pepr&fieldValidation=Strict&force=false",
-      ),
-      expect.objectContaining({
-        method: "PATCH",
-        compress: true,
-        headers: new Headers({
-          "Content-Type": "application/apply-patch+yaml",
-          "User-Agent": `kubernetes-fluent-client`,
-        }),
-        body: JSON.stringify(fakePayload),
-      }),
-    );
-  });
-
-  it("should handle APPLY with force", async () => {
-    mockedFetch.mockResolvedValueOnce({
-      ok: true,
-      data: fakePayload,
-      status: 200,
-      statusText: "OK",
-    });
-
-    const result = await k8sExec(Pod, fakeFilters, "APPLY", fakePayload, { force: true });
-
-    expect(result).toEqual(fakePayload);
-    expect(mockedFetch).toHaveBeenCalledWith(
-      new URL(
-        "http://jest-test:8080/api/v1/namespaces/default/pods/fake?fieldManager=pepr&fieldValidation=Strict&force=true",
-      ),
-      expect.objectContaining({
-        method: "PATCH",
-        compress: true,
-        headers: new Headers({
-          "Content-Type": "application/apply-patch+yaml",
-          "User-Agent": `kubernetes-fluent-client`,
-        }),
-        body: JSON.stringify(fakePayload),
-      }),
-    );
-  });
-
-  it("should handle fetch call failure", async () => {
-    const fakeStatus = 404;
-    const fakeStatusText = "Not Found";
-
-    mockedFetch.mockResolvedValueOnce({
-      ok: false,
-      data: null,
-      status: fakeStatus,
-      statusText: fakeStatusText,
-    });
-
-    await expect(k8sExec(Pod, fakeFilters, fakeMethod, fakePayload)).rejects.toEqual(
-      expect.objectContaining({
-        status: fakeStatus,
-        statusText: fakeStatusText,
-      }),
-    );
-  });
-});