@credibledata/cred-cli 0.1.4 → 0.1.5

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

@@ -0,0 +1,120 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { deleteGroup } from "./deletegroup";
+
+describe("delete-group", () => {
+   let sandbox: sinon.SinonSandbox;
+   let deleteGroupStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      deleteGroupStub = 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, "deleteGroup")
+         .callsFake(deleteGroupStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should delete group successfully", async () => {
+      deleteGroupStub.resolves({ status: 200 });
+
+      await deleteGroup("http://test-server", "test-group", false);
+
+      expect(deleteGroupStub.calledOnce).to.be.true;
+      expect(deleteGroupStub.firstCall.args[0]).to.equal("test-org");
+      expect(deleteGroupStub.firstCall.args[1]).to.equal("test-group");
+      expect(deleteGroupStub.firstCall.args[2]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(
+         loggerStub.info.calledWith(sinon.match("Group deleted successfully")),
+      ).to.be.true;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      deleteGroupStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(GroupsApi.prototype, "deleteGroup")
+         .callsFake(deleteGroupStub);
+
+      await deleteGroup("http://test-server", "test-group", false);
+
+      expect(deleteGroupStub.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();
+      deleteGroupStub = 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, "deleteGroup")
+         .callsFake(deleteGroupStub);
+
+      await deleteGroup("http://test-server", "test-group", false);
+
+      expect(deleteGroupStub.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");
+      deleteGroupStub.rejects(mockError);
+
+      await deleteGroup("http://test-server", "test-group", true);
+
+      expect(deleteGroupStub.calledOnce).to.be.true;
+      expect(loggerStub.error.calledWith(sinon.match("Failed to delete group")))
+         .to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+});

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

@@ -0,0 +1,129 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getGroup } from "./getgroup";
+
+describe("get-group", () => {
+   let sandbox: sinon.SinonSandbox;
+   let getGroupStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      getGroupStub = 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, "getGroup").callsFake(getGroupStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should get group successfully", async () => {
+      const mockGroupData = {
+         groupName: "test-group",
+         organizationName: "test-org",
+         description: "Test group",
+      };
+      const mockResponse = {
+         data: mockGroupData,
+      };
+      getGroupStub.resolves(mockResponse);
+
+      await getGroup("http://test-server", "test-group", false);
+
+      expect(getGroupStub.calledOnce).to.be.true;
+      expect(getGroupStub.firstCall.args[0]).to.equal("test-org");
+      expect(getGroupStub.firstCall.args[1]).to.equal("test-group");
+      expect(getGroupStub.firstCall.args[2]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(consoleLogStub.called).to.be.true;
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Group retrieved successfully"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      getGroupStub = 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, "getGroup").callsFake(getGroupStub);
+
+      await getGroup("http://test-server", "test-group", false);
+
+      expect(getGroupStub.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();
+      getGroupStub = 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, "getGroup").callsFake(getGroupStub);
+
+      await getGroup("http://test-server", "test-group", false);
+
+      expect(getGroupStub.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");
+      getGroupStub.rejects(mockError);
+
+      await getGroup("http://test-server", "test-group", true);
+
+      expect(getGroupStub.calledOnce).to.be.true;
+      expect(loggerStub.error.calledWith(sinon.match("Failed to get group"))).to
+         .be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+});

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

@@ -0,0 +1,137 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { listGroups, printOutGroups } from "./listgroups";
+
+describe("list-groups", () => {
+   let sandbox: sinon.SinonSandbox;
+   let listGroupsStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      listGroupsStub = 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, "listGroups").callsFake(listGroupsStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should list groups successfully", async () => {
+      const mockGroups = [
+         { groupName: "group1", organizationName: "test-org" },
+         { groupName: "group2", organizationName: "test-org" },
+      ];
+      const mockResponse = {
+         data: mockGroups,
+      };
+      listGroupsStub.resolves(mockResponse);
+
+      await listGroups("http://test-server", false);
+
+      expect(listGroupsStub.calledOnce).to.be.true;
+      expect(listGroupsStub.firstCall.args[0]).to.equal("test-org");
+      expect(listGroupsStub.firstCall.args[1]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(consoleLogStub.called).to.be.true;
+      expect(
+         loggerStub.info.calledWith(sinon.match("Groups listed successfully")),
+      ).to.be.true;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      listGroupsStub = 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, "listGroups").callsFake(listGroupsStub);
+
+      await listGroups("http://test-server", false);
+
+      expect(listGroupsStub.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();
+      listGroupsStub = 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, "listGroups").callsFake(listGroupsStub);
+
+      await listGroups("http://test-server", false);
+
+      expect(listGroupsStub.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");
+      listGroupsStub.rejects(mockError);
+
+      await listGroups("http://test-server", true);
+
+      expect(listGroupsStub.calledOnce).to.be.true;
+      expect(loggerStub.error.calledWith(sinon.match("Failed to list groups")))
+         .to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+
+   it("should work with printOutGroups", async () => {
+      const mockGroups = [{ groupName: "group1" }];
+      const mockResponse = {
+         data: mockGroups,
+      };
+      listGroupsStub.resolves(mockResponse);
+
+      await printOutGroups("http://test-server", false);
+
+      expect(listGroupsStub.calledOnce).to.be.true;
+   });
+});

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

@@ -0,0 +1,224 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { removeMember } from "./removemember";
+
+describe("remove-member", () => {
+   let sandbox: sinon.SinonSandbox;
+   let removeGroupMembersStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      removeGroupMembersStub = 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, "removeGroupMembers")
+         .callsFake(removeGroupMembersStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should remove user member successfully", async () => {
+      const mockResponse = {
+         data: {},
+      };
+      removeGroupMembersStub.resolves(mockResponse);
+
+      await removeMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         false,
+      );
+
+      expect(removeGroupMembersStub.calledOnce).to.be.true;
+      expect(removeGroupMembersStub.firstCall.args[0]).to.equal("test-org");
+      expect(removeGroupMembersStub.firstCall.args[1]).to.equal("test-group");
+      expect(removeGroupMembersStub.firstCall.args[2]).to.deep.include({
+         members: [
+            {
+               userGroupId: "user:test-user",
+            },
+         ],
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match(
+               "Successfully removed user test-user from group test-group",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should remove group member successfully", async () => {
+      const mockResponse = {
+         data: {},
+      };
+      removeGroupMembersStub.resolves(mockResponse);
+
+      await removeMember(
+         "http://test-server",
+         "test-group",
+         "group",
+         "test-subgroup",
+         false,
+      );
+
+      expect(removeGroupMembersStub.firstCall.args[2]).to.deep.include({
+         members: [
+            {
+               userGroupId: "group:test-subgroup",
+            },
+         ],
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match(
+               "Successfully removed group test-subgroup from group test-group",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle case-insensitive member type", async () => {
+      const mockResponse = {
+         data: {},
+      };
+      removeGroupMembersStub.resolves(mockResponse);
+
+      await removeMember(
+         "http://test-server",
+         "test-group",
+         "USER",
+         "test-user",
+         false,
+      );
+
+      expect(
+         removeGroupMembersStub.firstCall.args[2].members[0].userGroupId,
+      ).to.equal("user:test-user");
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      removeGroupMembersStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(GroupsApi.prototype, "removeGroupMembers")
+         .callsFake(removeGroupMembersStub);
+
+      await removeMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         false,
+      );
+
+      expect(removeGroupMembersStub.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();
+      removeGroupMembersStub = 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, "removeGroupMembers")
+         .callsFake(removeGroupMembersStub);
+
+      await removeMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         false,
+      );
+
+      expect(removeGroupMembersStub.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 removeMember(
+         "http://test-server",
+         "test-group",
+         "invalid",
+         "test-user",
+         false,
+      );
+
+      expect(removeGroupMembersStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Error: memberType must be either 'user' or 'group'"),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      removeGroupMembersStub.rejects(mockError);
+
+      await removeMember(
+         "http://test-server",
+         "test-group",
+         "user",
+         "test-user",
+         true,
+      );
+
+      expect(removeGroupMembersStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Failed to remove member from group"),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+});

package/src/commands/group/removemember.ts

@@ -44,6 +44,7 @@ export async function removeMember(
    } else {
       logger.error("Error: memberType must be either 'user' or 'group'");
       process.exit(1);
+      return;
    }
 
    const groupMember: GroupMember = {