@credibledata/cred-cli 0.0.6

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

@@ -0,0 +1,70 @@
+import fs from "fs";
+import { Project, ProjectsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation, printOutError } from "../../utils";
+
+const projectsApi = new ProjectsApi(new Configuration());
+
+export async function createProject(
+   controlPlane: string,
+   projectName: string,
+   readmeFile: string,
+   replicationCount: number | undefined,
+   debug: boolean,
+   autoConfirm: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      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}?`,
+      );
+      if (!confirmation) {
+         logger.info("Operation cancelled.");
+         return;
+      }
+   }
+   logger.info("Creating project " + projectName);
+
+   let readmeContents = "";
+   if (readmeFile) {
+      readmeContents = fs.readFileSync(readmeFile).toString();
+   }
+
+   try {
+      const project: Project = { name: projectName, readme: readmeContents };
+      if (replicationCount !== undefined) {
+         project.replicationCount = replicationCount;
+      }
+      await projectsApi
+         .createProject(clientConfig.getOrganization(), project, {
+            baseURL: controlPlane,
+            headers: {
+               Authorization: clientConfig.getAuthenticationHeader(),
+            },
+         })
+         .then((response) => {
+            const jsonString = JSON.stringify(response.data, null, 2);
+            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/deleteproject.ts

@@ -0,0 +1,48 @@
+import { ProjectsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation, printOutError } from "../../utils";
+
+const projectsApi = new ProjectsApi(new Configuration());
+
+export async function deleteProject(
+   controlPlane: string,
+   projectName: string,
+   debug: boolean,
+   autoConfirm: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+   if (!autoConfirm) {
+      const confirmation = await getConfirmation(
+         `Are you sure you that want to delete the ${projectName} project? This action cannot be undone.`,
+      );
+      if (!confirmation) {
+         logger.info("Operation cancelled.");
+         return;
+      }
+   }
+   logger.info("Deleting project " + projectName);
+
+   try {
+      await projectsApi.deleteProject(
+         clientConfig.getOrganization(),
+         projectName,
+         {
+            baseURL: controlPlane,
+            headers: {
+               Authorization: clientConfig.getAuthenticationHeader(),
+            },
+         },
+      );
+      logger.info("Project deleted successfully");
+   } catch (e) {
+      logger.error("Failed to delete project");
+      printOutError(e, debug);
+   }
+}

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;
+   });
+});

package/src/commands/project/getproject.ts

@@ -0,0 +1,43 @@
+import { ProjectsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson, printOutError } from "../../utils";
+
+const projectsApi = new ProjectsApi(new Configuration());
+
+export async function getProject(
+   controlPlane: string,
+   projectName: string,
+   debug: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+   const organizationName = clientConfig.getOrganization();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   if (!projectName) {
+      logger.error("Please, make sure to provide a project name");
+      return;
+   }
+
+   try {
+      const response = await projectsApi.getProject(
+         organizationName,
+         projectName,
+         false,
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      console.log(prettifyJson(response.data));
+   } catch (e) {
+      logger.error("Failed to get project");
+      printOutError(e, debug);
+   }
+}