@credibledata/cred-cli 0.1.3 → 0.1.5

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

@@ -0,0 +1,121 @@
+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 { listProjects, printOutProjects } from "./listprojects";
+
+describe("list-projects", () => {
+   let sandbox: sinon.SinonSandbox;
+   let listProjectsStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      listProjectsStub = 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, "listProjects")
+         .callsFake(listProjectsStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should list projects successfully", async () => {
+      const mockProjects = [
+         { name: "project1", replicationCount: 2 },
+         { name: "project2", replicationCount: 3 },
+      ];
+      const mockResponse = {
+         data: mockProjects,
+         headers: {},
+      };
+      listProjectsStub.resolves(mockResponse);
+
+      const result = await listProjects("http://test-server", false);
+
+      expect(listProjectsStub.calledOnce).to.be.true;
+      expect(listProjectsStub.firstCall.args[0]).to.equal("test-org");
+      expect(listProjectsStub.firstCall.args[1]).to.equal(-1); // limit
+      expect(listProjectsStub.firstCall.args[2]).to.equal(0); // offset
+      expect(listProjectsStub.firstCall.args[3]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(result).to.deep.equal({
+         projects: mockProjects,
+         totalCount: undefined,
+      });
+   });
+
+   it("should return empty array when config doesn't exist", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listProjectsStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(ProjectsApi.prototype, "listProjects")
+         .callsFake(listProjectsStub);
+
+      const result = await listProjects("http://test-server", false);
+
+      expect(listProjectsStub.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 return empty array on API error", async () => {
+      const mockError = new Error("API Error");
+      listProjectsStub.rejects(mockError);
+
+      const result = await listProjects("http://test-server", true);
+
+      expect(listProjectsStub.calledOnce).to.be.true;
+      expect(result).to.be.undefined;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to list projects")),
+      ).to.be.true;
+   });
+
+   it("should print projects when using printOutProjects", async () => {
+      const mockProjects = [{ name: "project1" }];
+      const mockResponse = {
+         data: mockProjects,
+         headers: {},
+      };
+      listProjectsStub.resolves(mockResponse);
+
+      await printOutProjects("http://test-server", false);
+
+      expect(consoleLogStub.calledOnce).to.be.true;
+      const loggedValue = consoleLogStub.firstCall.args[0];
+      const parsed = JSON.parse(loggedValue);
+      expect(parsed).to.have.property("projects");
+      expect(parsed.projects).to.deep.equal(mockProjects);
+   });
+});

package/src/commands/project/listprojects.ts

@@ -2,35 +2,61 @@ import { ProjectsApi } 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 projectsApi = new ProjectsApi(new Configuration());
 
-export async function listProjects(controlPlane: string, debug: boolean) {
+export async function listProjects(
+   controlPlane: string,
+   debug: boolean,
+   page?: string | number,
+   pageSize?: string | number,
+) {
    const clientConfig = new ClientConfiguration();
 
    if (!clientConfig.doesConfigExists()) {
       logger.error("Please, make sure that you are logged in");
-      return [];
+      return;
    }
 
    try {
+      const { limit, offset } = parsePaginationParams(page, pageSize);
+
       const response = await projectsApi.listProjects(
          clientConfig.getOrganization(),
+         limit,
+         offset,
          {
             baseURL: controlPlane,
             headers: clientConfig.getHeaders(),
          },
       );
 
-      return response.data;
+      const totalCount = extractTotalCount(response.headers);
+
+      return {
+         projects: response.data,
+         totalCount,
+      };
    } catch (e) {
       logger.error("Failed to list projects");
       printOutError(e, debug);
-      return [];
+      return;
    }
 }
 
-export async function printOutProjects(controlPlane: string, debug: boolean) {
-   console.log(prettifyJson(await listProjects(controlPlane, debug)));
+export async function printOutProjects(
+   controlPlane: string,
+   debug: boolean,
+   page?: string | number,
+   pageSize?: string | number,
+) {
+   const projects = await listProjects(controlPlane, debug, page, pageSize);
+
+   console.log(prettifyJson(projects));
 }

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

@@ -0,0 +1,63 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { setProject } from "./setproject";
+
+describe("set-project", () => {
+   let sandbox: sinon.SinonSandbox;
+   let setProjectStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      setProjectStub = sandbox.stub(
+         ClientConfiguration.prototype,
+         "setProject",
+      );
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should set project successfully", async () => {
+      await setProject("test-project");
+
+      expect(setProjectStub.calledOnce).to.be.true;
+      expect(setProjectStub.firstCall.args[0]).to.equal("test-project");
+      expect(consoleLogStub.calledWith("Setting project test-project")).to.be
+         .true;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      setProjectStub = sandbox.stub(
+         ClientConfiguration.prototype,
+         "setProject",
+      );
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+
+      await setProject("test-project");
+
+      expect(setProjectStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure that you are logged in"),
+         ),
+      ).to.be.true;
+   });
+});

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

@@ -0,0 +1,217 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { ProjectsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { updateProject } from "./updateproject";
+
+describe("update-project", () => {
+   let sandbox: sinon.SinonSandbox;
+   let updateProjectStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      updateProjectStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+
+      // Mock ClientConfiguration constructor
+      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" });
+
+      // Mock ProjectsApi constructor and method
+      sandbox
+         .stub(ProjectsApi.prototype, "updateProject")
+         .callsFake(updateProjectStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   describe("updateProject", () => {
+      it("should update project successfully", async () => {
+         const mockResponse = { status: 200 };
+         updateProjectStub.resolves(mockResponse);
+
+         await updateProject(
+            "http://test-server",
+            "test-project",
+            { replicationCount: 3 },
+            false,
+            true,
+         );
+
+         expect(updateProjectStub.calledOnce).to.be.true;
+         expect(updateProjectStub.firstCall.args[0]).to.equal("test-org");
+         expect(updateProjectStub.firstCall.args[1]).to.equal("test-project");
+         expect(updateProjectStub.firstCall.args[2]).to.include({
+            replicationCount: 3,
+         });
+         expect(updateProjectStub.firstCall.args[3]).to.deep.include({
+            baseURL: "http://test-server",
+            headers: { Authorization: "Bearer test-token" },
+         });
+         expect(
+            loggerStub.info.calledWith(
+               sinon.match("Successfully updated project test-project"),
+            ),
+         ).to.be.true;
+      });
+
+      it("should handle missing project name", async () => {
+         await updateProject(
+            "http://test-server",
+            "",
+            { replicationCount: 3 },
+            false,
+            true,
+         );
+
+         expect(updateProjectStub.called).to.be.false;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match("Please provide a project name"),
+            ),
+         ).to.be.true;
+      });
+
+      it("should handle API errors", async () => {
+         const mockError = new Error("API Error");
+         updateProjectStub.rejects(mockError);
+
+         await updateProject(
+            "http://test-server",
+            "test-project",
+            { replicationCount: 3 },
+            true,
+            true,
+         );
+
+         expect(updateProjectStub.calledOnce).to.be.true;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match("Failed to update project test-project"),
+            ),
+         ).to.be.true;
+      });
+
+      it("should handle non-200 response status", async () => {
+         const mockResponse = { status: 400 };
+         updateProjectStub.resolves(mockResponse);
+
+         await updateProject(
+            "http://test-server",
+            "test-project",
+            { replicationCount: 3 },
+            false,
+            true,
+         );
+
+         expect(updateProjectStub.calledOnce).to.be.true;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match("Failed to update project. Status: 400"),
+            ),
+         ).to.be.true;
+      });
+   });
+
+   describe("validators", () => {
+      describe("authentication validation", () => {
+         it("should fail when user is not logged in", async () => {
+            sandbox.restore();
+            sandbox = sinon.createSandbox();
+            updateProjectStub = sandbox.stub();
+            loggerStub = sandbox.stub(logger);
+
+            sandbox
+               .stub(ClientConfiguration.prototype, "doesConfigExists")
+               .returns(false);
+            sandbox
+               .stub(ProjectsApi.prototype, "updateProject")
+               .callsFake(updateProjectStub);
+
+            await updateProject(
+               "http://test-server",
+               "test-project",
+               { replicationCount: 3 },
+               false,
+               true,
+            );
+
+            expect(updateProjectStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Please, make sure that you are logged in"),
+               ),
+            ).to.be.true;
+         });
+      });
+
+      describe("replication count validation", () => {
+         it("should accept valid replication counts", async () => {
+            const mockResponse = { status: 200 };
+            updateProjectStub.resolves(mockResponse);
+
+            const validCounts = [1, 2, 5, 10, 100];
+
+            for (const count of validCounts) {
+               await updateProject(
+                  "http://test-server",
+                  "test-project",
+                  { replicationCount: count },
+                  false,
+                  true,
+               );
+               expect(updateProjectStub.called).to.be.true;
+               expect(updateProjectStub.firstCall.args[2]).to.include({
+                  replicationCount: count,
+               });
+               updateProjectStub.reset();
+            }
+         });
+
+         it("should reject replication count less than 1", async () => {
+            await updateProject(
+               "http://test-server",
+               "test-project",
+               { replicationCount: 0 },
+               false,
+               true,
+            );
+
+            expect(updateProjectStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Replication count must be at least 1"),
+               ),
+            ).to.be.true;
+         });
+
+         it("should reject negative replication count", async () => {
+            await updateProject(
+               "http://test-server",
+               "test-project",
+               { replicationCount: -1 },
+               false,
+               true,
+            );
+
+            expect(updateProjectStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Replication count must be at least 1"),
+               ),
+            ).to.be.true;
+         });
+      });
+   });
+});

package/src/commands/project/updateproject.ts

@@ -0,0 +1,82 @@
+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());
+
+type UpdateProjectProperties = {
+   replicationCount?: number;
+};
+
+export async function updateProject(
+   controlPlane: string,
+   projectName: string,
+   properties: UpdateProjectProperties,
+   debug?: boolean,
+   skipConfirmation?: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   if (!projectName) {
+      logger.error("Please provide a project name");
+      return;
+   }
+
+   const organizationName = clientConfig.getOrganization();
+
+   if (
+      properties.replicationCount !== undefined &&
+      properties.replicationCount < 1
+   ) {
+      logger.error("Replication count must be at least 1");
+      return;
+   }
+
+   try {
+      if (!skipConfirmation) {
+         const confirmation = await getConfirmation(
+            `Are you sure you want to update project ${projectName}?`,
+         );
+         if (!confirmation) {
+            logger.info("Operation cancelled.");
+            return;
+         }
+      }
+
+      const projectUpdate: Project = {};
+
+      if (properties.replicationCount !== undefined) {
+         projectUpdate.replicationCount = properties.replicationCount;
+      }
+
+      const response = await projectsApi.updateProject(
+         organizationName,
+         projectName,
+         projectUpdate,
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      if (response.status === 200) {
+         logger.info(`Successfully updated project ${projectName}`);
+         if (properties.replicationCount !== undefined) {
+            logger.info(
+               `Replication count set to ${properties.replicationCount}`,
+            );
+         }
+      } else {
+         logger.error(`Failed to update project. Status: ${response.status}`);
+      }
+   } catch (e) {
+      logger.error(`Failed to update project ${projectName}`);
+      printOutError(e, debug);
+   }
+}

package/src/commands/rm.ts

@@ -84,13 +84,9 @@ export const registerRmCommands = (cli: Command, environment: Environment) => {
          );
       });
 
-
    rm.command("group-access-token")
       .description("Delete an access token from a group.")
-      .argument(
-         "<groupName>",
-         "The name of the group",
-      )
+      .argument("<groupName>", "The name of the group")
       .argument("<tokenName>", "The name of the token to delete")
       .option("--debug")
       .option("-y, --yes", "Skip confirmation.")
@@ -102,5 +98,4 @@ export const registerRmCommands = (cli: Command, environment: Environment) => {
             options.debug || false,
          );
       });
-
 };

package/src/commands/update.ts

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { controlPlanesByEnv, Environment } from "../constants";
 import { updatePackage } from "./package/updatepackage";
+import { updateProject } from "./project/updateproject";
 
 export const registerUpdateCommands = (
    cli: Command,
@@ -11,6 +12,29 @@ export const registerUpdateCommands = (
       .description("Update a resource")
       .argument("<resource>", "The resource to update");
 
+   update
+      .command("project")
+      .description("Update a project.")
+      .argument("<projectName>", "The name of the project to update.")
+      .option(
+         "--replication <replicationCount>",
+         "The new replication count (must be at least 1).",
+         parseInt,
+      )
+      .option("--debug")
+      .option("-y, --yes", "Skip confirmation.")
+      .action((projectName, options) => {
+         updateProject(
+            controlPlanesByEnv[environment],
+            projectName,
+            {
+               replicationCount: options.replication,
+            },
+            options.debug,
+            options.yes,
+         );
+      });
+
    update
       .command("package")
       .description("Update a package.")
@@ -37,5 +61,4 @@ export const registerUpdateCommands = (
             options.yes,
          );
       });
-
 };