@credibledata/cred-cli 0.0.6

package/src/clientconfiguration.spec.ts

@@ -0,0 +1,490 @@
+import { expect } from "chai";
+import fs from "fs";
+import os from "os";
+import { join } from "path";
+import sinon from "sinon";
+import { ClientConfiguration } from "./clientconfiguration";
+import { ALL_ENVIRONMENTS, type Environment } from "./constants";
+import { logger } from "./logger";
+
+/** Expected `configPerEnvironment` shape after `loadConfig()` (every env has an object). */
+function fullPerEnv(
+   filled: Partial<Record<Environment, Record<string, unknown>>> = {},
+): Record<string, Record<string, unknown>> {
+   const out: Record<string, Record<string, unknown>> = {};
+   for (const env of ALL_ENVIRONMENTS) {
+      out[env] = filled[env] != null ? { ...filled[env]! } : {};
+   }
+   return out;
+}
+
+describe("ClientConfiguration", () => {
+   let clientConfig: ClientConfiguration;
+   let readFileSyncStub: sinon.SinonStub;
+   let writeFileSyncStub: sinon.SinonStub;
+   let customConfigPath: string;
+
+   beforeEach(() => {
+      customConfigPath = join(os.homedir(), ".cred_test");
+      clientConfig = new ClientConfiguration(customConfigPath);
+
+      fs.writeFileSync(customConfigPath, "{}");
+
+      readFileSyncStub = sinon.stub(fs, "readFileSync");
+      writeFileSyncStub = sinon.stub(fs, "writeFileSync");
+   });
+
+   afterEach(() => {
+      sinon.restore();
+
+      if (fs.existsSync(customConfigPath)) {
+         fs.unlinkSync(customConfigPath);
+      }
+   });
+
+   it("should load the default config if the file does not exist", () => {
+      readFileSyncStub.throws(new Error("File not found"));
+      clientConfig.loadConfig();
+      expect(clientConfig["config"]).to.deep.equal({
+         configPerEnvironment: fullPerEnv(),
+         activeEnvironment: "production",
+      });
+   });
+
+   it("should load the config file correctly", () => {
+      const mockConfig = {
+         configPerEnvironment: {
+            production: { project: "test-project" },
+            staging: {},
+            localhost: {},
+         },
+         activeEnvironment: "production",
+      };
+      readFileSyncStub.returns(JSON.stringify(mockConfig));
+      clientConfig.loadConfig();
+      expect(clientConfig["config"]).to.deep.equal({
+         configPerEnvironment: fullPerEnv({
+            production: { project: "test-project" },
+         }),
+         activeEnvironment: "production",
+      });
+   });
+
+   it("should allow setAccessToken when activeEnvironment had no bucket on disk (e.g. videoamp)", () => {
+      const mockConfig = {
+         configPerEnvironment: {
+            production: {},
+            staging: {},
+            dev: {},
+            localhost: {},
+            "e2e-test": {},
+         },
+         activeEnvironment: "videoamp",
+      };
+      readFileSyncStub.returns(JSON.stringify(mockConfig));
+      clientConfig.setAccessToken(true, "user-jwt");
+      const written = JSON.parse(writeFileSyncStub.lastCall.args[1] as string);
+      expect(written.configPerEnvironment.videoamp.accessToken).to.equal(
+         "user-jwt",
+      );
+      expect(written.configPerEnvironment.videoamp.isServiceAccountToken).to.be
+         .false;
+   });
+
+   it("should set and get the project correctly", () => {
+      readFileSyncStub.throws(new Error("File not found"));
+      clientConfig.setProject("new-project");
+
+      expect(
+         writeFileSyncStub.calledWith(
+            customConfigPath,
+            JSON.stringify({
+               configPerEnvironment: fullPerEnv({
+                  production: { project: "new-project" },
+               }),
+               activeEnvironment: "production",
+            }),
+         ),
+      ).to.be.true;
+   });
+
+   it("should set and get the access token correctly", () => {
+      readFileSyncStub.throws(new Error("File not found"));
+      clientConfig.setAccessToken(false, "token-123");
+
+      expect(
+         writeFileSyncStub.calledWith(
+            customConfigPath,
+            JSON.stringify({
+               configPerEnvironment: fullPerEnv({
+                  production: {
+                     isServiceAccountToken: true,
+                     accessToken: "token-123",
+                  },
+               }),
+               activeEnvironment: "production",
+            }),
+         ),
+      ).to.be.true;
+   });
+
+   it("should clear auth when setting access token", () => {
+      readFileSyncStub.returns(
+         JSON.stringify({ auth: { username: "user", password: "pass" } }),
+      );
+      clientConfig.setAccessToken(true, "new-token");
+      expect(
+         writeFileSyncStub.calledWith(
+            customConfigPath,
+            JSON.stringify({
+               configPerEnvironment: fullPerEnv({
+                  production: {
+                     isServiceAccountToken: false,
+                     accessToken: "new-token",
+                  },
+               }),
+               activeEnvironment: "production",
+            }),
+         ),
+      ).to.be.true;
+   });
+
+   it("should set and get organization", () => {
+      readFileSyncStub.throws(new Error("File not found"));
+      clientConfig.setOrganization("my-org");
+
+      expect(
+         writeFileSyncStub.calledWith(
+            customConfigPath,
+            JSON.stringify({
+               configPerEnvironment: fullPerEnv({
+                  production: { organization: "my-org" },
+               }),
+               activeEnvironment: "production",
+            }),
+         ),
+      ).to.be.true;
+   });
+
+   it("should set and get refresh token", () => {
+      readFileSyncStub.throws(new Error("File not found"));
+      clientConfig.setRefreshToken("refresh-token-123");
+
+      expect(
+         writeFileSyncStub.calledWith(
+            customConfigPath,
+            JSON.stringify({
+               configPerEnvironment: fullPerEnv({
+                  production: { refreshToken: "refresh-token-123" },
+               }),
+               activeEnvironment: "production",
+            }),
+         ),
+      ).to.be.true;
+   });
+
+   it("should set and get VSCode user", () => {
+      readFileSyncStub.throws(new Error("File not found"));
+      clientConfig.setVSCodeUser("testuser", "test@example.com");
+
+      expect(
+         writeFileSyncStub.calledWith(
+            customConfigPath,
+            JSON.stringify({
+               configPerEnvironment: fullPerEnv({
+                  production: {
+                     vsCodeUser: {
+                        username: "testuser",
+                        email: "test@example.com",
+                     },
+                  },
+               }),
+               activeEnvironment: "production",
+            }),
+         ),
+      ).to.be.true;
+   });
+
+   it("should set and get JWT access token", () => {
+      readFileSyncStub.throws(new Error("File not found"));
+      clientConfig.setJwtAccessToken("jwt-token-abc");
+
+      expect(
+         writeFileSyncStub.calledWith(
+            customConfigPath,
+            JSON.stringify({
+               configPerEnvironment: fullPerEnv({
+                  production: { jwtAccessToken: "jwt-token-abc" },
+               }),
+               activeEnvironment: "production",
+            }),
+         ),
+      ).to.be.true;
+   });
+
+   it("should return true for doesConfigExists when environment config exists", () => {
+      const mockConfig = {
+         configPerEnvironment: {
+            production: { project: "test" },
+            staging: {},
+            localhost: {},
+         },
+         activeEnvironment: "production",
+      };
+      readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+      expect(clientConfig.doesConfigExists()).to.be.true;
+   });
+
+   it("should destroy config by resetting environment config to empty", () => {
+      const mockConfig = {
+         configPerEnvironment: {
+            production: { organization: "my-org", project: "my-proj" },
+            staging: {},
+            localhost: {},
+         },
+         activeEnvironment: "production",
+      };
+      readFileSyncStub.returns(JSON.stringify(mockConfig));
+      clientConfig.destroyConfig();
+
+      const lastWrite = writeFileSyncStub.lastCall.args[1] as string;
+      expect(JSON.parse(lastWrite)).to.deep.equal({
+         configPerEnvironment: fullPerEnv(),
+         activeEnvironment: "production",
+      });
+   });
+
+   it("should set and get environment", () => {
+      readFileSyncStub.throws(new Error("File not found"));
+      clientConfig.setEnvironment("staging");
+
+      expect(
+         writeFileSyncStub.calledWith(
+            customConfigPath,
+            JSON.stringify({
+               configPerEnvironment: fullPerEnv(),
+               activeEnvironment: "staging",
+            }),
+         ),
+      ).to.be.true;
+   });
+
+   it("should return headers with Bearer token for user tokens", () => {
+      const mockConfig = {
+         configPerEnvironment: {
+            production: {
+               accessToken: "user-token",
+               isServiceAccountToken: false,
+            },
+            staging: {},
+            localhost: {},
+         },
+         activeEnvironment: "production",
+      };
+      readFileSyncStub.returns(JSON.stringify(mockConfig));
+      clientConfig.loadConfig();
+
+      const headers = clientConfig.getHeaders();
+      expect(headers.Authorization).to.equal("Bearer user-token");
+   });
+
+   it("should return headers with ApiKey for service account tokens", () => {
+      const mockConfig = {
+         configPerEnvironment: {
+            production: {
+               accessToken: "service-token",
+               isServiceAccountToken: true,
+            },
+            staging: {},
+            localhost: {},
+         },
+         activeEnvironment: "production",
+      };
+      readFileSyncStub.returns(JSON.stringify(mockConfig));
+      clientConfig.loadConfig();
+
+      const headers = clientConfig.getHeaders();
+      expect(headers.Authorization).to.equal("ApiKey service-token");
+   });
+
+   it("should reset to defaults when config file is corrupted (missing activeEnvironment)", () => {
+      readFileSyncStub.returns(JSON.stringify({ configPerEnvironment: {} }));
+      clientConfig.loadConfig();
+
+      expect(clientConfig["config"].activeEnvironment).to.equal("production");
+   });
+
+   describe("isTokenValid", () => {
+      it("should return invalid when no token exists", () => {
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {},
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         const result = clientConfig.isTokenValid();
+         expect(result.valid).to.be.false;
+         expect(result.reason).to.equal("No token found. Please login.");
+      });
+
+      it("should return valid for service account tokens", () => {
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {
+                  accessToken: "some-api-key",
+                  isServiceAccountToken: true,
+               },
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         const result = clientConfig.isTokenValid();
+         expect(result.valid).to.be.true;
+      });
+
+      it("should return invalid for expired JWT", () => {
+         // Create a JWT with an expired exp claim
+         const payload = { exp: Math.floor(Date.now() / 1000) - 3600 };
+         const fakeJwt =
+            Buffer.from(JSON.stringify({ alg: "HS256" })).toString(
+               "base64url",
+            ) +
+            "." +
+            Buffer.from(JSON.stringify(payload)).toString("base64url") +
+            ".signature";
+
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {
+                  accessToken: fakeJwt,
+                  isServiceAccountToken: false,
+               },
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         const result = clientConfig.isTokenValid();
+         expect(result.valid).to.be.false;
+         expect(result.reason).to.equal("Token expired. Please login again.");
+      });
+
+      it("should return valid for non-expired JWT", () => {
+         const payload = { exp: Math.floor(Date.now() / 1000) + 3600 };
+         const fakeJwt =
+            Buffer.from(JSON.stringify({ alg: "HS256" })).toString(
+               "base64url",
+            ) +
+            "." +
+            Buffer.from(JSON.stringify(payload)).toString("base64url") +
+            ".signature";
+
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {
+                  accessToken: fakeJwt,
+                  isServiceAccountToken: false,
+               },
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         const result = clientConfig.isTokenValid();
+         expect(result.valid).to.be.true;
+      });
+
+      it("should return invalid for malformed token", () => {
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {
+                  accessToken: "not-a-valid-jwt",
+                  isServiceAccountToken: false,
+               },
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         const result = clientConfig.isTokenValid();
+         expect(result.valid).to.be.false;
+         expect(result.reason).to.equal(
+            "Invalid token format. Please login again.",
+         );
+      });
+   });
+
+   describe("printStatus", () => {
+      let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+      let consoleLogStub: sinon.SinonStub;
+
+      beforeEach(() => {
+         loggerStub = sinon.stub(logger);
+         consoleLogStub = sinon.stub(console, "log");
+      });
+
+      it("should print org and project when token is valid", () => {
+         const payload = { exp: Math.floor(Date.now() / 1000) + 3600 };
+         const fakeJwt =
+            Buffer.from(JSON.stringify({ alg: "HS256" })).toString(
+               "base64url",
+            ) +
+            "." +
+            Buffer.from(JSON.stringify(payload)).toString("base64url") +
+            ".signature";
+
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {
+                  accessToken: fakeJwt,
+                  isServiceAccountToken: false,
+                  organization: "my-org",
+                  project: "my-project",
+               },
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         clientConfig.printStatus();
+
+         expect(loggerStub.info.calledWith(sinon.match("Organization:"))).to.be
+            .true;
+         expect(loggerStub.info.calledWith(sinon.match("Project:"))).to.be.true;
+      });
+
+      it("should print error when token is invalid", () => {
+         const mockConfig = {
+            configPerEnvironment: {
+               production: {},
+               staging: {},
+               localhost: {},
+            },
+            activeEnvironment: "production",
+         };
+         readFileSyncStub.returns(JSON.stringify(mockConfig));
+
+         clientConfig.printStatus();
+
+         expect(
+            loggerStub.error.calledWith(sinon.match("Failed to get status")),
+         ).to.be.true;
+      });
+   });
+});