@credibledata/cred-cli 0.1.4 → 0.1.5

package/src/commands/connection/listconnections.spec.ts

@@ -0,0 +1,132 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { ConnectionsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson } from "../../utils";
+import { listConnections } from "./listconnections";
+
+describe("list-connections", () => {
+   let sandbox: sinon.SinonSandbox;
+   let listConnectionsStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      listConnectionsStub = 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(ConnectionsApi.prototype, "listConnections")
+         .callsFake(listConnectionsStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should list connections successfully", async () => {
+      const mockConnections = [
+         { name: "conn1", type: "postgres" },
+         { name: "conn2", type: "mysql" },
+      ];
+      const mockResponse = {
+         data: mockConnections,
+         headers: {},
+      };
+      listConnectionsStub.resolves(mockResponse);
+
+      await listConnections("http://test-server", false);
+
+      expect(listConnectionsStub.calledOnce).to.be.true;
+      expect(listConnectionsStub.firstCall.args[0]).to.equal("test-org");
+      expect(listConnectionsStub.firstCall.args[1]).to.equal("test-project");
+      expect(listConnectionsStub.firstCall.args[2]).to.equal(-1); // limit
+      expect(listConnectionsStub.firstCall.args[3]).to.equal(0); // offset
+      expect(listConnectionsStub.firstCall.args[4]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(consoleLogStub.calledOnce).to.be.true;
+      const loggedValue = consoleLogStub.firstCall.args[0];
+      const parsed = JSON.parse(loggedValue);
+      expect(parsed).to.have.property("connections");
+      expect(parsed.connections).to.deep.equal(mockConnections);
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listConnectionsStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(ConnectionsApi.prototype, "listConnections")
+         .callsFake(listConnectionsStub);
+
+      await listConnections("http://test-server", false);
+
+      expect(listConnectionsStub.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();
+      listConnectionsStub = 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(ConnectionsApi.prototype, "listConnections")
+         .callsFake(listConnectionsStub);
+
+      await listConnections("http://test-server", false);
+
+      expect(listConnectionsStub.called).to.be.false;
+      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");
+      listConnectionsStub.rejects(mockError);
+
+      await listConnections("http://test-server", true);
+
+      expect(listConnectionsStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to list connections")),
+      ).to.be.true;
+   });
+});

package/src/commands/connection/listconnections.ts

@@ -2,11 +2,21 @@ import { ConnectionsApi } 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 connectionsApi = new ConnectionsApi(new Configuration());
 
-export const listConnections = async (controlPlane: string, debug: boolean) => {
+export const listConnections = async (
+   controlPlane: string,
+   debug: boolean,
+   page?: string | number,
+   pageSize?: string | number,
+) => {
    const clientConfig = new ClientConfiguration();
    const organizationName = clientConfig.getOrganization();
    const projectName = clientConfig.getProject();
@@ -22,16 +32,25 @@ export const listConnections = async (controlPlane: string, debug: boolean) => {
    }
 
    try {
+      const { limit, offset } = parsePaginationParams(page, pageSize);
       const response = await connectionsApi.listConnections(
          organizationName,
          projectName,
+         limit,
+         offset,
          {
             baseURL: controlPlane,
             headers: clientConfig.getHeaders(),
          },
       );
+      const totalCount = extractTotalCount(response.headers);
 
-      console.log(prettifyJson(response.data));
+      const payload = {
+         connections: response.data,
+         totalCount,
+      };
+
+      console.log(prettifyJson(payload));
    } catch (e) {
       logger.error("Failed to list connections");
       printOutError(e, debug);

package/src/commands/group/addmember.spec.ts

@@ -0,0 +1,257 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { addMember } from "./addmember";
+
+describe("add-member", () => {
+   let sandbox: sinon.SinonSandbox;
+   let addGroupMembersStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      addGroupMembersStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      processExitStub = sandbox.stub(process, "exit");
+
+      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(GroupsApi.prototype, "addGroupMembers")
+         .callsFake(addGroupMembersStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should add user member successfully", async () => {
+      const mockResponse = {
+         data: {},
+      };
+      addGroupMembersStub.resolves(mockResponse);
+
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         "admin",
+         false,
+      );
+
+      expect(addGroupMembersStub.calledOnce).to.be.true;
+      expect(addGroupMembersStub.firstCall.args[0]).to.equal("test-org");
+      expect(addGroupMembersStub.firstCall.args[1]).to.equal("test-group");
+      expect(addGroupMembersStub.firstCall.args[2]).to.deep.include({
+         members: [
+            {
+               userGroupId: "user:test-user",
+               status: "admin",
+            },
+         ],
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match(
+               "Successfully added user test-user to group test-group with role admin",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should add group member successfully", async () => {
+      const mockResponse = {
+         data: {},
+      };
+      addGroupMembersStub.resolves(mockResponse);
+
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "group",
+         "test-subgroup",
+         "member",
+         false,
+      );
+
+      expect(addGroupMembersStub.firstCall.args[2]).to.deep.include({
+         members: [
+            {
+               userGroupId: "group:test-subgroup",
+               status: "member",
+            },
+         ],
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match(
+               "Successfully added group test-subgroup to group test-group with role member",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle case-insensitive member type", async () => {
+      const mockResponse = {
+         data: {},
+      };
+      addGroupMembersStub.resolves(mockResponse);
+
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "USER",
+         "test-user",
+         "admin",
+         false,
+      );
+
+      expect(
+         addGroupMembersStub.firstCall.args[2].members[0].userGroupId,
+      ).to.equal("user:test-user");
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      addGroupMembersStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(GroupsApi.prototype, "addGroupMembers")
+         .callsFake(addGroupMembersStub);
+
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         "admin",
+         false,
+      );
+
+      expect(addGroupMembersStub.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 organization", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      addGroupMembersStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns(undefined);
+      sandbox
+         .stub(GroupsApi.prototype, "addGroupMembers")
+         .callsFake(addGroupMembersStub);
+
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         "admin",
+         false,
+      );
+
+      expect(addGroupMembersStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(
+               "No organization set. Please login or set an organization.",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should reject invalid member type", async () => {
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "invalid",
+         "test-user",
+         "admin",
+         false,
+      );
+
+      expect(addGroupMembersStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(
+               (value: string) =>
+                  typeof value === "string" &&
+                  value.includes("memberType") &&
+                  value.includes("must be either 'user' or 'group'"),
+            ),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+
+   it("should reject invalid role", async () => {
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         "invalid-role",
+         false,
+      );
+
+      expect(addGroupMembersStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(/role must be either 'admin' or 'member'/),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      addGroupMembersStub.rejects(mockError);
+
+      await addMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         "admin",
+         true,
+      );
+
+      expect(addGroupMembersStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Failed to add member to group"),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+});

package/src/commands/group/addmember.ts

@@ -47,12 +47,14 @@ export async function addMember(
          `Error: memberType ${memberType} must be either 'user' or 'group'`,
       );
       process.exit(1);
+      return;
    }
 
    // Validate role
    if (role !== "admin" && role !== "member") {
       logger.error("Error: role must be either 'admin' or 'member'");
       process.exit(1);
+      return;
    }
 
    const groupMember: GroupMember = {

package/src/commands/group/creategroup.spec.ts

@@ -0,0 +1,146 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { createGroup } from "./creategroup";
+
+describe("create-group", () => {
+   let sandbox: sinon.SinonSandbox;
+   let createGroupStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      createGroupStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      processExitStub = sandbox.stub(process, "exit");
+
+      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(GroupsApi.prototype, "createGroup")
+         .callsFake(createGroupStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should create group successfully", async () => {
+      const mockResponse = {
+         data: { groupName: "test-group", organizationName: "test-org" },
+      };
+      createGroupStub.resolves(mockResponse);
+
+      await createGroup("http://test-server", "test-group", false);
+
+      expect(createGroupStub.calledOnce).to.be.true;
+      expect(createGroupStub.firstCall.args[0]).to.equal("test-org");
+      expect(createGroupStub.firstCall.args[1]).to.deep.include({
+         organizationName: "test-org",
+         groupName: "test-group",
+         description: "Group test-group",
+      });
+      expect(consoleLogStub.called).to.be.true;
+      expect(
+         loggerStub.info.calledWith(sinon.match("Group created successfully")),
+      ).to.be.true;
+   });
+
+   it("should create group with custom description", async () => {
+      const mockResponse = {
+         data: { groupName: "test-group" },
+      };
+      createGroupStub.resolves(mockResponse);
+
+      await createGroup(
+         "http://test-server",
+         "test-group",
+         false,
+         "Custom description",
+      );
+
+      expect(createGroupStub.firstCall.args[1]).to.deep.include({
+         description: "Custom description",
+      });
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      createGroupStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(GroupsApi.prototype, "createGroup")
+         .callsFake(createGroupStub);
+
+      await createGroup("http://test-server", "test-group", false);
+
+      expect(createGroupStub.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 organization", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      createGroupStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns(undefined);
+      sandbox
+         .stub(GroupsApi.prototype, "createGroup")
+         .callsFake(createGroupStub);
+
+      await createGroup("http://test-server", "test-group", false);
+
+      expect(createGroupStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(
+               "No organization set. Please login or set an organization.",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      createGroupStub.rejects(mockError);
+
+      await createGroup("http://test-server", "test-group", true);
+
+      expect(createGroupStub.calledOnce).to.be.true;
+      expect(loggerStub.error.calledWith(sinon.match("Failed to create group")))
+         .to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+});