@credibledata/cred-cli 0.0.100 → 0.0.103

package/src/commands/environment/updateenvironment.spec.ts

@@ -0,0 +1,386 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { EnvironmentsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { updateEnvironment } from "./updateenvironment";
+
+describe("update-environment", () => {
+   let sandbox: sinon.SinonSandbox;
+   let updateEnvironmentStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      updateEnvironmentStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+
+      // Mock ClientConfiguration constructor
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "getHeaders")
+         .returns({ Authorization: "Bearer test-token" });
+
+      // Mock EnvironmentsApi constructor and method
+      sandbox
+         .stub(EnvironmentsApi.prototype, "updateEnvironment")
+         .callsFake(updateEnvironmentStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   describe("updateEnvironment", () => {
+      it("should update environment successfully", async () => {
+         const mockResponse = { status: 200 };
+         updateEnvironmentStub.resolves(mockResponse);
+
+         await updateEnvironment(
+            "http://test-server",
+            "test-environment",
+            { replicationCount: 3 },
+            false,
+            true,
+         );
+
+         expect(updateEnvironmentStub.calledOnce).to.be.true;
+         expect(updateEnvironmentStub.firstCall.args[0]).to.equal("test-org");
+         expect(updateEnvironmentStub.firstCall.args[1]).to.equal(
+            "test-environment",
+         );
+         expect(updateEnvironmentStub.firstCall.args[2]).to.include({
+            replicationCount: 3,
+         });
+         expect(updateEnvironmentStub.firstCall.args[3]).to.deep.include({
+            baseURL: "http://test-server",
+            headers: { Authorization: "Bearer test-token" },
+         });
+         expect(
+            loggerStub.info.calledWith(
+               sinon.match("Successfully updated environment test-environment"),
+            ),
+         ).to.be.true;
+      });
+
+      it("should handle missing environment name", async () => {
+         await updateEnvironment(
+            "http://test-server",
+            "",
+            { replicationCount: 3 },
+            false,
+            true,
+         );
+
+         expect(updateEnvironmentStub.called).to.be.false;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match("Please provide an environment name"),
+            ),
+         ).to.be.true;
+      });
+
+      it("should handle API errors", async () => {
+         const mockError = new Error("API Error");
+         updateEnvironmentStub.rejects(mockError);
+
+         await updateEnvironment(
+            "http://test-server",
+            "test-environment",
+            { replicationCount: 3 },
+            true,
+            true,
+         );
+
+         expect(updateEnvironmentStub.calledOnce).to.be.true;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match("Failed to update environment test-environment"),
+            ),
+         ).to.be.true;
+      });
+
+      it("should handle non-200 response status", async () => {
+         const mockResponse = { status: 400 };
+         updateEnvironmentStub.resolves(mockResponse);
+
+         await updateEnvironment(
+            "http://test-server",
+            "test-environment",
+            { replicationCount: 3 },
+            false,
+            true,
+         );
+
+         expect(updateEnvironmentStub.calledOnce).to.be.true;
+         expect(
+            loggerStub.error.calledWith(
+               sinon.match("Failed to update environment. Status: 400"),
+            ),
+         ).to.be.true;
+      });
+   });
+
+   describe("validators", () => {
+      describe("authentication validation", () => {
+         it("should fail when user is not logged in", async () => {
+            sandbox.restore();
+            sandbox = sinon.createSandbox();
+            updateEnvironmentStub = sandbox.stub();
+            loggerStub = sandbox.stub(logger);
+
+            sandbox
+               .stub(ClientConfiguration.prototype, "doesConfigExists")
+               .returns(false);
+            sandbox
+               .stub(EnvironmentsApi.prototype, "updateEnvironment")
+               .callsFake(updateEnvironmentStub);
+
+            await updateEnvironment(
+               "http://test-server",
+               "test-environment",
+               { replicationCount: 3 },
+               false,
+               true,
+            );
+
+            expect(updateEnvironmentStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Please, make sure that you are logged in"),
+               ),
+            ).to.be.true;
+         });
+      });
+
+      describe("git-backed modeling", () => {
+         it("sends the enrolment flag on its own", async () => {
+            updateEnvironmentStub.resolves({ status: 200 });
+
+            await updateEnvironment(
+               "http://test-server",
+               "test-environment",
+               { gitModeling: "true" },
+               false,
+               true,
+            );
+
+            expect(updateEnvironmentStub.calledOnce).to.be.true;
+            expect(updateEnvironmentStub.firstCall.args[2]).to.deep.equal({
+               gitModelingEnabled: true,
+            });
+         });
+
+         it("rejects a --git-modeling value that is neither true nor false", async () => {
+            await updateEnvironment(
+               "http://test-server",
+               "test-environment",
+               { gitModeling: "yes" },
+               false,
+               true,
+            );
+
+            expect(updateEnvironmentStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("--git-modeling must be true or false"),
+               ),
+            ).to.be.true;
+         });
+
+         it("sends all three coordinates together", async () => {
+            updateEnvironmentStub.resolves({ status: 200 });
+
+            await updateEnvironment(
+               "http://test-server",
+               "test-environment",
+               {
+                  gitRepositoryOwner: "credible-data-repos",
+                  gitRepositoryName: "models",
+                  gitBaseBranch: "main",
+               },
+               false,
+               true,
+            );
+
+            expect(updateEnvironmentStub.firstCall.args[2]).to.deep.equal({
+               gitRepositoryOwner: "credible-data-repos",
+               gitRepositoryName: "models",
+               gitBaseBranch: "main",
+            });
+         });
+
+         it("refuses a partial coordinate locally rather than sending a 400", async () => {
+            // The API rejects this as GIT_REPOSITORY_INCOMPLETE. Refusing here means a
+            // script gets the rule from the tool it is driving.
+            await updateEnvironment(
+               "http://test-server",
+               "test-environment",
+               { gitRepositoryOwner: "credible-data-repos" },
+               false,
+               true,
+            );
+
+            expect(updateEnvironmentStub.called).to.be.false;
+            expect(loggerStub.error.calledWith(sinon.match("change together")))
+               .to.be.true;
+         });
+
+         it("refuses a mix of set and cleared coordinates", async () => {
+            await updateEnvironment(
+               "http://test-server",
+               "test-environment",
+               {
+                  gitRepositoryOwner: "credible-data-repos",
+                  gitRepositoryName: "",
+                  gitBaseBranch: "main",
+               },
+               false,
+               true,
+            );
+
+            expect(updateEnvironmentStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(sinon.match("unset the repository")),
+            ).to.be.true;
+         });
+
+         it("sends nulls when all three are emptied, which is how a record is unset", async () => {
+            updateEnvironmentStub.resolves({ status: 200 });
+
+            await updateEnvironment(
+               "http://test-server",
+               "test-environment",
+               {
+                  gitRepositoryOwner: "",
+                  gitRepositoryName: "",
+                  gitBaseBranch: " ",
+               },
+               false,
+               true,
+            );
+
+            expect(updateEnvironmentStub.firstCall.args[2]).to.deep.equal({
+               gitRepositoryOwner: null,
+               gitRepositoryName: null,
+               gitBaseBranch: null,
+            });
+         });
+
+         it("carries the enrolment and the coordinates in one request", async () => {
+            updateEnvironmentStub.resolves({ status: 200 });
+
+            await updateEnvironment(
+               "http://test-server",
+               "test-environment",
+               {
+                  gitModeling: "true",
+                  gitRepositoryOwner: "credible-data-repos",
+                  gitRepositoryName: "models",
+                  gitBaseBranch: "main",
+               },
+               false,
+               true,
+            );
+
+            expect(updateEnvironmentStub.firstCall.args[2]).to.deep.equal({
+               gitModelingEnabled: true,
+               gitRepositoryOwner: "credible-data-repos",
+               gitRepositoryName: "models",
+               gitBaseBranch: "main",
+            });
+         });
+
+         it("reports a refusal from the server rather than claiming success", async () => {
+            updateEnvironmentStub.rejects(
+               Object.assign(new Error("Request failed with status code 400"), {
+                  response: {
+                     status: 400,
+                     data: { code: "GIT_REPOSITORY_NOT_REGISTERED" },
+                  },
+               }),
+            );
+
+            await updateEnvironment(
+               "http://test-server",
+               "test-environment",
+               { gitModeling: "true" },
+               false,
+               true,
+            );
+
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Failed to update environment test-environment"),
+               ),
+            ).to.be.true;
+            expect(
+               loggerStub.info.calledWith(sinon.match("Successfully updated")),
+            ).to.be.false;
+         });
+      });
+
+      describe("replication count validation", () => {
+         it("should accept valid replication counts", async () => {
+            const mockResponse = { status: 200 };
+            updateEnvironmentStub.resolves(mockResponse);
+
+            const validCounts = [1, 2, 5, 10, 100];
+
+            for (const count of validCounts) {
+               await updateEnvironment(
+                  "http://test-server",
+                  "test-environment",
+                  { replicationCount: count },
+                  false,
+                  true,
+               );
+               expect(updateEnvironmentStub.called).to.be.true;
+               expect(updateEnvironmentStub.firstCall.args[2]).to.include({
+                  replicationCount: count,
+               });
+               updateEnvironmentStub.reset();
+            }
+         });
+
+         it("should reject replication count less than 1", async () => {
+            await updateEnvironment(
+               "http://test-server",
+               "test-environment",
+               { replicationCount: 0 },
+               false,
+               true,
+            );
+
+            expect(updateEnvironmentStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Replication count must be at least 1"),
+               ),
+            ).to.be.true;
+         });
+
+         it("should reject negative replication count", async () => {
+            await updateEnvironment(
+               "http://test-server",
+               "test-environment",
+               { replicationCount: -1 },
+               false,
+               true,
+            );
+
+            expect(updateEnvironmentStub.called).to.be.false;
+            expect(
+               loggerStub.error.calledWith(
+                  sinon.match("Replication count must be at least 1"),
+               ),
+            ).to.be.true;
+         });
+      });
+   });
+});

package/src/commands/environment/updateenvironment.ts

@@ -0,0 +1,168 @@
+import { Environment, EnvironmentsApi } from "../../client/api";
+import { Configuration } from "../../client/configuration";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { getConfirmation, printOutError } from "../../utils";
+
+const environmentsApi = new EnvironmentsApi(new Configuration());
+
+type UpdateEnvironmentProperties = {
+   replicationCount?: number;
+   /** Raw `--git-modeling` value; parsed here so a typo is refused rather than sent. */
+   gitModeling?: string;
+   gitRepositoryOwner?: string;
+   gitRepositoryName?: string;
+   gitBaseBranch?: string;
+};
+
+/**
+ * The three repository coordinates change as a unit, and the API rejects any other
+ * shape (`GIT_REPOSITORY_INCOMPLETE`, `GIT_REPOSITORY_INCOHERENT`). Refused here too, so
+ * a scripted caller gets the rule from the tool it is driving rather than from a 400.
+ *
+ * Returns the body fragment, or a message to print instead of sending anything.
+ */
+function gitRepositoryRecord(
+   properties: UpdateEnvironmentProperties,
+): { changes: Partial<Environment> } | { error: string } {
+   const mentioned = [
+      properties.gitRepositoryOwner,
+      properties.gitRepositoryName,
+      properties.gitBaseBranch,
+   ].filter((value) => value !== undefined) as string[];
+
+   if (mentioned.length === 0) {
+      return { changes: {} };
+   }
+   if (mentioned.length !== 3) {
+      return {
+         error:
+            "--git-repository-owner, --git-repository-name and --git-base-branch change " +
+            "together. Pass all three, or none.",
+      };
+   }
+
+   const trimmed = mentioned.map((value) => value.trim());
+   const cleared = trimmed.filter((value) => value === "").length;
+   if (cleared !== 0 && cleared !== 3) {
+      return {
+         error:
+            "Set all three of --git-repository-owner, --git-repository-name and " +
+            '--git-base-branch, or pass "" for all three to unset the repository.',
+      };
+   }
+
+   const [owner, name, baseBranch] = trimmed;
+   return {
+      changes: {
+         gitRepositoryOwner: owner || null,
+         gitRepositoryName: name || null,
+         gitBaseBranch: baseBranch || null,
+      },
+   };
+}
+
+export async function updateEnvironment(
+   controlPlane: string,
+   environmentName: string,
+   properties: UpdateEnvironmentProperties,
+   debug?: boolean,
+   skipConfirmation?: boolean,
+) {
+   const clientConfig = new ClientConfiguration();
+   if (!clientConfig.doesConfigExists()) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
+   if (!environmentName) {
+      logger.error("Please provide an environment name");
+      return;
+   }
+
+   const organizationName = clientConfig.getOrganization();
+
+   if (
+      properties.replicationCount !== undefined &&
+      properties.replicationCount < 1
+   ) {
+      logger.error("Replication count must be at least 1");
+      return;
+   }
+
+   if (
+      properties.gitModeling !== undefined &&
+      properties.gitModeling !== "true" &&
+      properties.gitModeling !== "false"
+   ) {
+      logger.error("--git-modeling must be true or false");
+      return;
+   }
+
+   const repositoryRecord = gitRepositoryRecord(properties);
+   if ("error" in repositoryRecord) {
+      logger.error(repositoryRecord.error);
+      return;
+   }
+
+   try {
+      if (!skipConfirmation) {
+         const confirmation = await getConfirmation(
+            `Are you sure you want to update environment ${environmentName}?`,
+         );
+         if (!confirmation) {
+            logger.info("Operation cancelled.");
+            return;
+         }
+      }
+
+      const environmentUpdate: Environment = { ...repositoryRecord.changes };
+
+      if (properties.replicationCount !== undefined) {
+         environmentUpdate.replicationCount = properties.replicationCount;
+      }
+
+      if (properties.gitModeling !== undefined) {
+         environmentUpdate.gitModelingEnabled =
+            properties.gitModeling === "true";
+      }
+
+      const response = await environmentsApi.updateEnvironment(
+         organizationName,
+         environmentName,
+         environmentUpdate,
+         {
+            baseURL: controlPlane,
+            headers: clientConfig.getHeaders(),
+         },
+      );
+
+      if (response.status === 200) {
+         logger.info(`Successfully updated environment ${environmentName}`);
+         if (properties.replicationCount !== undefined) {
+            logger.info(
+               `Replication count set to ${properties.replicationCount}`,
+            );
+         }
+         if (properties.gitModeling !== undefined) {
+            logger.info(
+               `Git-backed modeling ${properties.gitModeling === "true" ? "enabled" : "disabled"}`,
+            );
+         }
+         if (environmentUpdate.gitRepositoryOwner !== undefined) {
+            logger.info(
+               environmentUpdate.gitRepositoryOwner
+                  ? `Repository set to ${environmentUpdate.gitRepositoryOwner}/${environmentUpdate.gitRepositoryName} (${environmentUpdate.gitBaseBranch})`
+                  : "Repository unset",
+            );
+         }
+      } else {
+         logger.error(
+            `Failed to update environment. Status: ${response.status}`,
+         );
+      }
+   } catch (e) {
+      logger.error(`Failed to update environment ${environmentName}`);
+      printOutError(e, debug);
+   }
+}