@credibledata/cred-cli 0.0.6

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

package/src/commands/group/creategroup.ts

@@ -0,0 +1,54 @@
+import { Group, GroupsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { printOutError } from "../../utils";
+
+const groupsApi = new GroupsApi(new Configuration());
+
+export async function createGroup(
+   controlPlane: string,
+   groupName: string,
+   debug: boolean,
+   description?: string,
+) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   const organizationName = clientConfig.getOrganization();
+   if (!organizationName) {
+      logger.error("No organization set. Please login or set an organization.");
+      return;
+   }
+
+   logger.info(
+      `Creating group ${groupName} in organization ${organizationName}`,
+   );
+
+   const group: Group = {
+      organizationName,
+      groupName,
+      description: description || `Group ${groupName}`,
+   };
+
+   try {
+      const response = await groupsApi.createGroup(organizationName, group, {
+         baseURL: controlPlane,
+         headers: {
+            Authorization: clientConfig.getAuthenticationHeader(),
+         },
+      });
+
+      const jsonString = JSON.stringify(response.data, null, 2);
+      console.log(jsonString);
+      logger.info("Group created successfully");
+   } catch (error) {
+      logger.error("Failed to create group");
+      printOutError(error, debug);
+      process.exit(1);
+   }
+}

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/deletegroup.ts

@@ -0,0 +1,45 @@
+import { GroupsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { printOutError } from "../../utils";
+
+const groupsApi = new GroupsApi(new Configuration());
+
+export async function deleteGroup(
+   controlPlane: string,
+   groupName: string,
+   debug: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   const organizationName = clientConfig.getOrganization();
+   if (!organizationName) {
+      logger.error("No organization set. Please login or set an organization.");
+      return;
+   }
+
+   logger.info(
+      `Deleting group ${groupName} from organization ${organizationName}`,
+   );
+
+   try {
+      await groupsApi.deleteGroup(organizationName, groupName, {
+         baseURL: controlPlane,
+         headers: {
+            Authorization: clientConfig.getAuthenticationHeader(),
+         },
+      });
+
+      logger.info("Group deleted successfully");
+   } catch (error) {
+      logger.error("Failed to delete group");
+      printOutError(error, debug);
+      process.exit(1);
+   }
+}

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/getgroup.ts

@@ -0,0 +1,47 @@
+import { GroupsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { printOutError } from "../../utils";
+
+const groupsApi = new GroupsApi(new Configuration());
+
+export async function getGroup(
+   controlPlane: string,
+   groupName: string,
+   debug: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   const organizationName = clientConfig.getOrganization();
+   if (!organizationName) {
+      logger.error("No organization set. Please login or set an organization.");
+      return;
+   }
+
+   logger.info(
+      `Getting group ${groupName} from organization ${organizationName}`,
+   );
+
+   try {
+      const response = await groupsApi.getGroup(organizationName, groupName, {
+         baseURL: controlPlane,
+         headers: {
+            Authorization: clientConfig.getAuthenticationHeader(),
+         },
+      });
+
+      const jsonString = JSON.stringify(response.data, null, 2);
+      console.log(jsonString);
+      logger.info("Group retrieved successfully");
+   } catch (error) {
+      logger.error("Failed to get group");
+      printOutError(error, debug);
+      process.exit(1);
+   }
+}

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