@credibledata/cred-cli 0.0.100 → 0.0.103

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

@@ -0,0 +1,110 @@
+import { expect } from "chai";
+import sinon from "sinon";
+import { EnvironmentsApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson } from "../../utils";
+import { getEnvironment } from "./getenvironment";
+
+describe("get-environment", () => {
+   let sandbox: sinon.SinonSandbox;
+   let getEnvironmentStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let consoleLogStub: sinon.SinonStub;
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      getEnvironmentStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      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" });
+
+      sandbox
+         .stub(EnvironmentsApi.prototype, "getEnvironment")
+         .callsFake(getEnvironmentStub);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+   });
+
+   it("should get environment successfully", async () => {
+      const mockEnvironmentData = {
+         name: "test-environment",
+         replicationCount: 3,
+      };
+      const mockResponse = {
+         data: mockEnvironmentData,
+      };
+      getEnvironmentStub.resolves(mockResponse);
+
+      await getEnvironment("http://test-server", "test-environment", false);
+
+      expect(getEnvironmentStub.calledOnce).to.be.true;
+      expect(getEnvironmentStub.firstCall.args[0]).to.equal("test-org");
+      expect(getEnvironmentStub.firstCall.args[1]).to.equal("test-environment");
+      expect(getEnvironmentStub.firstCall.args[2]).to.equal(false);
+      expect(getEnvironmentStub.firstCall.args[3]).to.deep.include({
+         baseURL: "http://test-server",
+         headers: { Authorization: "Bearer test-token" },
+      });
+      expect(consoleLogStub.calledWith(prettifyJson(mockEnvironmentData))).to.be
+         .true;
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      getEnvironmentStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      consoleLogStub = sandbox.stub(console, "log");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(EnvironmentsApi.prototype, "getEnvironment")
+         .callsFake(getEnvironmentStub);
+
+      await getEnvironment("http://test-server", "test-environment", false);
+
+      expect(getEnvironmentStub.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 environment name", async () => {
+      await getEnvironment("http://test-server", "", false);
+
+      expect(getEnvironmentStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure to provide an environment name"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle API errors", async () => {
+      const mockError = new Error("API Error");
+      getEnvironmentStub.rejects(mockError);
+
+      await getEnvironment("http://test-server", "test-environment", true);
+
+      expect(getEnvironmentStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to get environment")),
+      ).to.be.true;
+   });
+});

package/src/commands/{project/getproject.ts → environment/getenvironment.ts}

@@ -1,14 +1,14 @@
-import { ProjectsApi } from "../../client/api";
+import { EnvironmentsApi } from "../../client/api";
 import { Configuration } from "../../client/configuration";
 import { ClientConfiguration } from "../../clientconfiguration";
 import { logger } from "../../logger";
 import { prettifyJson, printOutError } from "../../utils";
 
-const projectsApi = new ProjectsApi(new Configuration());
+const environmentsApi = new EnvironmentsApi(new Configuration());
 
-export async function getProject(
+export async function getEnvironment(
    controlPlane: string,
-   projectName: string,
+   environmentName: string,
    debug: boolean,
 ) {
    const clientConfig = new ClientConfiguration();
@@ -19,15 +19,15 @@ export async function getProject(
       return;
    }
 
-   if (!projectName) {
-      logger.error("Please, make sure to provide a project name");
+   if (!environmentName) {
+      logger.error("Please, make sure to provide an environment name");
       return;
    }
 
    try {
-      const response = await projectsApi.getProject(
+      const response = await environmentsApi.getEnvironment(
          organizationName,
-         projectName,
+         environmentName,
          false,
          {
             baseURL: controlPlane,
@@ -37,7 +37,7 @@ export async function getProject(
 
       console.log(prettifyJson(response.data));
    } catch (e) {
-      logger.error("Failed to get project");
+      logger.error("Failed to get environment");
       printOutError(e, debug);
    }
 }

package/src/commands/{project/listprojects.spec.ts → environment/listenvironments.spec.ts}

@@ -1,20 +1,20 @@
 import { expect } from "chai";
 import sinon from "sinon";
-import { ProjectsApi } from "../../client/api";
+import { EnvironmentsApi } from "../../client/api";
 import { ClientConfiguration } from "../../clientconfiguration";
 import { logger } from "../../logger";
 import { prettifyJson } from "../../utils";
-import { listProjects, printOutProjects } from "./listprojects";
+import { listEnvironments, printOutEnvironments } from "./listenvironments";
 
-describe("list-projects", () => {
+describe("list-environments", () => {
    let sandbox: sinon.SinonSandbox;
-   let listProjectsStub: sinon.SinonStub;
+   let listEnvironmentsStub: sinon.SinonStub;
    let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
    let consoleLogStub: sinon.SinonStub;
 
    beforeEach(() => {
       sandbox = sinon.createSandbox();
-      listProjectsStub = sandbox.stub();
+      listEnvironmentsStub = sandbox.stub();
       loggerStub = sandbox.stub(logger);
       consoleLogStub = sandbox.stub(console, "log");
 
@@ -29,37 +29,37 @@ describe("list-projects", () => {
          .returns({ Authorization: "Bearer test-token" });
 
       sandbox
-         .stub(ProjectsApi.prototype, "listProjects")
-         .callsFake(listProjectsStub);
+         .stub(EnvironmentsApi.prototype, "listEnvironments")
+         .callsFake(listEnvironmentsStub);
    });
 
    afterEach(() => {
       sandbox.restore();
    });
 
-   it("should list projects successfully", async () => {
-      const mockProjects = [
-         { name: "project1", replicationCount: 2 },
-         { name: "project2", replicationCount: 3 },
+   it("should list environments successfully", async () => {
+      const mockEnvironments = [
+         { name: "environment1", replicationCount: 2 },
+         { name: "environment2", replicationCount: 3 },
       ];
       const mockResponse = {
-         data: mockProjects,
+         data: mockEnvironments,
          headers: {},
       };
-      listProjectsStub.resolves(mockResponse);
+      listEnvironmentsStub.resolves(mockResponse);
 
-      const result = await listProjects("http://test-server", false);
+      const result = await listEnvironments("http://test-server", false);
 
-      expect(listProjectsStub.calledOnce).to.be.true;
-      expect(listProjectsStub.firstCall.args[0]).to.equal("test-org");
-      expect(listProjectsStub.firstCall.args[1]).to.equal(-1); // limit
-      expect(listProjectsStub.firstCall.args[2]).to.equal(0); // offset
-      expect(listProjectsStub.firstCall.args[3]).to.deep.include({
+      expect(listEnvironmentsStub.calledOnce).to.be.true;
+      expect(listEnvironmentsStub.firstCall.args[0]).to.equal("test-org");
+      expect(listEnvironmentsStub.firstCall.args[1]).to.equal(-1); // limit
+      expect(listEnvironmentsStub.firstCall.args[2]).to.equal(0); // offset
+      expect(listEnvironmentsStub.firstCall.args[3]).to.deep.include({
          baseURL: "http://test-server",
          headers: { Authorization: "Bearer test-token" },
       });
       expect(result).to.deep.equal({
-         projects: mockProjects,
+         projects: mockEnvironments,
          totalCount: undefined,
       });
    });
@@ -67,7 +67,7 @@ describe("list-projects", () => {
    it("should return empty array when config doesn't exist", async () => {
       sandbox.restore();
       sandbox = sinon.createSandbox();
-      listProjectsStub = sandbox.stub();
+      listEnvironmentsStub = sandbox.stub();
       loggerStub = sandbox.stub(logger);
       consoleLogStub = sandbox.stub(console, "log");
 
@@ -75,12 +75,12 @@ describe("list-projects", () => {
          .stub(ClientConfiguration.prototype, "doesConfigExists")
          .returns(false);
       sandbox
-         .stub(ProjectsApi.prototype, "listProjects")
-         .callsFake(listProjectsStub);
+         .stub(EnvironmentsApi.prototype, "listEnvironments")
+         .callsFake(listEnvironmentsStub);
 
-      const result = await listProjects("http://test-server", false);
+      const result = await listEnvironments("http://test-server", false);
 
-      expect(listProjectsStub.called).to.be.false;
+      expect(listEnvironmentsStub.called).to.be.false;
       expect(result).to.be.undefined;
       expect(
          loggerStub.error.calledWith(
@@ -91,31 +91,33 @@ describe("list-projects", () => {
 
    it("should return empty array on API error", async () => {
       const mockError = new Error("API Error");
-      listProjectsStub.rejects(mockError);
+      listEnvironmentsStub.rejects(mockError);
 
-      const result = await listProjects("http://test-server", true);
+      const result = await listEnvironments("http://test-server", true);
 
-      expect(listProjectsStub.calledOnce).to.be.true;
+      expect(listEnvironmentsStub.calledOnce).to.be.true;
       expect(result).to.be.undefined;
       expect(
-         loggerStub.error.calledWith(sinon.match("Failed to list projects")),
+         loggerStub.error.calledWith(
+            sinon.match("Failed to list environments"),
+         ),
       ).to.be.true;
    });
 
-   it("should print projects when using printOutProjects", async () => {
-      const mockProjects = [{ name: "project1" }];
+   it("should print environments when using printOutEnvironments", async () => {
+      const mockEnvironments = [{ name: "environment1" }];
       const mockResponse = {
-         data: mockProjects,
+         data: mockEnvironments,
          headers: {},
       };
-      listProjectsStub.resolves(mockResponse);
+      listEnvironmentsStub.resolves(mockResponse);
 
-      await printOutProjects("http://test-server", false);
+      await printOutEnvironments("http://test-server", false);
 
       expect(consoleLogStub.calledOnce).to.be.true;
       const loggedValue = consoleLogStub.firstCall.args[0];
       const parsed = JSON.parse(loggedValue);
       expect(parsed).to.have.property("projects");
-      expect(parsed.projects).to.deep.equal(mockProjects);
+      expect(parsed.projects).to.deep.equal(mockEnvironments);
    });
 });

package/src/commands/{project/listprojects.ts → environment/listenvironments.ts}

@@ -1,4 +1,4 @@
-import { ProjectsApi } from "../../client/api";
+import { EnvironmentsApi } from "../../client/api";
 import { Configuration } from "../../client/configuration";
 import { ClientConfiguration } from "../../clientconfiguration";
 import { logger } from "../../logger";
@@ -9,9 +9,9 @@ import {
    extractTotalCount,
 } from "../../utils";
 
-const projectsApi = new ProjectsApi(new Configuration());
+const environmentsApi = new EnvironmentsApi(new Configuration());
 
-export async function listProjects(
+export async function listEnvironments(
    controlPlane: string,
    debug: boolean,
    page?: string | number,
@@ -27,7 +27,7 @@ export async function listProjects(
    try {
       const { limit, offset } = parsePaginationParams(page, pageSize);
 
-      const response = await projectsApi.listProjects(
+      const response = await environmentsApi.listEnvironments(
          clientConfig.getOrganization(),
          limit,
          offset,
@@ -44,19 +44,24 @@ export async function listProjects(
          totalCount,
       };
    } catch (e) {
-      logger.error("Failed to list projects");
+      logger.error("Failed to list environments");
       printOutError(e, debug);
       return;
    }
 }
 
-export async function printOutProjects(
+export async function printOutEnvironments(
    controlPlane: string,
    debug: boolean,
    page?: string | number,
    pageSize?: string | number,
 ) {
-   const projects = await listProjects(controlPlane, debug, page, pageSize);
+   const environments = await listEnvironments(
+      controlPlane,
+      debug,
+      page,
+      pageSize,
+   );
 
-   console.log(prettifyJson(projects));
+   console.log(prettifyJson(environments));
 }

package/src/commands/{project/setproject.spec.ts → environment/setenvironment.spec.ts}

@@ -2,9 +2,9 @@ import { expect } from "chai";
 import sinon from "sinon";
 import { ClientConfiguration } from "../../clientconfiguration";
 import { logger } from "../../logger";
-import { setProject } from "./setproject";
+import { setEnvironment } from "./setenvironment";
 
-describe("set-project", () => {
+describe("set-environment", () => {
    let sandbox: sinon.SinonSandbox;
    let setProjectStub: sinon.SinonStub;
    let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
@@ -28,13 +28,13 @@ describe("set-project", () => {
       sandbox.restore();
    });
 
-   it("should set project successfully", async () => {
-      await setProject("test-project");
+   it("should set environment successfully", async () => {
+      await setEnvironment("test-environment");
 
       expect(setProjectStub.calledOnce).to.be.true;
-      expect(setProjectStub.firstCall.args[0]).to.equal("test-project");
-      expect(consoleLogStub.calledWith("Setting project test-project")).to.be
-         .true;
+      expect(setProjectStub.firstCall.args[0]).to.equal("test-environment");
+      expect(consoleLogStub.calledWith("Setting environment test-environment"))
+         .to.be.true;
    });
 
    it("should handle missing config", async () => {
@@ -51,7 +51,7 @@ describe("set-project", () => {
          .stub(ClientConfiguration.prototype, "doesConfigExists")
          .returns(false);
 
-      await setProject("test-project");
+      await setEnvironment("test-environment");
 
       expect(setProjectStub.called).to.be.false;
       expect(

package/src/commands/{project/setproject.ts → environment/setenvironment.ts}

@@ -1,14 +1,14 @@
 import { ClientConfiguration } from "../../clientconfiguration";
 import { logger } from "../../logger";
 
-export async function setProject(projectName: string) {
-   console.log("Setting project " + projectName);
+export async function setEnvironment(environmentName: string) {
+   console.log("Setting environment " + environmentName);
    const clientConfig = new ClientConfiguration();
 
    if (!clientConfig.doesConfigExists()) {
       logger.error("Please, make sure that you are logged in");
       return;
    }
-
-   clientConfig.setProject(projectName);
+   //TODO: Validate environment exists and user has access.
+   clientConfig.setProject(environmentName);
 }