@credibledata/cred-cli 0.1.3 → 0.1.5

package/src/commands/package/publish.spec.ts

@@ -0,0 +1,597 @@
+import { expect } from "chai";
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import sinon from "sinon";
+import { PackagesApi } from "../../client/api";
+import { ClientConfiguration } from "../../clientconfiguration";
+import { logger } from "../../logger";
+import { prettifyJson } from "../../utils";
+
+// We need to stub archiver before publish.ts imports it.
+// Since this is CommonJS, we replace archiver in the require cache.
+let storedCloseCallback: Function | undefined;
+let mockArchive: any;
+
+function createMockArchive(sandbox: sinon.SinonSandbox) {
+   storedCloseCallback = undefined;
+
+   mockArchive = {
+      on: sandbox.stub().returnsThis(),
+      directory: sandbox.stub().returnsThis(),
+      pipe: sandbox.stub().returnsThis(),
+      finalize: sandbox.stub().callsFake(function () {
+         // Trigger the close event on the WriteStream when finalize is called
+         if (storedCloseCallback) {
+            // Use process.nextTick to ensure it fires after the promise is set up
+            process.nextTick(() => storedCloseCallback!());
+         }
+         return mockArchive;
+      }),
+      pointer: sandbox.stub().returns(1024),
+   };
+   return mockArchive;
+}
+
+describe("publish", () => {
+   let sandbox: sinon.SinonSandbox;
+   let createOrUpdatePackageStub: sinon.SinonStub;
+   let loggerStub: sinon.SinonStubbedInstance<typeof logger>;
+   let getConfirmationStub: sinon.SinonStub;
+   let readFileSyncStub: sinon.SinonStub;
+   let existsSyncStub: sinon.SinonStub;
+   let unlinkStub: sinon.SinonStub;
+   let createWriteStreamStub: sinon.SinonStub;
+   let validateManifestStub: sinon.SinonStub;
+   let processCwdStub: sinon.SinonStub;
+   let publish: (
+      controlPlane: string,
+      replicationCount: number,
+      debug: boolean,
+      autoConfirm: boolean,
+      setLatest: boolean,
+   ) => Promise<void>;
+
+   // Store the original archiver module so we can restore it
+   let originalArchiverModule: any;
+   const archiverModulePath = require.resolve("archiver");
+
+   beforeEach(() => {
+      sandbox = sinon.createSandbox();
+
+      // Create mock archive
+      const archive = createMockArchive(sandbox);
+
+      // Replace archiver in require cache with our mock factory
+      originalArchiverModule = require.cache[archiverModulePath];
+      require.cache[archiverModulePath] = {
+         id: archiverModulePath,
+         filename: archiverModulePath,
+         loaded: true,
+         exports: function () {
+            return archive;
+         },
+      } as any;
+
+      // Clear publish module from cache so it picks up the stubbed archiver
+      const publishModulePath = require.resolve("./publish");
+      delete require.cache[publishModulePath];
+
+      // Now require publish - it will get our mock archiver
+      publish = require("./publish").publish;
+
+      createOrUpdatePackageStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+      readFileSyncStub = sandbox.stub(fs, "readFileSync");
+      existsSyncStub = sandbox.stub(fs, "existsSync");
+      unlinkStub = sandbox.stub(fs, "unlink");
+      createWriteStreamStub = sandbox.stub(fs, "createWriteStream");
+      validateManifestStub = sandbox.stub();
+      sandbox.stub(console, "log");
+      processCwdStub = sandbox.stub(process, "cwd");
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox
+         .stub(ClientConfiguration.prototype, "getProject")
+         .returns("test-project");
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "isTokenValid")
+         .returns({ valid: true });
+      sandbox
+         .stub(ClientConfiguration.prototype, "getHeaders")
+         .returns({ Authorization: "Bearer test-token" });
+
+      sandbox
+         .stub(PackagesApi.prototype, "createOrUpdatePackage")
+         .callsFake(createOrUpdatePackageStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+      sandbox
+         .stub(require("../../validator"), "validateManifest")
+         .callsFake(validateManifestStub);
+
+      processCwdStub.returns("/test/package-name");
+      validateManifestStub.returns(true);
+      existsSyncStub.returns(true);
+
+      // Mock write stream that captures the close callback
+      const mockWriteStream = {
+         on: sandbox.stub().callsFake(function (
+            event: string,
+            callback: Function,
+         ) {
+            if (event === "close") {
+               storedCloseCallback = callback;
+            }
+            return mockWriteStream;
+         }),
+         once: sandbox.stub().returnsThis(),
+         emit: sandbox.stub().returnsThis(),
+         write: sandbox.stub(),
+         end: sandbox.stub(),
+         pipe: sandbox.stub().returnsThis(),
+      };
+      createWriteStreamStub.returns(mockWriteStream);
+   });
+
+   afterEach(() => {
+      sandbox.restore();
+      // Restore original archiver module
+      if (originalArchiverModule) {
+         require.cache[archiverModulePath] = originalArchiverModule;
+      } else {
+         delete require.cache[archiverModulePath];
+      }
+   });
+
+   it("should publish package successfully", async function () {
+      this.timeout(5000);
+      const mockManifest = {
+         name: "test-package",
+         version: "1.0.0",
+         description: "Test package",
+      };
+      const mockPackageData = Buffer.from("test package data");
+      const mockResponse = {
+         data: { name: "test-package", version: "1.0.0" },
+      };
+
+      readFileSyncStub.callsFake((filePath: string) => {
+         if (filePath === "publisher.json") return JSON.stringify(mockManifest);
+         return mockPackageData;
+      });
+      getConfirmationStub.resolves(true);
+      createOrUpdatePackageStub.resolves(mockResponse);
+      unlinkStub.callsArg(1);
+
+      await publish("http://test-server", 2, false, true, false);
+
+      expect(validateManifestStub.calledOnce).to.be.true;
+      expect(readFileSyncStub.calledWith("publisher.json")).to.be.true;
+      expect(createOrUpdatePackageStub.calledOnce).to.be.true;
+      expect(createOrUpdatePackageStub.firstCall.args[0]).to.equal("test-org");
+      expect(createOrUpdatePackageStub.firstCall.args[1]).to.equal(
+         "test-project",
+      );
+      expect(createOrUpdatePackageStub.firstCall.args[2]).to.equal(
+         "test-package",
+      );
+      expect(createOrUpdatePackageStub.firstCall.args[3]).to.deep.include({
+         name: "test-package",
+         description: "Test package",
+         replicationCount: 2,
+      });
+      expect(createOrUpdatePackageStub.firstCall.args[4]).to.deep.include({
+         id: "1.0.0",
+      });
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match(prettifyJson(mockResponse.data)),
+         ),
+      ).to.be.true;
+   });
+
+   it("should set latest version when setLatest is true", async function () {
+      this.timeout(5000);
+      const mockManifest = {
+         name: "test-package",
+         version: "1.0.0",
+         description: "Test package",
+      };
+      const mockPackageData = Buffer.from("test package data");
+
+      readFileSyncStub.callsFake((filePath: string) => {
+         if (filePath === "publisher.json") return JSON.stringify(mockManifest);
+         return mockPackageData;
+      });
+      getConfirmationStub.resolves(true);
+      createOrUpdatePackageStub.resolves({ data: {} });
+      unlinkStub.callsArg(1);
+
+      await publish("http://test-server", 2, false, true, true);
+
+      expect(createOrUpdatePackageStub.firstCall.args[3]).to.deep.include({
+         latestVersion: "1.0.0",
+      });
+   });
+
+   it("should not set latest version when setLatest is false", async function () {
+      this.timeout(5000);
+      const mockManifest = {
+         name: "test-package",
+         version: "1.0.0",
+         description: "Test package",
+      };
+      const mockPackageData = Buffer.from("test package data");
+
+      readFileSyncStub.callsFake((filePath: string) => {
+         if (filePath === "publisher.json") return JSON.stringify(mockManifest);
+         return mockPackageData;
+      });
+      getConfirmationStub.resolves(true);
+      createOrUpdatePackageStub.resolves({ data: {} });
+      unlinkStub.callsArg(1);
+
+      await publish("http://test-server", 2, false, true, false);
+
+      expect(createOrUpdatePackageStub.firstCall.args[3]).to.not.have.property(
+         "latestVersion",
+      );
+   });
+
+   it("should skip confirmation when autoConfirm is true", async function () {
+      this.timeout(5000);
+      const mockManifest = {
+         name: "test-package",
+         version: "1.0.0",
+         description: "Test package",
+      };
+      const mockPackageData = Buffer.from("test package data");
+
+      readFileSyncStub.callsFake((filePath: string) => {
+         if (filePath === "publisher.json") return JSON.stringify(mockManifest);
+         return mockPackageData;
+      });
+      createOrUpdatePackageStub.resolves({ data: {} });
+      unlinkStub.callsArg(1);
+
+      await publish("http://test-server", 2, false, true, false);
+
+      expect(getConfirmationStub.called).to.be.false;
+      expect(createOrUpdatePackageStub.calledOnce).to.be.true;
+   });
+
+   it("should use package name from cwd directory", async function () {
+      this.timeout(5000);
+      processCwdStub.returns("/some/path/my-cool-package");
+      const mockManifest = {
+         name: "test-package",
+         version: "1.0.0",
+         description: "Test package",
+      };
+      const mockPackageData = Buffer.from("test package data");
+
+      readFileSyncStub.callsFake((filePath: string) => {
+         if (filePath === "publisher.json") return JSON.stringify(mockManifest);
+         return mockPackageData;
+      });
+      createOrUpdatePackageStub.resolves({ data: {} });
+      unlinkStub.callsArg(1);
+
+      await publish("http://test-server", 2, false, true, false);
+
+      // The archive path should use the cwd directory name
+      expect(createWriteStreamStub.calledWith("/tmp/my-cool-package.zip")).to.be
+         .true;
+   });
+
+   it("should calculate MD5 hash correctly", async function () {
+      this.timeout(5000);
+      const mockManifest = {
+         name: "test-package",
+         version: "1.0.0",
+         description: "Test package",
+      };
+      const mockPackageData = Buffer.from("test package data");
+      const expectedHash = crypto
+         .createHash("md5")
+         .update(mockPackageData)
+         .digest("hex");
+
+      readFileSyncStub.callsFake((filePath: string) => {
+         if (filePath === "publisher.json") return JSON.stringify(mockManifest);
+         return mockPackageData;
+      });
+      getConfirmationStub.resolves(true);
+      createOrUpdatePackageStub.resolves({ data: {} });
+      unlinkStub.callsArg(1);
+
+      await publish("http://test-server", 2, false, true, false);
+
+      expect(createOrUpdatePackageStub.firstCall.args[6]).to.equal(
+         expectedHash,
+      );
+   });
+
+   it("should handle missing config", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      createOrUpdatePackageStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+      readFileSyncStub = sandbox.stub(fs, "readFileSync");
+      existsSyncStub = sandbox.stub(fs, "existsSync");
+      validateManifestStub = sandbox.stub();
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(false);
+      sandbox
+         .stub(PackagesApi.prototype, "createOrUpdatePackage")
+         .callsFake(createOrUpdatePackageStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+      sandbox
+         .stub(require("../../validator"), "validateManifest")
+         .callsFake(validateManifestStub);
+
+      await publish("http://test-server", 2, false, true, false);
+
+      expect(createOrUpdatePackageStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure that you are logged in"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle invalid token", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      createOrUpdatePackageStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+      readFileSyncStub = sandbox.stub(fs, "readFileSync");
+      existsSyncStub = sandbox.stub(fs, "existsSync");
+      validateManifestStub = sandbox.stub();
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "isTokenValid")
+         .returns({ valid: false, reason: "No token found. Please login." });
+      sandbox
+         .stub(PackagesApi.prototype, "createOrUpdatePackage")
+         .callsFake(createOrUpdatePackageStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+      sandbox
+         .stub(require("../../validator"), "validateManifest")
+         .callsFake(validateManifestStub);
+
+      await publish("http://test-server", 2, false, true, false);
+
+      expect(createOrUpdatePackageStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("No token found. Please login."),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle invalid manifest", async () => {
+      validateManifestStub.returns(false);
+
+      await publish("http://test-server", 2, false, true, false);
+
+      expect(createOrUpdatePackageStub.called).to.be.false;
+   });
+
+   it("should handle missing organization", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      createOrUpdatePackageStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+      readFileSyncStub = sandbox.stub(fs, "readFileSync");
+      existsSyncStub = sandbox.stub(fs, "existsSync");
+      validateManifestStub = sandbox.stub();
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "isTokenValid")
+         .returns({ valid: true });
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("");
+      validateManifestStub.returns(true);
+      sandbox
+         .stub(PackagesApi.prototype, "createOrUpdatePackage")
+         .callsFake(createOrUpdatePackageStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+      sandbox
+         .stub(require("../../validator"), "validateManifest")
+         .callsFake(validateManifestStub);
+
+      await publish("http://test-server", 2, false, true, false);
+
+      expect(createOrUpdatePackageStub.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 project", async () => {
+      sandbox.restore();
+      sandbox = sinon.createSandbox();
+      createOrUpdatePackageStub = sandbox.stub();
+      loggerStub = sandbox.stub(logger);
+      getConfirmationStub = sandbox.stub();
+      readFileSyncStub = sandbox.stub(fs, "readFileSync");
+      existsSyncStub = sandbox.stub(fs, "existsSync");
+      validateManifestStub = sandbox.stub();
+
+      sandbox
+         .stub(ClientConfiguration.prototype, "doesConfigExists")
+         .returns(true);
+      sandbox
+         .stub(ClientConfiguration.prototype, "isTokenValid")
+         .returns({ valid: true });
+      sandbox
+         .stub(ClientConfiguration.prototype, "getOrganization")
+         .returns("test-org");
+      sandbox.stub(ClientConfiguration.prototype, "getProject").returns("");
+      validateManifestStub.returns(true);
+      sandbox
+         .stub(PackagesApi.prototype, "createOrUpdatePackage")
+         .callsFake(createOrUpdatePackageStub);
+      sandbox
+         .stub(require("../../utils"), "getConfirmation")
+         .callsFake(getConfirmationStub);
+      sandbox
+         .stub(require("../../validator"), "validateManifest")
+         .callsFake(validateManifestStub);
+
+      await publish("http://test-server", 2, false, true, false);
+
+      expect(createOrUpdatePackageStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match("Please, make sure to set a project"),
+         ),
+      ).to.be.true;
+   });
+
+   it("should handle missing publisher.json", async () => {
+      existsSyncStub.callsFake((filePath: string) => {
+         if (filePath === "publisher.json") return false;
+         return true;
+      });
+
+      await publish("http://test-server", 2, false, true, false);
+
+      expect(createOrUpdatePackageStub.called).to.be.false;
+      expect(readFileSyncStub.called).to.be.false;
+      expect(
+         loggerStub.error.calledWith(
+            sinon.match(
+               "Failed to publish the package. Could not find publisher.json, please ensure you are in a directory containing publisher.json",
+            ),
+         ),
+      ).to.be.true;
+   });
+
+   it("should request confirmation when autoConfirm is false", async function () {
+      this.timeout(5000);
+      const mockManifest = {
+         name: "test-package",
+         version: "1.0.0",
+         description: "Test package",
+      };
+      const mockPackageData = Buffer.from("test package data");
+
+      readFileSyncStub.callsFake((filePath: string) => {
+         if (filePath === "publisher.json") return JSON.stringify(mockManifest);
+         return mockPackageData;
+      });
+      getConfirmationStub.resolves(true);
+      createOrUpdatePackageStub.resolves({ data: {} });
+      unlinkStub.callsArg(1);
+
+      await publish("http://test-server", 2, false, false, false);
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(createOrUpdatePackageStub.calledOnce).to.be.true;
+   });
+
+   it("should cancel when confirmation is denied", async () => {
+      const mockManifest = {
+         name: "test-package",
+         version: "1.0.0",
+         description: "Test package",
+      };
+
+      readFileSyncStub.returns(JSON.stringify(mockManifest));
+      getConfirmationStub.resolves(false);
+
+      await publish("http://test-server", 2, false, false, false);
+
+      expect(getConfirmationStub.calledOnce).to.be.true;
+      expect(createOrUpdatePackageStub.called).to.be.false;
+      expect(loggerStub.info.calledWith(sinon.match("Operation cancelled."))).to
+         .be.true;
+   });
+
+   it("should handle API errors", async function () {
+      this.timeout(5000);
+      const mockManifest = {
+         name: "test-package",
+         version: "1.0.0",
+         description: "Test package",
+      };
+      const mockPackageData = Buffer.from("test package data");
+      const mockError = new Error("API Error");
+
+      readFileSyncStub.callsFake((filePath: string) => {
+         if (filePath === "publisher.json") return JSON.stringify(mockManifest);
+         return mockPackageData;
+      });
+      getConfirmationStub.resolves(true);
+      createOrUpdatePackageStub.rejects(mockError);
+      unlinkStub.callsArg(1);
+
+      await publish("http://test-server", 2, true, true, false);
+
+      expect(createOrUpdatePackageStub.calledOnce).to.be.true;
+      expect(
+         loggerStub.error.calledWith(sinon.match("Failed to publish package")),
+      ).to.be.true;
+   });
+
+   it("should log package URL after successful publish", async function () {
+      this.timeout(5000);
+      const mockManifest = {
+         name: "test-package",
+         version: "1.0.0",
+         description: "Test package",
+      };
+      const mockPackageData = Buffer.from("test package data");
+      const mockResponse = {
+         data: { name: "test-package", version: "1.0.0" },
+      };
+
+      readFileSyncStub.callsFake((filePath: string) => {
+         if (filePath === "publisher.json") return JSON.stringify(mockManifest);
+         return mockPackageData;
+      });
+      getConfirmationStub.resolves(true);
+      createOrUpdatePackageStub.resolves(mockResponse);
+      unlinkStub.callsArg(1);
+
+      await publish("http://test-server", 2, false, true, false);
+
+      expect(
+         loggerStub.info.calledWith(
+            sinon.match(
+               "Package available at: test-org/test-project/test-package/1.0.0",
+            ),
+         ),
+      ).to.be.true;
+   });
+});

package/src/commands/package/publish.ts

@@ -27,6 +27,14 @@ export async function publish(
       return;
    }
 
+   const tokenValidation = clientConfig.isTokenValid();
+   if (!tokenValidation.valid) {
+      logger.error(
+         tokenValidation.reason || "Please, make sure that you are logged in",
+      );
+      return;
+   }
+
    if (!validateManifest()) {
       return;
    }
@@ -34,11 +42,23 @@ export async function publish(
    const projectName = clientConfig.getProject();
    const organizationName = clientConfig.getOrganization();
 
+   if (!organizationName) {
+      logger.error("Please, make sure that you are logged in");
+      return;
+   }
+
    if (!projectName) {
       logger.error("Please, make sure to set a project");
       return;
    }
 
+   if (!fs.existsSync(PACKAGE_MANIFEST_NAME)) {
+      logger.error(
+         `Failed to publish the package. Could not find ${PACKAGE_MANIFEST_NAME}, please ensure you are in a directory containing ${PACKAGE_MANIFEST_NAME}`,
+      );
+      return;
+   }
+
    const packageManifestJson = fs.readFileSync(PACKAGE_MANIFEST_NAME);
    const packageManifest = JSON.parse(packageManifestJson.toString());
 
@@ -141,6 +161,18 @@ async function pushTmpPackageToRemoteServer(
          .createHash("md5")
          .update(fs.readFileSync(tmpPackagePath))
          .digest("hex");
+      if (debug) {
+         logger.debug("Package contents: " + packageContents);
+         logger.debug("Organization name: " + organizationName);
+         logger.debug("Project name: " + projectName);
+         logger.debug("Name: " + name);
+         logger.debug("Package: " + JSON.stringify(_package));
+         logger.debug("Version: " + JSON.stringify(version));
+         logger.debug("Control plane: " + controlPlane);
+         logger.debug(
+            "Client config: " + JSON.stringify(clientConfig.getHeaders()),
+         );
+      }
       const response = await packagesApi.createOrUpdatePackage(
          organizationName,
          projectName,