@credibledata/cred-cli 0.1.4 → 0.1.5

package/src/commands/groupaccesstoken/createToken.spec.ts

@@ -0,0 +1,211 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { createGroupAccessToken } from "./createToken";
+
+describe("create-group-access-token", () => {
+   let sandbox: sinon.SinonSandbox;
+   let createGroupAccessTokenStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      createGroupAccessTokenStub = 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, "createGroupAccessToken")
+         .callsFake(createGroupAccessTokenStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should create group access token successfully", async () => {
+      const mockResponse = {
+         data: { tokenName: "test-token", secret: "secret-value" },
+      };
+      createGroupAccessTokenStub.resolves(mockResponse);
+
+      const result = await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         undefined,
+         false,
+         false,
+      );
+
+      expect(createGroupAccessTokenStub.calledOnce).to.be.true;
+      expect(createGroupAccessTokenStub.firstCall.args[0]).to.equal("test-org");
+      expect(createGroupAccessTokenStub.firstCall.args[1]).to.equal(
+         "test-group",
+      );
+      expect(createGroupAccessTokenStub.firstCall.args[2]).to.equal(
+         "test-token",
+      );
+      expect(createGroupAccessTokenStub.firstCall.args[3]).to.be.undefined;
+      expect(consoleLogStub.called).to.be.true;
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Group access token created successfully"),
+         ),
+      ).to.be.true;
+      expect(result).to.deep.equal(mockResponse.data);
+   });
+
+   it("should create token with expiration date", async () => {
+      const futureDate = new Date();
+      futureDate.setFullYear(futureDate.getFullYear() + 1);
+      const expiresAt = futureDate.toISOString();
+      const mockResponse = {
+         data: { tokenName: "test-token" },
+      };
+      createGroupAccessTokenStub.resolves(mockResponse);
+
+      await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         expiresAt,
+         false,
+         false,
+      );
+
+      expect(createGroupAccessTokenStub.firstCall.args[3]).to.equal(expiresAt);
+   });
+
+   it("should reject invalid expiration date format", async () => {
+      await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         "invalid-date",
+         false,
+         false,
+      );
+
+      expect(createGroupAccessTokenStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(/Invalid expiration date format/),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+
+   it("should reject expiration date in the past", async () => {
+      const pastDate = new Date();
+      pastDate.setFullYear(pastDate.getFullYear() - 1);
+      const expiresAt = pastDate.toISOString();
+
+      await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         expiresAt,
+         false,
+         false,
+      );
+
+      expect(createGroupAccessTokenStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Expiration date must be in the future"),
+         ),
+      ).to.be.true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+
+   it("should return JSON output when jsonOutput is true", async () => {
+      const mockResponse = {
+         data: { tokenName: "test-token", secret: "secret-value" },
+      };
+      createGroupAccessTokenStub.resolves(mockResponse);
+
+      const result = await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         undefined,
+         true,
+         false,
+      );
+
+      expect(result).to.deep.equal(mockResponse.data);
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match("Group access token created successfully"),
+         ),
+      ).to.be.false;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      createGroupAccessTokenStub = 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, "createGroupAccessToken")
+         .callsFake(createGroupAccessTokenStub);
+
+      const result = await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         undefined,
+         false,
+         false,
+      );
+
+      expect(createGroupAccessTokenStub.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 handle API errors", async () => {
+      const mockError = new Error("API Error");
+      createGroupAccessTokenStub.rejects(mockError);
+
+      await createGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         undefined,
+         false,
+         true,
+      );
+
+      expect(createGroupAccessTokenStub.calledOnce).to.be.true;
+      expect(loggerStub.error.calledWith(sinon.match("Operation failed"))).to.be
+         .true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+});

package/src/commands/groupaccesstoken/createToken.ts

@@ -3,66 +3,70 @@ import { logger } from "../../logger";
 import { withGroupContext } from "./groupContainer";
 
 export async function createGroupAccessToken(
-    controlPlane: string,
-    groupName: string,
-    tokenName: string,
-    expiresAt: string | undefined,
-    debug: boolean,
+   controlPlane: string,
+   groupName: string,
+   tokenName: string,
+   expiresAt: string | undefined,
+   jsonOutput: boolean,
+   debug: boolean,
 ) {
-    // Validate expiresAt format if provided
-    if (expiresAt) {
-        const expiresAtDate = new Date(expiresAt);
-        if (isNaN(expiresAtDate.getTime())) {
-            logger.error(
-                `Invalid expiration date format: ${expiresAt}. Please use ISO 8601 format (e.g., 2025-12-31T23:59:59Z)`,
-            );
-            process.exit(1);
-        }
-        if (expiresAtDate <= new Date()) {
-            logger.error(
-                "Expiration date must be in the future",
-            );
-            process.exit(1);
-        }
-    }
+   // Validate expiresAt format if provided
+   if (expiresAt) {
+      const expiresAtDate = new Date(expiresAt);
+      if (isNaN(expiresAtDate.getTime())) {
+         logger.error(
+            `Invalid expiration date format: ${expiresAt}. Please use ISO 8601 format (e.g., 2025-12-31T23:59:59Z)`,
+         );
+         process.exit(1);
+         return;
+      }
+      if (expiresAtDate <= new Date()) {
+         logger.error("Expiration date must be in the future");
+         process.exit(1);
+         return;
+      }
+   }
 
-    const result = await withGroupContext(controlPlane, async (context) => {
-        const { organizationName, groupsApi, options } = context;
+   const result = await withGroupContext(
+      controlPlane,
+      async (context) => {
+         const { organizationName, groupsApi, options } = context;
 
-        logger.info(
-            `Creating access token ${tokenName} for group ${groupName} in organization ${organizationName}${expiresAt ? ` (expires: ${expiresAt})` : ""}`,
-        );
-
-        const response = await groupsApi.createGroupAccessToken(
+         const response = await groupsApi.createGroupAccessToken(
             organizationName,
             groupName,
             tokenName,
             expiresAt,
             options,
-        );
+         );
+
+         return response.data;
+      },
+      undefined,
+      debug,
+   );
 
-        return response.data;
-    }, undefined, debug);
+   if (jsonOutput) {
+      return result;
+   }
 
-    // Display security warning after the response is printed
-    console.log("\n" + kleur.yellow().bold("⚠️  IMPORTANT SECURITY NOTICE ⚠️"));
-    console.log(
-        kleur.yellow(
-            "The token secret shown above will NOT be displayed again.",
-        ),
-    );
-    console.log(
-        kleur.yellow(
-            "Please store it securely in a password manager or secure vault.",
-        ),
-    );
-    console.log(
-        kleur.yellow(
-            "If you lose this token, you will need to create a new one.",
-        ),
-    );
-    console.log("");
-    logger.info("Group access token created successfully");
+   // Display security warning after the response is printed
+   console.log("\n" + kleur.yellow().bold("⚠️  IMPORTANT SECURITY NOTICE ⚠️"));
+   console.log(
+      kleur.yellow("The token secret shown above will NOT be displayed again."),
+   );
+   console.log(
+      kleur.yellow(
+         "Please store it securely in a password manager or secure vault.",
+      ),
+   );
+   console.log(
+      kleur.yellow(
+         "If you lose this token, you will need to create a new one.",
+      ),
+   );
+   console.log("");
+   logger.info("Group access token created successfully");
 
-    return result;
+   return result;
 }

package/src/commands/groupaccesstoken/deleteToken.spec.ts

@@ -0,0 +1,147 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { GroupsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { deleteGroupAccessToken } from "./deleteToken";
+
+describe("delete-group-access-token", () => {
+   let sandbox: sinon.SinonSandbox;
+   let deleteGroupAccessTokenStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let processExitStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      deleteGroupAccessTokenStub = 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, "deleteGroupAccessToken")
+         .callsFake(deleteGroupAccessTokenStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should delete group access token successfully", async () => {
+      deleteGroupAccessTokenStub.resolves({ status: 200 });
+
+      await deleteGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         false,
+      );
+
+      expect(deleteGroupAccessTokenStub.calledOnce).to.be.true;
+      expect(deleteGroupAccessTokenStub.firstCall.args[0]).to.equal("test-org");
+      expect(deleteGroupAccessTokenStub.firstCall.args[1]).to.equal(
+         "test-group",
+      );
+      expect(deleteGroupAccessTokenStub.firstCall.args[2]).to.equal(
+         "test-token",
+      );
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match(
+               "Successfully deleted access token test-token. This token has been immediately revoked.",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      deleteGroupAccessTokenStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      processExitStub = sandbox.stub(process, "exit");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(GroupsApi.prototype, "deleteGroupAccessToken")
+         .callsFake(deleteGroupAccessTokenStub);
+
+      const result = await deleteGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         false,
+      );
+
+      expect(deleteGroupAccessTokenStub.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 handle missing organization", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      deleteGroupAccessTokenStub = 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, "deleteGroupAccessToken")
+         .callsFake(deleteGroupAccessTokenStub);
+
+      const result = await deleteGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         false,
+      );
+
+      expect(deleteGroupAccessTokenStub.called).to.be.false;
+      expect(result).to.be.undefined;
+      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");
+      deleteGroupAccessTokenStub.rejects(mockError);
+
+      await deleteGroupAccessToken(
+         "http://test-server",
+         "test-group",
+         "test-token",
+         true,
+      );
+
+      expect(deleteGroupAccessTokenStub.calledOnce).to.be.true;
+      expect(loggerStub.error.calledWith(sinon.match("Operation failed"))).to.be
+         .true;
+      expect(processExitStub.calledWith(1)).to.be.true;
+   });
+});

package/src/commands/groupaccesstoken/deleteToken.ts

@@ -2,23 +2,28 @@ import { logger } from "../../logger";
 import { withGroupContext } from "./groupContainer";
 
 export async function deleteGroupAccessToken(
-    controlPlane: string,
-    groupName: string,
-    tokenName: string,
-    debug: boolean,
+   controlPlane: string,
+   groupName: string,
+   tokenName: string,
+   debug: boolean,
 ) {
-    return withGroupContext(controlPlane, async (context) => {
-        const { organizationName, groupsApi, options } = context;
+   return withGroupContext(
+      controlPlane,
+      async (context) => {
+         const { organizationName, groupsApi, options } = context;
 
-        logger.info(
+         logger.info(
             `Deleting access token ${tokenName} from group ${groupName} in organization ${organizationName}`,
-        );
+         );
 
-        await groupsApi.deleteGroupAccessToken(
+         await groupsApi.deleteGroupAccessToken(
             organizationName,
             groupName,
             tokenName,
             options,
-        );
-    }, `Successfully deleted access token ${tokenName}. This token has been immediately revoked.`, debug);
+         );
+      },
+      `Successfully deleted access token ${tokenName}. This token has been immediately revoked.`,
+      debug,
+   );
 }

package/src/commands/groupaccesstoken/groupContainer.ts

@@ -5,23 +5,23 @@ import { logger } from "../../logger";
 import { printOutError } from "../../utils";
 
 export interface ApiOptions {
-    baseURL: string;
-    headers: {
-        Authorization: string;
-    };
-    params?: Record<string, unknown>;
+   baseURL: string;
+   headers: {
+      Authorization: string;
+   };
+   params?: Record<string, unknown>;
 }
 
 export interface GroupContext {
-    organizationName: string;
-    groupsApi: GroupsApi;
-    options: ApiOptions;
+   organizationName: string;
+   groupsApi: GroupsApi;
+   options: ApiOptions;
 }
 
 /**
  * Container function that handles common ClientConfiguration checks, setup,
  * error handling, and response printing for group access token operations.
- * 
+ *
  * @param controlPlane The control plane URL
  * @param handler The handler function to execute with the configured context
  * @param successMessage Optional success message to display after the operation
@@ -29,55 +29,55 @@ export interface GroupContext {
  * @returns The result of the handler function, or void if validation fails
  */
 export async function withGroupContext<T>(
-    controlPlane: string,
-    handler: (context: GroupContext) => Promise<T>,
-    successMessage?: string,
-    debug: boolean = false,
+   controlPlane: string,
+   handler: (context: GroupContext) => Promise<T>,
+   successMessage?: string,
+   debug: boolean = false,
 ): Promise<T | void> {
-    const clientConfig = new ClientConfiguration();
+   const clientConfig = new ClientConfiguration();
 
-    if (!clientConfig.doesConfigExists()) {
-        logger.error("Please, make sure that you are logged in");
-        return;
-    }
+   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;
-    }
+   const organizationName = clientConfig.getOrganization();
+   if (!organizationName) {
+      logger.error("No organization set. Please login or set an organization.");
+      return;
+   }
 
-    const options: ApiOptions = {
-        baseURL: controlPlane,
-        headers: {
-            Authorization: clientConfig.getAuthenticationHeader(),
-        },
-    };
+   const options: ApiOptions = {
+      baseURL: controlPlane,
+      headers: {
+         Authorization: clientConfig.getAuthenticationHeader(),
+      },
+   };
 
-    const context: GroupContext = {
-        organizationName,
-        groupsApi: new GroupsApi(new Configuration()),
-        options,
-    };
+   const context: GroupContext = {
+      organizationName,
+      groupsApi: new GroupsApi(new Configuration()),
+      options,
+   };
 
-    try {
-        const result = await handler(context);
+   try {
+      const result = await handler(context);
 
-        // Print response if it exists
-        if (result !== undefined && result !== null) {
-            const jsonString = JSON.stringify(result, null, 2);
-            console.log(jsonString);
-        }
+      // Print response if it exists
+      if (result !== undefined && result !== null) {
+         const jsonString = JSON.stringify(result, null, 2);
+         console.log(jsonString);
+      }
 
-        // Print success message if provided
-        if (successMessage) {
-            logger.info(successMessage);
-        }
+      // Print success message if provided
+      if (successMessage) {
+         logger.info(successMessage);
+      }
 
-        return result;
-    } catch (error) {
-        logger.error("Operation failed");
-        printOutError(error, debug);
-        process.exit(1);
-    }
+      return result;
+   } catch (error) {
+      logger.error("Operation failed");
+      printOutError(error, debug);
+      process.exit(1);
+   }
 }