@sera4/essentia 1.1.66-rc.1 → 1.1.66

package/test/health.spec.js

@@ -1,213 +0,0 @@
-import { expect, should as chaiShould } from "chai";
-import sinon from "sinon";
-import express from "express";
-import { healthCheck as hc } from "../index.js";
-
-const should = chaiShould();
-
-const mockResponse = () => {
-  const res = {};
-  res.status = sinon.stub().returns(res);
-  res.setHeader = sinon.stub();
-  res.json = sinon.stub().returns(res);
-  res.send = sinon.spy();
-  return res;
-};
-
-/* algorithm for shuffling an array */
-const shuffle = (a) => {
-  for (let i = a.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [a[i], a[j]] = [a[j], a[i]];
-  }
-  return a;
-}
-
-describe("HealthCheck Testing", () => {
-  let healthCheck = new hc();
-
-  describe("Health Check Sanity", () => {
-    it ("Should have NO predefined health checks", () => {
-      return expect(healthCheck.healthChecks).to.be.an('array').that.is.empty;
-    });
-
-    it ("Should have have a sane default path route", () => {
-      return expect(healthCheck.defaultPath()).to.match(/health_check/);
-    });
-
-    it ("Should have have sane response defaults", () => {
-      expect(healthCheck.defaultResponse).to.have.property("status", 200);
-      expect(healthCheck.defaultResponse).to.have.property("errors").to.be.an('object').to.be.empty;
-    })
-  });
-
-  describe("Health Check Router", () => {
-    it ("Should throw without a proper router object", () => {
-      expect(healthCheck.routes.bind(healthCheck)).to.throw('missing_express_router');
-    })
-
-    it ("Should return a proper router object with an improved route", () => {
-      let router = express.Router();
-      let improved_router = healthCheck.routes(router);
-      expect(improved_router).to.equal(router);
-    })
-  });
-
-  describe("Check Health Checks", () => {
-    let req, res;
-
-    beforeEach("Setup hc object", () => {
-      res = mockResponse();
-      req = { baseUrl: "server.example.com/api/health_check.json" };
-      healthCheck = new hc();
-    })
-
-    it ("Returns ok with no additional health check routes defined", (done) => {
-      req = { baseUrl: "server.example.com/api/health_check.json" };
-
-      const expectedResult = { check: 1, healthy: "true", message: "success" }
-
-      healthCheck.checkHealth(req, res)
-        .then((r) => {
-          sinon.assert.alwaysCalledWith(res.status, 200);
-          sinon.assert.calledOnce(res.status);
-          sinon.assert.alwaysCalledWith(res.json, expectedResult)
-          done()
-        });
-    })
-
-    it("Returns success with a simple successful (v1) health check defined", (done) => {
-      const sampleCheck = async () => {
-        return { name: "db", "result": "success", critical: false };
-      }
-
-      healthCheck.addCheck(sampleCheck);
-      expect(healthCheck.healthChecks).to.be.an('array').with.lengthOf(1);
-
-      const expectedResult = { check: 1, healthy: "true", message: "success" }
-      healthCheck.checkHealth(req, res)
-        .then((r) => {
-          sinon.assert.alwaysCalledWith(res.status, 200);
-          sinon.assert.alwaysCalledWith(res.json, expectedResult);
-          done()
-        });
-    })
-
-    it("Returns fail with a failed health check", (done) => {
-      const sampleCheck = async () => {
-        return { name: "db", "result": "fail" };
-      }
-
-      healthCheck.addCheck(sampleCheck);
-      expect(healthCheck.healthChecks).to.be.an('array').with.lengthOf(1);
-
-      const expectedResult = { check: 1, healthy: "false", message: "fail" }
-      healthCheck.checkHealth(req, res)
-        .then(e => { done() })
-        .catch(err => {
-          sinon.assert.alwaysCalledWith(res.status, 500);
-          sinon.assert.alwaysCalledWith(res.json, expectedResult);
-          done()
-        })
-    })
-
-    it("Returns unhealthy with an OK and failed health check", (done) => {
-      const sampleFail = async () => {
-        return { name: "db", "result": "fail" };
-      }
-
-      const sampleSuccess= async () => {
-        return { name: "redis", "result": "success" };
-      }
-
-      shuffle([sampleFail, sampleSuccess]).forEach(el => {
-        healthCheck.addCheck(el);
-      })
-
-      expect(healthCheck.healthChecks).to.be.an('array').with.lengthOf(2);
-
-      healthCheck.checkHealth(req, res)
-        .then(e => { done() })
-        .catch(err => {
-          sinon.assert.alwaysCalledWith(res.status, 500);
-          sinon.assert.alwaysCalledWith(res.json, 'fail');
-          done()
-        })
-    })
-
-    it("Returns healthy/200 when non-critical element fails (v2)", async () => {
-      const sampleCheck= async () => { throw new Error({status: 500}) }
-
-      healthCheck.setupCheck({ name: "sample", critical: false, healthFunction: sampleCheck });
-      expect(healthCheck.healthChecks).to.be.an('array').with.lengthOf(1);
-
-      await healthCheck.checkHealth(req, res)
-
-      sinon.assert.alwaysCalledWith(res.status, 200);
-
-      const expectedResult = {
-        check: 1,
-        healthy: "true",
-        message: "fail",
-        services: [{ critical: false, name: "sample", result: "fail", status: undefined }]
-      }
-      sinon.assert.alwaysCalledWith(res.json, expectedResult);
-    })
-
-    it("Returns unhealthy/500 when a critical component returns failure (v2)", async () => {
-      const sampleCheck= async () => { throw new Error({status: 500}) }
-
-      healthCheck.setupCheck({ name: "sample", critical: true, healthFunction: sampleCheck });
-      expect(healthCheck.healthChecks).to.be.an('array').with.lengthOf(1);
-
-      await healthCheck.checkHealth(req, res)
-
-      const expectedResult = {
-        check: 1, healthy: false,
-        message: "fail",
-        services: [{ critical: true, name: "sample", result: "fail", status: undefined }]
-      }
-      sinon.assert.alwaysCalledWith(res.status, 500);
-      sinon.assert.alwaysCalledWith(res.json, expectedResult);
-    })
-
-    it("Returns unhealthy/500 when a critical component returns failure (v2)", async () => {
-      const sampleCheck= async () => { throw new Error({status: 500}) }
-      const sampleCheck2= async () => { return true }
-
-      healthCheck.setupCheck({ name: "sample", critical: true, healthFunction: sampleCheck });
-      healthCheck.setupCheck({ name: "sample2", critical: true, healthFunction: sampleCheck2 });
-      expect(healthCheck.healthChecks).to.be.an('array').with.lengthOf(2);
-
-      await healthCheck.checkHealth(req, res)
-
-      const expectedResult = {
-        check: 1, healthy: false,
-        message: "fail",
-        services: [
-          { critical: true, name: "sample", result: "fail", status: undefined },
-          { critical: true, name: "sample2", result: "success" }]
-      }
-      sinon.assert.alwaysCalledWith(res.status, 500);
-      sinon.assert.alwaysCalledWith(res.json, expectedResult);
-    })
-
-    it("Returns a different ID each time it runscheck", (done) => {
-      let req2, res2;
-      res2 = mockResponse();
-
-      req = { baseUrl: "server.example.com/api/health_check.json" };
-      req2 = req
-
-      healthCheck.checkHealth(req, res)
-        .then(() => {
-          expect(healthCheck.lastCallId).to.equal(1)
-          healthCheck.checkHealth(req2, res2)
-            .then(() => {
-              expect(healthCheck.lastCallId).to.equal(2)
-              done()
-            })
-        })
-    })
-  })
-});

package/test/prompt.test.js

@@ -1,91 +0,0 @@
-import { expect } from "chai";
-import sinon from "sinon";
-import prompt from "prompt";
-import { ArgumentParser } from 'argparse';
-import logger from "../logger/s4-logger.js";
-
-import { setupCLIParser, cliSleep, promptCLIAsync, commonCLIInit, waitCLIPrompt, continueCLIPrompt } from "../prompts/index.js";
-
-describe("Prompt Functions", () => {
-  describe("Setup Parser", () => {
-    let loggerStub;
-
-    beforeEach(() => {
-      loggerStub = sinon.stub(logger, "info");
-    });
-
-    afterEach(() => {
-      loggerStub.restore();
-    });
-
-    it("should create an ArgumentParser with the given description", () => {
-      const description = "Test Description";
-      const parser = setupCLIParser(description);
-
-      expect(parser).to.be.instanceOf(ArgumentParser);
-      expect(loggerStub.calledWith(description)).to.be.true;
-    });
-  });
-
-  describe("cliSleep", () => {
-    it("should return a promise that resolves after the specified time", async () => {
-      const clock = sinon.useFakeTimers();
-      const ms = 1000;
-
-      const promise = cliSleep(ms);
-      clock.tick(ms);
-
-      await promise;
-      clock.restore();
-    });
-  });
-
-  describe("Prompt Async", () => {
-    let promptStub;
-
-    beforeEach(() => {
-      promptStub = sinon.stub(prompt, "get");
-    });
-
-    afterEach(() => {
-      promptStub.restore();
-    });
-
-    it("should resolve with response when prompt succeeds", async () => {
-      const options = { name: "test" };
-      const mockResponse = { name: "response" };
-
-      promptStub.yields(null, mockResponse);
-
-      const result = await promptCLIAsync(options);
-      expect(result).to.equal(mockResponse);
-      expect(promptStub.calledWith(options)).to.be.true;
-    });
-
-    it("should reject with error when prompt fails", async () => {
-      const options = { name: "test" };
-      const mockError = new Error("Prompt error");
-
-      promptStub.yields(mockError, null);
-
-      try {
-        await promptCLIAsync(options);
-        expect.fail("Should have thrown an error");
-      } catch (error) {
-        expect(error).to.equal(mockError);
-      }
-    });
-  });
-
-  describe("Prompt Objects", () => {
-    it("should define waitPrompt with correct structure", () => {
-      expect(waitCLIPrompt).to.have.property("Push <enter> when done");
-      expect(waitCLIPrompt["Push <enter> when done"]).to.have.property("type", "boolean");
-    });
-
-    it("should define continuePrompt with correct structure", () => {
-      expect(continueCLIPrompt).to.have.property("Push <enter> to continue");
-      expect(continueCLIPrompt["Push <enter> to continue"]).to.have.property("type", "boolean");
-    });
-  });
-});

package/test/s4-formatter.spec.js

@@ -1,80 +0,0 @@
-import should from "should";
-import { expect as expect } from "chai";
-
-import S4Formatter from "../formatter/index.js";
-
-describe("Formatter", function () {
-  let response;
-
-  describe("Sending legacy format []", function () {
-    before("Setup", function () {
-      const error = { status: 200, error: ["error1"] } 
-      response = S4Formatter.formatError(error);
-    })
-
-    describe("Default values", function () {
-      it("should have a generic error", function () {
-        response.should.have.property("errors");
-      });
-
-      it("should have error code set correctly", function () {
-        response.should.have.property("status", 200);
-      });
-    });
-  });
-
-  describe("Support null error payloads", function () {
-    before("Setup", function () {
-      response = S4Formatter.formatError(null);
-    })
-
-    describe("Default values", function () {
-      it("Should have a default error level and blank errors", function () {
-        expect(response).to.have.property("status",422);
-        expect(response).to.have.property("errors").to.be.empty;
-      });
-
-    });
-  });
-
-  describe("Should not fold in funky keys/values", function () {
-    before("Setup", function () {
-      response = S4Formatter.formatError({randomKey: 123});
-    })
-
-    describe("Default values", function () {
-      it("Should not funky key name folded in", function () {
-        response.should.not.have.property("randomKey", {});
-      });
-    });
-  });
-
-  describe("Support validator formats", function () {
-    before("Setup", function () {
-      let error = {
-        "status": 422,
-        "errors": {
-            "password": {
-                "location": "body",
-                "param": "password",
-                "value": "badPassw0rd",
-                "msg": "weak"
-            }
-        }
-      }
-    
-      response = S4Formatter.formatError(error);
-    })
-
-    describe("Default values", function () {
-      it("Should have a default error level and blank errors", function () {
-        response.should.have.property("status", 422);
-        expect(response).to.be.an("object");
-        expect(response).to.have.property('errors');
-        expect(Object.keys(response['errors'])).to.have.lengthOf('1')
-        response.should.have.property("errors");
-      });
-
-    });
-  });
-})

package/test/s4-pagination.spec.js

@@ -1,196 +0,0 @@
-import should from "should";
-import S4Pagination from "../paginator/s4-pagination.js";
-import http_mocks from "node-mocks-http";
-import events from "events";
-
-describe("Pagination", function () {
-  var paginator = null;
-  var request = null;
-  var response = null;
-  var next = null;
-
-  before("Setup", function () {
-    next = function () { };
-    response = http_mocks.createResponse({ eventEmitter: events.EventEmitter });
-    request = http_mocks.createRequest({
-      method: "GET",
-      url: "/"
-    })
-    paginator = S4Pagination.createPaginator(request, response, next);
-  });
-
-  describe("Parsing query parameters", function () {
-    describe("Default values", function () {
-      it("should have default page set to 1", function () {
-        paginator.should.have.property("page", 1);
-      });
-
-      it("should have default page size set to 5", function () {
-        paginator.should.have.property("page_size", 5);
-      });
-    });
-
-    describe("Page value set to 0", function () {
-      before("Setup", function () {
-        request = http_mocks.createRequest({
-          method: "GET",
-          url: "/?page=0"
-        })
-        paginator = S4Pagination.createPaginator(request, response, next);
-      });
-
-      it("should set page to 1", function () {
-        paginator.should.have.property("page", 1);
-      });
-    });
-
-    describe("Page value set to negative", function () {
-      before("Setup", function () {
-        request = http_mocks.createRequest({
-          method: "GET",
-          url: "/?page=-1"
-        })
-        paginator = S4Pagination.createPaginator(request, response, next);
-      });
-
-      it("should set page to 1", function () {
-        paginator.should.have.property("page", 1);
-      });
-    });
-
-    describe("Page value set to 2", function () {
-      before("Setup", function () {
-        request = http_mocks.createRequest({
-          method: "GET",
-          url: "/?page=2"
-        })
-        paginator = S4Pagination.createPaginator(request, response, next);
-      });
-
-      it("should set page to 2", function () {
-        paginator.should.have.property("page", 2);
-      });
-    });
-
-    describe("Page value set to 10", function () {
-      before("Setup", function () {
-        request = http_mocks.createRequest({
-          method: "GET",
-          url: "/?page=10"
-        })
-        paginator = S4Pagination.createPaginator(request, response, next);
-      });
-
-      it("should set page to 10", function () {
-        paginator.should.have.property("page", 10);
-      });
-    });
-
-    describe("Page value set to 100", function () {
-      before("Setup", function () {
-        request = http_mocks.createRequest({
-          method: "GET",
-          url: "/?page=100"
-        })
-        paginator = S4Pagination.createPaginator(request, response, next);
-      });
-
-      it("should set page to 100", function () {
-        paginator.should.have.property("page", 100);
-      });
-    });
-
-    describe("Page Size value set to 0", function () {
-      before("Setup", function () {
-        request = http_mocks.createRequest({
-          method: "GET",
-          url: "/?page_size=0"
-        })
-        paginator = S4Pagination.createPaginator(request, response, next);
-      });
-
-      it("should set page size to 5", function () {
-        paginator.should.have.property("page_size", 5);
-      });
-    });
-
-    describe("Page Size value set to negative", function () {
-      before("Setup", function () {
-        request = http_mocks.createRequest({
-          method: "GET",
-          url: "/?page_size=-1"
-        })
-        paginator = S4Pagination.createPaginator(request, response, next);
-      });
-
-      it("should set page size to 5", function () {
-        paginator.should.have.property("page_size", 5);
-      });
-    });
-
-    describe("Page Size value set to 2", function () {
-      before("Setup", function () {
-        request = http_mocks.createRequest({
-          method: "GET",
-          url: "/?page_size=2"
-        })
-        paginator = S4Pagination.createPaginator(request, response, next);
-      });
-
-      it("should set page size to 5", function () {
-        paginator.should.have.property("page_size", 5);
-      });
-    });
-
-    describe("Page Size value set to 10", function () {
-      before("Setup", function () {
-        request = http_mocks.createRequest({
-          method: "GET",
-          url: "/?page_size=10"
-        })
-        paginator = S4Pagination.createPaginator(request, response, next);
-      });
-
-      it("should set page size to 10", function () {
-        paginator.should.have.property("page_size", 10);
-      });
-    });
-
-    describe("Page Size value set to 100", function () {
-      before("Setup", function () {
-        request = http_mocks.createRequest({
-          method: "GET",
-          url: "/?page_size=100"
-        })
-        paginator = S4Pagination.createPaginator(request, response, next);
-      });
-
-      it("should set page size to 100", function () {
-        paginator.should.have.property("page_size", 100);
-      });
-    });
-  });
-
-  describe("Replying", function() {
-    beforeEach("Clear request", function() {
-      response = http_mocks.createResponse({ eventEmitter: events.EventEmitter });
-      paginator = S4Pagination.createPaginator(request, response, next);
-    });
-
-    it ("should return 500 if data is null", function(){
-      paginator.reply(null);
-      response.statusCode.should.equal(500);
-    });
-
-    it ("should return pagination data", function(){
-      const items = [1,2,3,4,5,6,7,8,9,10];
-      const data = {
-        docs : items,
-        total : items.length,
-      };
-      paginator.reply(data);
-      response.statusCode.should.equal(200);
-      response._getHeaders().should.have.property("s4-pagination");
-    });
-  });
-});

package/test/serializer.spec.js

@@ -1,34 +0,0 @@
-import { expect } from "chai";
-import serializer from "../serializer/index.js";
-
-describe("Serializer", () => {
-
-  describe("Serialize", () => {
-
-    it ("should not show Hidden/Removed fields", () => {
-      const model = { prototype: {} }
-      model.prototype.get = function() { 
-        return { 
-          name: "John",
-          hidden_prefs: "should be hidden",
-          password: "password",
-          password_salt: "password_salt",
-          mfa_totp_secret: "mfa_totp_secret",
-        } 
-      }
-      const options = { hide: ["hidden_prefs"], remove: ["password", "password_salt", "mfa_totp_secret"] }
-      
-      serializer.serialize(model, options);
-      
-      const serialized = model.prototype.toJSON();
-
-      expect(serialized.name).to.eq("John");
-
-      expect(serialized.hidden_prefs).to.be.undefined;
-      expect(serialized.password).to.be.undefined;
-      expect(serialized.password_salt).to.be.undefined;
-      expect(serialized.mfa_totp_secret).to.be.undefined;
-    });
-
-  });
-});