@credibledata/cred-cli 0.1.4 → 0.1.5

package/src/commands/package/updatepackage.spec.ts

@@ -218,4 +218,102 @@ describe("set-replication-count", () => {
          });
       });
    });
+
+   describe("updatePackage params", () => {
+      it("should pass latestVersion when provided", async () => {
+         const mockResponse = { status: 200 };
+         updatePackageStub.resolves(mockResponse);
+
+         await updatePackage(
+            "http://test-server",
+            "test-package",
+            { latestVersion: "2.0.0" },
+            false,
+            true,
+         );
+
+         expect(updatePackageStub.calledOnce).to.be.true;
+         expect(updatePackageStub.firstCall.args[3]).to.deep.include({
+            latestVersion: "2.0.0",
+         });
+      });
+
+      it("should pass description when provided", async () => {
+         const mockResponse = { status: 200 };
+         updatePackageStub.resolves(mockResponse);
+
+         await updatePackage(
+            "http://test-server",
+            "test-package",
+            { description: "Updated description" },
+            false,
+            true,
+         );
+
+         expect(updatePackageStub.calledOnce).to.be.true;
+         expect(updatePackageStub.firstCall.args[3]).to.deep.include({
+            description: "Updated description",
+         });
+      });
+
+      it("should reject invalid package path with multiple segments", async () => {
+         await updatePackage(
+            "http://test-server",
+            "foo/bar",
+            { replicationCount: 3 },
+            false,
+            true,
+         );
+
+         expect(updatePackageStub.called).to.be.false;
+         expect(
+            loggerStub.error.calledWith(sinon.match("Invalid package path")),
+         ).to.be.true;
+      });
+   });
+
+   describe("confirmation flow", () => {
+      let getConfirmationStub: sinon.SinonStub;
+
+      beforeEach(() => {
+         getConfirmationStub = sandbox.stub();
+         sandbox
+            .stub(require("../../utils"), "getConfirmation")
+            .callsFake(getConfirmationStub);
+      });
+
+      it("should request confirmation when autoConfirm is false", async () => {
+         const mockResponse = { status: 200 };
+         updatePackageStub.resolves(mockResponse);
+         getConfirmationStub.resolves(true);
+
+         await updatePackage(
+            "http://test-server",
+            "test-package",
+            { replicationCount: 3 },
+            false,
+            false,
+         );
+
+         expect(getConfirmationStub.calledOnce).to.be.true;
+         expect(updatePackageStub.calledOnce).to.be.true;
+      });
+
+      it("should cancel when confirmation is denied", async () => {
+         getConfirmationStub.resolves(false);
+
+         await updatePackage(
+            "http://test-server",
+            "test-package",
+            { replicationCount: 3 },
+            false,
+            false,
+         );
+
+         expect(getConfirmationStub.calledOnce).to.be.true;
+         expect(updatePackageStub.called).to.be.false;
+         expect(loggerStub.info.calledWith(sinon.match("Operation cancelled.")))
+            .to.be.true;
+      });
+   });
 });

package/src/commands/project/createproject.spec.ts

@@ -0,0 +1,247 @@
+import { expect } from "chai";
+import fs from "fs";
+import sinon from "sinon";
+import { ProjectsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation } from "../../utils";
+import { createProject } from "./createproject";
+
+describe("create-project", () => {
+   let sandbox: sinon.SinonSandbox;
+   let createProjectStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+   let getConfirmationStub: sinon.SinonStub;
+   let readFileSyncStub: sinon.SinonStub;
+   let setProjectStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      createProjectStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      getConfirmationStub = sandbox.stub();
+      readFileSyncStub = sandbox.stub(fs, "readFileSync");
+      setProjectStub = sandbox.stub(
+         ClientConfiguration.prototype,
+         "setProject",
+      );
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getAuthenticationHeader")
+         .returns("Bearer test-token");
+
+      sandbox
+         .stub(ProjectsApi.prototype, "createProject")
+         .callsFake(createProjectStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should create project successfully", async () => {
+      const mockResponse = {
+         data: { name: "test-project", replicationCount: 2 },
+      };
+      createProjectStub.resolves(mockResponse);
+      getConfirmationStub.resolves(true);
+
+      await createProject(
+         "http://test-server",
+         "test-project",
+         "",
+         undefined,
+         false,
+         true,
+      );
+
+      expect(createProjectStub.calledOnce).to.be.true;
+      expect(createProjectStub.firstCall.args[0]).to.equal("test-org");
+      expect(createProjectStub.firstCall.args[1]).to.deep.include({
+         name: "test-project",
+         readme: "",
+      });
+      expect(setProjectStub.calledWith("test-project")).to.be.true;
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Project created successfully"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should create project with readme file", async () => {
+      const mockResponse = {
+         data: { name: "test-project" },
+      };
+      createProjectStub.resolves(mockResponse);
+      getConfirmationStub.resolves(true);
+      readFileSyncStub.returns("README content");
+
+      await createProject(
+         "http://test-server",
+         "test-project",
+         "/path/to/readme.md",
+         undefined,
+         false,
+         true,
+      );
+
+      expect(readFileSyncStub.calledWith("/path/to/readme.md")).to.be.true;
+      expect(createProjectStub.firstCall.args[1]).to.deep.include({
+         name: "test-project",
+         readme: "README content",
+      });
+   });
+
+   it("should create project with replication count", async () => {
+      const mockResponse = {
+         data: { name: "test-project", replicationCount: 5 },
+      };
+      createProjectStub.resolves(mockResponse);
+      getConfirmationStub.resolves(true);
+
+      await createProject(
+         "http://test-server",
+         "test-project",
+         "",
+         5,
+         false,
+         true,
+      );
+
+      expect(createProjectStub.firstCall.args[1]).to.deep.include({
+         name: "test-project",
+         replicationCount: 5,
+      });
+      expect(
+         loggerStub.info.calledWith(sinon.match("Replication count set to 5")),
+      ).to.be.true;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      createProjectStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      getConfirmationStub = sandbox.stub();
+      readFileSyncStub = sandbox.stub(fs, "readFileSync");
+      setProjectStub = sandbox.stub(
+         ClientConfiguration.prototype,
+         "setProject",
+      );
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(ProjectsApi.prototype, "createProject")
+         .callsFake(createProjectStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+
+      await createProject(
+         "http://test-server",
+         "test-project",
+         "",
+         undefined,
+         false,
+         true,
+      );
+
+      expect(createProjectStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure that you are logged in"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should reject replication count less than 1", async () => {
+      await createProject(
+         "http://test-server",
+         "test-project",
+         "",
+         0,
+         false,
+         true,
+      );
+
+      expect(createProjectStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Replication count must be at least 1"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should request confirmation when autoConfirm is false", async () => {
+      const mockResponse = {
+         data: { name: "test-project" },
+      };
+      createProjectStub.resolves(mockResponse);
+      getConfirmationStub.resolves(true);
+
+      await createProject(
+         "http://test-server",
+         "test-project",
+         "",
+         undefined,
+         false,
+         false,
+      );
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(createProjectStub.calledOnce).to.be.true;
+   });
+
+   it("should cancel when confirmation is denied", async () => {
+      getConfirmationStub.resolves(false);
+
+      await createProject(
+         "http://test-server",
+         "test-project",
+         "",
+         undefined,
+         false,
+         false,
+      );
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(createProjectStub.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");
+      createProjectStub.rejects(mockError);
+      getConfirmationStub.resolves(true);
+
+      await createProject(
+         "http://test-server",
+         "test-project",
+         "",
+         undefined,
+         true,
+         true,
+      );
+
+      expect(createProjectStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to create project")),
+      ).to.be.true;
+   });
+});

package/src/commands/project/createproject.ts

@@ -11,6 +11,7 @@ export async function createProject(
    controlPlane: string,
    projectName: string,
    readmeFile: string,
+   replicationCount: number | undefined,
    debug: boolean,
    autoConfirm: boolean,
 ) {
@@ -20,6 +21,10 @@ export async function createProject(
       logger.error("Please, make sure that you are logged in");
       return;
    }
+   if (replicationCount !== undefined && replicationCount < 1) {
+      logger.error("Replication count must be at least 1");
+      return;
+   }
    if (!autoConfirm) {
       const confirmation = await getConfirmation(
          `Are you sure you that want to create a project named ${projectName}?`,
@@ -38,6 +43,9 @@ export async function createProject(
 
    try {
       const project: Project = { name: projectName, readme: readmeContents };
+      if (replicationCount !== undefined) {
+         project.replicationCount = replicationCount;
+      }
       await projectsApi
          .createProject(clientConfig.getOrganization(), project, {
             baseURL: controlPlane,
@@ -50,10 +58,13 @@ export async function createProject(
             console.log(jsonString);
             // Make the new project the default project.
             clientConfig.setProject(projectName);
+            if (replicationCount !== undefined) {
+               logger.info(`Replication count set to ${replicationCount}`);
+            }
          });
       logger.info("Project created successfully");
    } catch (e) {
       logger.error("Failed to create project");
       printOutError(e, debug);
    }
-}
+}

package/src/commands/project/deleteproject.spec.ts

@@ -0,0 +1,123 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { ProjectsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation } from "../../utils";
+import { deleteProject } from "./deleteproject";
+
+describe("delete-project", () => {
+   let sandbox: sinon.SinonSandbox;
+   let deleteProjectStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let getConfirmationStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      deleteProjectStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getAuthenticationHeader")
+         .returns("Bearer test-token");
+
+      sandbox
+         .stub(ProjectsApi.prototype, "deleteProject")
+         .callsFake(deleteProjectStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should delete project successfully", async () => {
+      deleteProjectStub.resolves({ status: 200 });
+      getConfirmationStub.resolves(true);
+
+      await deleteProject("http://test-server", "test-project", false, true);
+
+      expect(deleteProjectStub.calledOnce).to.be.true;
+      expect(deleteProjectStub.firstCall.args[0]).to.equal("test-org");
+      expect(deleteProjectStub.firstCall.args[1]).to.equal("test-project");
+      expect(deleteProjectStub.firstCall.args[2]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Project deleted successfully"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      deleteProjectStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(ProjectsApi.prototype, "deleteProject")
+         .callsFake(deleteProjectStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+
+      await deleteProject("http://test-server", "test-project", false, true);
+
+      expect(deleteProjectStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure that you are logged in"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should request confirmation when autoConfirm is false", async () => {
+      deleteProjectStub.resolves({ status: 200 });
+      getConfirmationStub.resolves(true);
+
+      await deleteProject("http://test-server", "test-project", false, false);
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(deleteProjectStub.calledOnce).to.be.true;
+   });
+
+   it("should cancel when confirmation is denied", async () => {
+      getConfirmationStub.resolves(false);
+
+      await deleteProject("http://test-server", "test-project", false, false);
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(deleteProjectStub.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");
+      deleteProjectStub.rejects(mockError);
+      getConfirmationStub.resolves(true);
+
+      await deleteProject("http://test-server", "test-project", true, true);
+
+      expect(deleteProjectStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to delete project")),
+      ).to.be.true;
+   });
+});

package/src/commands/project/getproject.spec.ts

@@ -0,0 +1,109 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { ProjectsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson } from "../../utils";
+import { getProject } from "./getproject";
+
+describe("get-project", () => {
+   let sandbox: sinon.SinonSandbox;
+   let getProjectStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      getProjectStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getHeaders")
+         .returns({ Authorization: "Bearer test-token" });
+
+      sandbox
+         .stub(ProjectsApi.prototype, "getProject")
+         .callsFake(getProjectStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should get project successfully", async () => {
+      const mockProjectData = {
+         name: "test-project",
+         replicationCount: 3,
+      };
+      const mockResponse = {
+         data: mockProjectData,
+      };
+      getProjectStub.resolves(mockResponse);
+
+      await getProject("http://test-server", "test-project", false);
+
+      expect(getProjectStub.calledOnce).to.be.true;
+      expect(getProjectStub.firstCall.args[0]).to.equal("test-org");
+      expect(getProjectStub.firstCall.args[1]).to.equal("test-project");
+      expect(getProjectStub.firstCall.args[2]).to.equal(false);
+      expect(getProjectStub.firstCall.args[3]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(consoleLogStub.calledWith(prettifyJson(mockProjectData))).to.be
+         .true;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      getProjectStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(ProjectsApi.prototype, "getProject")
+         .callsFake(getProjectStub);
+
+      await getProject("http://test-server", "test-project", false);
+
+      expect(getProjectStub.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 name", async () => {
+      await getProject("http://test-server", "", false);
+
+      expect(getProjectStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure to provide a project name"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      getProjectStub.rejects(mockError);
+
+      await getProject("http://test-server", "test-project", true);
+
+      expect(getProjectStub.calledOnce).to.be.true;
+      expect(loggerStub.error.calledWith(sinon.match("Failed to get project")))
+         .to.be.true;
+   });
+});