@credibledata/cred-cli 0.0.103 → 0.0.105

package/src/clientconfiguration.spec.ts

@@ -1,615 +0,0 @@
-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 renameSyncStub: sinon.SinonStub;
-   let customConfigPath: string;
-
-   // Simulate a real ENOENT from readFileSync (has `.code = "ENOENT"`).
-   // A bare `Error("File not found")` no longer triggers first-time-setup —
-   // loadConfig now rethrows non-ENOENT errors instead of silently masking them.
-   const enoent = () => Object.assign(new Error("ENOENT"), { code: "ENOENT" });
-
-   // Pull the most-recent persisted config payload off the stubs. Atomic writes
-   // go through writeFileSync(tmpPath, json) followed by renameSync(tmp, path).
-   const lastWrittenConfig = () => {
-      const args = writeFileSyncStub.lastCall.args;
-      return JSON.parse(args[1] as 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");
-      renameSyncStub = sinon.stub(fs, "renameSync");
-   });
-
-   afterEach(() => {
-      sinon.restore();
-
-      if (fs.existsSync(customConfigPath)) {
-         fs.unlinkSync(customConfigPath);
-      }
-   });
-
-   it("should load the default config if the file does not exist", () => {
-      readFileSyncStub.throws(enoent());
-      clientConfig.loadConfig();
-      expect(clientConfig["config"]).to.deep.equal({
-         configPerEnvironment: fullPerEnv(),
-         activeEnvironment: "production",
-      });
-   });
-
-   it("should throw loudly when the config file is unparseable", () => {
-      // Non-atomic writes from older binaries can leave `.cred` truncated.
-      // loadConfig must fail loud instead of silently overwriting — a silent
-      // reset erases the access token for every subsequent caller.
-      readFileSyncStub.returns("{ not json");
-      expect(() => clientConfig.loadConfig()).to.throw(/may be corrupt/);
-      expect(writeFileSyncStub.called).to.be.false;
-   });
-
-   it("should throw when readFileSync fails with a non-ENOENT error", () => {
-      const eacces = Object.assign(new Error("EACCES"), { code: "EACCES" });
-      readFileSyncStub.throws(eacces);
-      expect(() => clientConfig.loadConfig()).to.throw(/EACCES/);
-   });
-
-   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(enoent());
-      clientConfig.setProject("new-project");
-
-      expect(lastWrittenConfig()).to.deep.equal({
-         configPerEnvironment: fullPerEnv({
-            production: { project: "new-project" },
-         }),
-         activeEnvironment: "production",
-      });
-      expect(renameSyncStub.lastCall.args[1]).to.equal(customConfigPath);
-   });
-
-   it("should set and get the access token correctly", () => {
-      readFileSyncStub.throws(enoent());
-      clientConfig.setAccessToken(false, "token-123");
-
-      expect(lastWrittenConfig()).to.deep.equal({
-         configPerEnvironment: fullPerEnv({
-            production: {
-               isServiceAccountToken: true,
-               accessToken: "token-123",
-            },
-         }),
-         activeEnvironment: "production",
-      });
-   });
-
-   it("should preserve other per-env fields when setting access token", () => {
-      // Valid initial config (with an activeEnvironment so loadConfig accepts it).
-      readFileSyncStub.returns(
-         JSON.stringify({
-            configPerEnvironment: {
-               production: {
-                  auth: { username: "user", password: "pass" },
-               },
-            },
-            activeEnvironment: "production",
-         }),
-      );
-      clientConfig.setAccessToken(true, "new-token");
-      expect(lastWrittenConfig().configPerEnvironment.production).to.deep.equal(
-         {
-            auth: { username: "user", password: "pass" },
-            isServiceAccountToken: false,
-            accessToken: "new-token",
-         },
-      );
-   });
-
-   it("should set and get organization", () => {
-      readFileSyncStub.throws(enoent());
-      clientConfig.setOrganization("my-org");
-
-      expect(lastWrittenConfig()).to.deep.equal({
-         configPerEnvironment: fullPerEnv({
-            production: { organization: "my-org" },
-         }),
-         activeEnvironment: "production",
-      });
-   });
-
-   it("should set and get refresh token", () => {
-      readFileSyncStub.throws(enoent());
-      clientConfig.setRefreshToken("refresh-token-123");
-
-      expect(lastWrittenConfig()).to.deep.equal({
-         configPerEnvironment: fullPerEnv({
-            production: { refreshToken: "refresh-token-123" },
-         }),
-         activeEnvironment: "production",
-      });
-   });
-
-   it("should set and get VSCode user", () => {
-      readFileSyncStub.throws(enoent());
-      clientConfig.setVSCodeUser("testuser", "test@example.com");
-
-      expect(lastWrittenConfig()).to.deep.equal({
-         configPerEnvironment: fullPerEnv({
-            production: {
-               vsCodeUser: {
-                  username: "testuser",
-                  email: "test@example.com",
-               },
-            },
-         }),
-         activeEnvironment: "production",
-      });
-   });
-
-   it("should set and get JWT access token", () => {
-      readFileSyncStub.throws(enoent());
-      clientConfig.setJwtAccessToken("jwt-token-abc");
-
-      expect(lastWrittenConfig()).to.deep.equal({
-         configPerEnvironment: fullPerEnv({
-            production: { jwtAccessToken: "jwt-token-abc" },
-         }),
-         activeEnvironment: "production",
-      });
-   });
-
-   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();
-
-      expect(lastWrittenConfig()).to.deep.equal({
-         configPerEnvironment: fullPerEnv(),
-         activeEnvironment: "production",
-      });
-   });
-
-   it("should set and get environment", () => {
-      readFileSyncStub.throws(enoent());
-      clientConfig.setEnvironment("staging");
-
-      expect(lastWrittenConfig()).to.deep.equal({
-         configPerEnvironment: fullPerEnv(),
-         activeEnvironment: "staging",
-      });
-   });
-
-   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 throw when config file is missing activeEnvironment", () => {
-      // Previously loadConfig silently reset to defaults — that turned one
-      // corrupt read into permanent state loss for every caller. Now we fail loud.
-      readFileSyncStub.returns(JSON.stringify({ configPerEnvironment: {} }));
-      expect(() => clientConfig.loadConfig()).to.throw(
-         /Invalid config structure/,
-      );
-      expect(writeFileSyncStub.called).to.be.false;
-   });
-
-   describe("recoverIfCorrupt", () => {
-      it("returns null and writes nothing when the config is already valid", () => {
-         readFileSyncStub.returns(
-            JSON.stringify({
-               configPerEnvironment: {},
-               activeEnvironment: "staging",
-            }),
-         );
-
-         expect(clientConfig.recoverIfCorrupt()).to.be.null;
-         expect(renameSyncStub.called).to.be.false;
-         // Valid config preserved — active environment untouched.
-         expect(clientConfig.getEnvironment()).to.equal("staging");
-      });
-
-      it("backs up an unparseable file and resets to defaults", () => {
-         readFileSyncStub.returns("{ not json");
-
-         const backupPath = clientConfig.recoverIfCorrupt();
-
-         expect(backupPath).to.match(
-            new RegExp(`${customConfigPath}\\.corrupt-[0-9a-f]{16}$`),
-         );
-         // Renamed aside, never deleted, so the bad file is recoverable.
-         expect(renameSyncStub.calledWith(customConfigPath, backupPath!)).to.be
-            .true;
-         expect(lastWrittenConfig()).to.deep.equal({
-            configPerEnvironment: fullPerEnv(),
-            activeEnvironment: "production",
-         });
-      });
-
-      it("backs up a structurally-invalid file and resets to defaults", () => {
-         readFileSyncStub.returns(JSON.stringify({ configPerEnvironment: {} }));
-
-         const backupPath = clientConfig.recoverIfCorrupt();
-
-         expect(backupPath).to.be.a("string");
-         expect(renameSyncStub.calledWith(customConfigPath, backupPath!)).to.be
-            .true;
-         expect(lastWrittenConfig().activeEnvironment).to.equal("production");
-      });
-
-      it("rethrows fs errors (e.g. EACCES) instead of masking them as a reset", () => {
-         // A permissions problem must surface — resetting would just fail to
-         // write anyway, and silently "recovering" would hide the real cause.
-         const eacces = Object.assign(new Error("EACCES"), { code: "EACCES" });
-         readFileSyncStub.throws(eacces);
-
-         expect(() => clientConfig.recoverIfCorrupt()).to.throw(/EACCES/);
-         expect(renameSyncStub.called).to.be.false;
-      });
-
-      it("creates a fresh default when the file is absent (ENOENT)", () => {
-         readFileSyncStub.throws(enoent());
-
-         // First-time setup is not corruption — nothing to back up. (The atomic
-         // write of the new default does call renameSync, but never to a
-         // `.corrupt-` backup path.)
-         expect(clientConfig.recoverIfCorrupt()).to.be.null;
-         expect(
-            renameSyncStub
-               .getCalls()
-               .some((c) => String(c.args[1]).includes(".corrupt-")),
-         ).to.be.false;
-      });
-   });
-
-   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("Environment:"))).to.be
-            .true;
-      });
-
-      it("should name the targeted cell when the 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: {},
-               staging: {},
-               localhost: {},
-               dev: {
-                  accessToken: fakeJwt,
-                  isServiceAccountToken: false,
-                  organization: "demo",
-                  project: "demo",
-               },
-            },
-            activeEnvironment: "dev",
-         };
-         readFileSyncStub.returns(JSON.stringify(mockConfig));
-
-         clientConfig.printStatus();
-
-         expect(loggerStub.info.calledWith(sinon.match("Cell:"))).to.be.true;
-         expect(loggerStub.info.calledWith(sinon.match("dev"))).to.be.true;
-         expect(
-            loggerStub.info.calledWith(
-               sinon.match("https://dev-admin.credibledata.com/api/v0"),
-            ),
-         ).to.be.true;
-      });
-
-      it("should name the targeted cell even when the token is invalid", () => {
-         const mockConfig = {
-            configPerEnvironment: {
-               production: {},
-               staging: {},
-               localhost: {},
-            },
-            activeEnvironment: "localhost",
-         };
-         readFileSyncStub.returns(JSON.stringify(mockConfig));
-
-         clientConfig.printStatus();
-
-         expect(loggerStub.info.calledWith(sinon.match("Cell:"))).to.be.true;
-         expect(
-            loggerStub.info.calledWith(
-               sinon.match("http://admin.ms2.localhost/api/v0"),
-            ),
-         ).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;
-      });
-   });
-});