@credibledata/cred-cli 0.1.4 → 0.1.5

package/src/commands/package/deletepackage.spec.ts

@@ -0,0 +1,164 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { PackagesApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation } from "../../utils";
+import { deletePackage } from "./deletepackage";
+
+describe("delete-package", () => {
+   let sandbox: sinon.SinonSandbox;
+   let deletePackageStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let getConfirmationStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      deletePackageStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox
+         .stub(ClientConfiguration.prototype, "getProject")
+         .returns("test-project");
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getHeaders")
+         .returns({ Authorization: "Bearer test-token" });
+
+      sandbox
+         .stub(PackagesApi.prototype, "deletePackage")
+         .callsFake(deletePackageStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should delete package successfully", async () => {
+      deletePackageStub.resolves({ status: 200 });
+      getConfirmationStub.resolves(true);
+
+      await deletePackage("http://test-server", "/test-package", false, true);
+
+      expect(deletePackageStub.calledOnce).to.be.true;
+      expect(deletePackageStub.firstCall.args[0]).to.equal("test-org");
+      expect(deletePackageStub.firstCall.args[1]).to.equal("test-project");
+      expect(deletePackageStub.firstCall.args[2]).to.equal("test-package");
+      expect(deletePackageStub.firstCall.args[3]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Package deleted successfully"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle package path without leading slash", async () => {
+      deletePackageStub.resolves({ status: 200 });
+      getConfirmationStub.resolves(true);
+
+      await deletePackage("http://test-server", "test-package", false, true);
+
+      expect(deletePackageStub.firstCall.args[2]).to.equal("test-package");
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      deletePackageStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(PackagesApi.prototype, "deletePackage")
+         .callsFake(deletePackageStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+
+      await deletePackage("http://test-server", "/test-package", false, true);
+
+      expect(deletePackageStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure that you are logged in"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle missing project", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      deletePackageStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox.stub(ClientConfiguration.prototype, "getProject").returns("");
+      sandbox
+         .stub(PackagesApi.prototype, "deletePackage")
+         .callsFake(deletePackageStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+
+      await deletePackage("http://test-server", "/test-package", false, true);
+
+      expect(deletePackageStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure to set a project"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should request confirmation when autoConfirm is false", async () => {
+      deletePackageStub.resolves({ status: 200 });
+      getConfirmationStub.resolves(true);
+
+      await deletePackage("http://test-server", "/test-package", false, false);
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(deletePackageStub.calledOnce).to.be.true;
+   });
+
+   it("should cancel when confirmation is denied", async () => {
+      getConfirmationStub.resolves(false);
+
+      await deletePackage("http://test-server", "/test-package", false, false);
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(deletePackageStub.called).to.be.false;
+      expect(loggerStub.info.calledWith(sinon.match("Operation cancelled."))).to
+         .be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      deletePackageStub.rejects(mockError);
+      getConfirmationStub.resolves(true);
+
+      await deletePackage("http://test-server", "/test-package", true, true);
+
+      expect(deletePackageStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to delete package")),
+      ).to.be.true;
+   });
+});

package/src/commands/package/listpackages.spec.ts

@@ -0,0 +1,147 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { PackagesApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson } from "../../utils";
+import { listPackages, printOutPackages } from "./listpackages";
+
+describe("list-packages", () => {
+   let sandbox: sinon.SinonSandbox;
+   let listPackagesStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      listPackagesStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox
+         .stub(ClientConfiguration.prototype, "getProject")
+         .returns("test-project");
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getHeaders")
+         .returns({ Authorization: "Bearer test-token" });
+
+      sandbox
+         .stub(PackagesApi.prototype, "listPackages")
+         .callsFake(listPackagesStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should list packages successfully", async () => {
+      const mockPackages = [
+         { name: "package1", latestVersion: "1.0.0" },
+         { name: "package2", latestVersion: "2.0.0" },
+      ];
+      const mockResponse = {
+         data: mockPackages,
+         headers: {},
+      };
+      listPackagesStub.resolves(mockResponse);
+
+      const result = await listPackages("http://test-server", false);
+
+      expect(listPackagesStub.calledOnce).to.be.true;
+      expect(listPackagesStub.firstCall.args[0]).to.equal("test-org");
+      expect(listPackagesStub.firstCall.args[1]).to.equal("test-project");
+      expect(listPackagesStub.firstCall.args[2]).to.equal(-1); // limit
+      expect(listPackagesStub.firstCall.args[3]).to.equal(0); // offset
+      expect(listPackagesStub.firstCall.args[4]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(result).to.deep.equal({
+         packages: mockPackages,
+         totalCount: undefined,
+      });
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listPackagesStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(PackagesApi.prototype, "listPackages")
+         .callsFake(listPackagesStub);
+
+      const result = await listPackages("http://test-server", false);
+
+      expect(listPackagesStub.called).to.be.false;
+      expect(result).to.be.undefined;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure that you are logged in"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle missing project", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listPackagesStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox.stub(ClientConfiguration.prototype, "getProject").returns("");
+      sandbox
+         .stub(PackagesApi.prototype, "listPackages")
+         .callsFake(listPackagesStub);
+
+      const result = await listPackages("http://test-server", false);
+
+      expect(listPackagesStub.called).to.be.false;
+      expect(result).to.be.undefined;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure to set a project"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      listPackagesStub.rejects(mockError);
+
+      const result = await listPackages("http://test-server", true);
+
+      expect(listPackagesStub.calledOnce).to.be.true;
+      expect(result).to.be.undefined;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to list packages")),
+      ).to.be.true;
+   });
+
+   it("should print packages when using printOutPackages", async () => {
+      const mockPackages = [{ name: "package1" }];
+      const mockResponse = {
+         data: mockPackages,
+         headers: {},
+      };
+      listPackagesStub.resolves(mockResponse);
+
+      await printOutPackages("http://test-server", false);
+
+      expect(consoleLogStub.called).to.be.true;
+   });
+});

package/src/commands/package/listpackages.ts

@@ -2,11 +2,21 @@ import { PackagesApi } from "../../client/api";
 import { Configuration } from "../../client/configuration";
 import { ClientConfiguration } from "../../clientconfiguration";
 import { logger } from "../../logger";
-import { prettifyJson, printOutError } from "../../utils";
+import {
+   prettifyJson,
+   printOutError,
+   parsePaginationParams,
+   extractTotalCount,
+} from "../../utils";
 
 const packagesApi = new PackagesApi(new Configuration());
 
-export async function listPackages(controlPlane: string, debug: boolean) {
+export async function listPackages(
+   controlPlane: string,
+   debug: boolean,
+   page?: string | number,
+   pageSize?: string | number,
+) {
    const clientConfig = new ClientConfiguration();
    const organizationName = clientConfig.getOrganization();
    const projectName = clientConfig.getProject();
@@ -22,23 +32,36 @@ export async function listPackages(controlPlane: string, debug: boolean) {
    }
 
    try {
+      const { limit, offset } = parsePaginationParams(page, pageSize);
       const response = await packagesApi.listPackages(
          organizationName,
          projectName,
+         limit,
+         offset,
          {
             baseURL: controlPlane,
             headers: clientConfig.getHeaders(),
          },
       );
 
-      return response.data;
+      const totalCount = extractTotalCount(response.headers);
+
+      return {
+         packages: response.data,
+         totalCount,
+      };
    } catch (e) {
       logger.error("Failed to list packages");
       printOutError(e, debug);
    }
 }
 
-export async function printOutPackages(controlPlane: string, debug: boolean) {
-   const packages = await listPackages(controlPlane, debug);
+export async function printOutPackages(
+   controlPlane: string,
+   debug: boolean,
+   page?: string | number,
+   pageSize?: string | number,
+) {
+   const packages = await listPackages(controlPlane, debug, page, pageSize);
    console.log(prettifyJson(packages));
 }