@n42/cli 0.2.42 → 0.2.72

package/test/utils.test.js

@@ -1,15 +1,83 @@
-const { buildDocLabel } = require("../src/utils");
 const { expect } = require("chai");
+const sinon = require("sinon");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const config = require("../src/config");
+const db = require("../src/db");
+
+const TEST_ROOT = path.join(os.tmpdir(), "node42-utils-test");
 
 describe("utils", () => {
+  let utils;
+
+  beforeEach(() => {
+    sinon.restore();
+
+    // isolate fs paths
+    sinon.stub(config, "NODE42_DIR").value(TEST_ROOT);
+    sinon.stub(config, "ARTEFACTS_DIR").value(path.join(TEST_ROOT, "artefacts"));
+    sinon.stub(config, "TRANSACTIONS_DIR").value(path.join(TEST_ROOT, "transactions"));
+    sinon.stub(config, "VALIDATIONS_DIR").value(path.join(TEST_ROOT, "validations"));
+    sinon.stub(config, "CONFIG_FILE").value(path.join(TEST_ROOT, "config.json"));
+    sinon.stub(config, "TOKENS_FILE").value(path.join(TEST_ROOT, "tokens.json"));
+    sinon.stub(config, "DATABASE_FILE").value(path.join(TEST_ROOT, "db.json"));
+
+    if (fs.existsSync(TEST_ROOT)) {
+      fs.rmSync(TEST_ROOT, { recursive: true, force: true });
+    }
+
+    delete require.cache[require.resolve("../src/utils")];
+    utils = require("../src/utils");
+  });
+
+  afterEach(() => {
+    sinon.restore();
+    if (fs.existsSync(TEST_ROOT)) {
+      fs.rmSync(TEST_ROOT, { recursive: true, force: true });
+    }
+  });
+
+  /* ---------- PURE HELPERS ---------- */
+
+  it("capitalizes string", () => {
+    expect(utils.capitalize("test")).to.equal("Test");
+  });
+
+  it("returns short id", () => {
+    expect(utils.getShortId("1234567890")).to.equal("12345678");
+  });
+
+  it("returns artefact extension", () => {
+    expect(utils.getArtefactExt("plantuml", "svg")).to.equal("svg");
+    expect(utils.getArtefactExt("plantuml", "text")).to.equal("puml");
+    expect(utils.getArtefactExt("json")).to.equal("json");
+  });
+
+  /* ---------- VALIDATION ---------- */
+
+  it("validates environment", () => {
+    expect(() => utils.validateEnv("TEST")).to.not.throw();
+    expect(() => utils.validateEnv("prod")).to.not.throw();
+    expect(() => utils.validateEnv("BAD")).to.throw();
+  });
+
+  it("validates participant id", () => {
+    expect(() => utils.validateId("participant", "9915:abc123")).to.not.throw();
+    expect(() => utils.validateId("participant", "bad-id")).to.throw();
+  });
+
+  /* ---------- buildDocLabel ---------- */
+
   describe("buildDocLabel()", () => {
     it("formats wildcard invoice", () => {
       const doc = {
-          scheme: "peppol-doctype-wildcard",
-          value: "urn:oasis:names:specification:ubl:schema:xsd:Invoice-2::Invoice##*"
+        scheme: "peppol-doctype-wildcard",
+        value: "urn:oasis:names:specification:ubl:schema:xsd:Invoice-2::Invoice##*"
       };
 
-      expect(buildDocLabel(doc)).to.equal("Any Invoice (Wildcard)");
+      expect(utils.buildDocLabel(doc)).to.equal("Any Invoice (Wildcard)");
     });
 
     it("formats BIS invoice", () => {
@@ -18,12 +86,42 @@ describe("utils", () => {
         value: "urn:oasis:names:specification:ubl:schema:xsd:Invoice-2::Invoice##urn:cen.eu:en16931:2017"
       };
 
-      expect(buildDocLabel(doc)).to.equal("Invoice (BIS 3)");
+      expect(utils.buildDocLabel(doc)).to.equal("Invoice (BIS 3)");
     });
 
     it("falls back on 'unknown' value", () => {
       const doc = { scheme: "busdox-docid-qns", value: "unknown" };
-      expect(buildDocLabel(doc)).to.equal("Document");
+      expect(utils.buildDocLabel(doc)).to.equal("Document");
     });
   });
-});
+
+  /* ---------- FS / SIDE EFFECTS ---------- */
+
+  it("creates application directories and config", () => {
+    utils.createAppDirs(true);
+
+    expect(fs.existsSync(config.NODE42_DIR)).to.be.true;
+    expect(fs.existsSync(config.ARTEFACTS_DIR)).to.be.true;
+    expect(fs.existsSync(config.CONFIG_FILE)).to.be.true;
+  });
+
+  it("cleans artefacts directory", () => {
+    fs.mkdirSync(config.ARTEFACTS_DIR, { recursive: true });
+    fs.writeFileSync(path.join(config.ARTEFACTS_DIR, "x"), "x");
+
+    sinon.stub(db, "clear");
+
+    utils.cleanAppDirs({ artefacts: true });
+
+    expect(fs.existsSync(config.ARTEFACTS_DIR)).to.be.true;
+    expect(fs.readdirSync(config.ARTEFACTS_DIR)).to.have.length(0);
+  });
+
+  it("prints message when nothing to clean", () => {
+    sinon.stub(console, "log");
+
+    utils.cleanAppDirs({});
+
+    expect(console.log.calledWithMatch("Nothing to clean")).to.be.true;
+  });
+});

package/test/validator.test.js

@@ -0,0 +1,66 @@
+const { expect } = require("chai");
+const sinon = require("sinon");
+
+const utils = require("../src/utils");
+const errors = require("../src/errors");
+
+describe("runValidation()", () => {
+  let validator;
+  let fetchStub;
+  let spinnerStub;
+  let handleErrorStub;
+  let exitStub;
+
+  beforeEach(() => {
+    sinon.restore();
+
+    delete require.cache[require.resolve("../src/auth")];
+    delete require.cache[require.resolve("../src/validator")];
+
+    const auth = require("../src/auth");
+    fetchStub = sinon.stub(auth, "fetchWithAuth").resolves({
+      ok: true,
+      json: async () => ({ sections: [] })
+    });
+
+    handleErrorStub = sinon.stub(errors, "handleError").resolves();
+    spinnerStub = sinon.stub(utils, "startSpinner").returns(() => {});
+    exitStub = sinon.stub(process, "exit").throws(new Error("exit"));
+
+    validator = require("../src/validator");
+  });
+
+  afterEach(() => sinon.restore());
+
+  it("sends XML to validator endpoint and handles successful response", async () => {
+    await validator.runValidation(
+      "Invoice.xml",
+      "<xml></xml>",
+      { ruleset: "current" }
+    );
+
+    expect(fetchStub.calledOnce).to.equal(true);
+    expect(handleErrorStub.notCalled).to.equal(true);
+    expect(exitStub.notCalled).to.equal(true);
+  });
+
+  it("handles validator error response and exits", async () => {
+    fetchStub.resolves({
+      ok: false,
+      status: 400,
+      json: async () => ({ code: "VALIDATION_FAILED" })
+    });
+
+    try {
+      await validator.runValidation(
+        "Invoice.xml",
+        "<xml></xml>",
+        { ruleset: "current" }
+      );
+    } catch {}
+
+    expect(fetchStub.calledOnce).to.equal(true);
+    expect(handleErrorStub.calledOnce).to.equal(true);
+    expect(process.exit.calledWith(1)).to.be.true;
+  });
+});

package/jest.config.js

@@ -1,6 +0,0 @@
-module.exports = {
-  testEnvironment: "node",
-  verbose: true,
-  coverageDirectory: "coverage",
-  testMatch: ["**/test/**/*.test.js"]
-};

package/src/browser.js

@@ -1,11 +0,0 @@
-const open = require("open").default;
-let browserOpened = false;
-
-
-async function openOnce(target) {
-  if (browserOpened) return;
-  browserOpened = true;
-  await open(target, { wait: false });
-}
-
-module.exports = { openOnce };