analogger 1.3.0 → 1.4.1

package/.github/workflows/test.yml

@@ -1,4 +1,4 @@
-name: Versioning AnaLogger
+name: Test
 env:
   ANALOGGER_APP_NAME: "release/analogger"
 on:

package/.github/workflows/versioning.yml

@@ -1,4 +1,4 @@
-name: Versioning AnaLogger
+name: Build
 env:
   ANALOGGER_APP_NAME: "release/analogger"
 on:

package/.nycrc

@@ -0,0 +1,20 @@
+{
+    "lines": 95,
+    "statements": 95,
+    "functions": 95,
+    "branches": 50,
+  "reporter": [
+    "json",
+    "text-summary"
+  ],
+  "exclude": [
+    "coverage/**",
+    "docs/**",
+    "test{,s}/**",
+    "test{,-*}.{js,cjs,mjs,ts}",
+    "lib/browser/**",
+    "package-scripts.js",
+    "scripts/**"
+  ],
+  "check-coverage": true
+}

package/CHANGELOG.md

@@ -1 +1,9 @@
+## [1.4.1](https://github.com/thimpat/analogger/compare/v1.4.0...v1.4.1) (2022-02-09)
+
+# [1.4.0](https://github.com/thimpat/analogger/compare/v1.3.2...v1.4.0) (2022-02-09)
+
+## [1.3.2](https://github.com/thimpat/analogger/compare/v1.3.1...v1.3.2) (2022-02-09)
+
+## [1.3.1](https://github.com/thimpat/analogger/compare/v1.3.0...v1.3.1) (2022-02-09)
+
 # [1.3.0](https://github.com/thimpat/analogger/compare/v1.2.0...v1.3.0) (2022-02-08)

package/README.md

@@ -1,4 +1,9 @@
 
+![Test workflow](https://github.com/thimpat/analogger/actions/workflows/test.yml/badge.svg)
+![nycrc Coverage](https://img.shields.io/nycrc/thimpat/analogger?preferredThreshold=lines)
+![Version workflow](https://github.com/thimpat/analogger/actions/workflows/versioning.yml/badge.svg)
+[![npm version](https://badge.fury.io/js/analogger.svg)](https://badge.fury.io/js/analogger)
+
 Analogger is a very simple logger for both Node and the Browser.
 It is a library using both CJS and ESM.
 It serves as a packaging example of **hybrid (CJS/ESM) module**.
@@ -172,10 +177,11 @@ anaLogger.assert((a, b)=> a === b, true, 2, 2)
 
 <br/><br/>
 
-###
+### setErrorHandlerForUserTarget()
 
-When an error is detected and should be seen by your app consumers explicitly (for instance, display a dialogue box
-to them), you can hook your logic.
+When an error is detected and should be seen by your app consumers explicitly (for instance, you want to display a 
+dialogue box
+to them), you can set a handler here. All other console.error will be working as usual (logging messages). 
 
 ```javascript
     anaLogger.setErrorHandlerForUserTarget(function (context/*, ...args*/)
@@ -186,5 +192,9 @@ to them), you can hook your logic.
             // When an error is detected in the Browser, the Browser will see this message
             anaLogger.alert(`Users explicitly see this message`)
         }
-    })
+    });
+
+    anaLogger.setActiveTarget(LOG_TARGETS.USER);
+    anaLogger.error({target: LOG_TARGETS.USER}, "Salut user!");     // Display an alert box
+    anaLogger.error("Hi user!");                                    // Log the message to the inspector
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "analogger",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Js Logger",
   "main": "dist/index-cjs.min.cjs",
   "module": "dist/index-esm.min.mjs",
@@ -17,7 +17,7 @@
     "bundle:prod:cjs": "rollup --config rollup-cjs.config.js",
     "bundle:prod:esm": "rollup --config rollup-esm.config.js",
     "bundle:prod": "npm run convert-cjs:esm && npm run convert-cjs:browser && npm run bundle:prod:cjs && npm run bundle:prod:esm",
-    "test": "mocha",
+    "test": "nyc mocha",
     "demo": "npm run bundle:prod && node example/cjs/demo.cjs"
   },
   "author": "Patrice Thimothee",
@@ -41,14 +41,17 @@
     "babel-eslint": "^10.1.0",
     "capture-console": "^1.0.1",
     "chai": "^4.3.6",
+    "chai-arrays": "^2.2.0",
     "chai-spies": "^1.0.0",
     "eslint": "^8.8.0",
     "mocha": "^9.2.0",
+    "nyc": "^15.1.0",
     "rollup": "^2.67.0",
     "rollup-plugin-delete": "^2.0.0",
     "rollup-plugin-uglify": "^6.0.4",
     "semantic-release": "^19.0.2",
-    "to-esm": "^1.6.2"
+    "sinon": "^13.0.1",
+    "to-esm": "^1.6.4"
   },
   "dependencies": {
     "chalk": "^5.0.0",

package/test/integration.cjs

@@ -1,19 +1,14 @@
 const chai = require("chai");
 var capcon = require('capture-console');
 const {anaLogger} = require("../src/cjs/ana-logger.cjs");
-const {LOG_CONTEXT, LOG_TARGETS} = require("../example/cjs/contexts-def.cjs");
+const {LOG_CONTEXTS, LOG_TARGETS} = require("../example/cjs/contexts-def.cjs");
 const expect = chai.expect;
 
 describe('In the Terminal', function ()
 {
-    const {anaLogger} = require("../src/cjs/ana-logger.cjs");
-
-    const LOG_CONTEXT = {STANDARD: {}, TEST: {color: "#B18904", symbol: "⏰"}, C1: null, C2: null, C3: null, DEFAULT: {}}
-    const LOG_TARGETS = {ALL: "ALL", DEV1: "TOM", DEV2: "TIM", DEV3: "ME", USER: "USER"}
-
     before(()=>
     {
-        anaLogger.setContexts(LOG_CONTEXT);
+        anaLogger.setContexts(LOG_CONTEXTS);
         anaLogger.setTargets(LOG_TARGETS);
     })
 
@@ -38,7 +33,7 @@ describe('In the Terminal', function ()
             expect(captured.stdout).to.contain(`Test Log example C1`)
         });
 
-        it('should hide console output when the console behaviour is overridden', function ()
+        it('should hide console output when the console behaviour is overridden', function (done)
         {
             const captured = capcon.captureStdio(function ()
             {
@@ -46,6 +41,7 @@ describe('In the Terminal', function ()
                 anaLogger.setOptions({silent: true})
                 anaLogger.overrideConsole()
                 console.log(`Log After override`);
+                done()
             })
 
             expect(captured.stdout).to.contain(`Log Before override`)
@@ -58,7 +54,7 @@ describe('In the Terminal', function ()
             {
                 anaLogger.keepLogHistory();
                 anaLogger.setOptions({silent: true, hideError: false})
-                anaLogger.log(LOG_CONTEXT.C1, `Test Log example something again`);
+                anaLogger.log(LOG_CONTEXTS.C1, `Test Log example something again`);
             })
 
             const captured2 = capcon.captureStdio(function ()
@@ -94,8 +90,8 @@ describe('In the Terminal', function ()
             const captured = capcon.captureStdio(function ()
             {
                 anaLogger.setActiveTarget(LOG_TARGETS.DEV3)
-                anaLogger.log({context: LOG_CONTEXT.TEST, target: LOG_TARGETS.DEV3, lid: 100001}, `Test Log example with active target`);
-                anaLogger.log({context: LOG_CONTEXT.TEST, target: LOG_TARGETS.DEV1, lid: 100002}, `Test Log example with DEV1 target`);
+                anaLogger.log({context: LOG_CONTEXTS.TEST, target: LOG_TARGETS.DEV3, lid: 100001}, `Test Log example with active target`);
+                anaLogger.log({context: LOG_CONTEXTS.TEST, target: LOG_TARGETS.DEV1, lid: 100002}, `Test Log example with DEV1 target`);
                 anaLogger.log(`Test Log example with DEFAULT target`);
             })
 
@@ -104,6 +100,17 @@ describe('In the Terminal', function ()
             expect(captured.stdout).to.not.contain(`Test Log example with DEV1 target`)
         });
 
+        it('should not anything when silent mode is enabled', function ()
+        {
+            const captured = capcon.captureStdio(function ()
+            {
+                anaLogger.setOptions({silent: true})
+                anaLogger.log(`Test Log example with DEFAULT target`);
+            })
+
+            expect(captured.stdout).to.not.contain(`Test Log example with DEFAULT target`)
+        });
+
 
     });
 });

package/test/unit.cjs

@@ -1,30 +1,91 @@
 const chai = require("chai");
+const assertArrays = require("chai-arrays")
 const expect = chai.expect;
+const sinon = require("sinon");
+
+let alert, sandbox;
+
+// Arrange
+const myStub = {
+    myMethod: () => { }
+}
+
+
 const spies = require('chai-spies');
 
 chai.use(spies);
+chai.use(assertArrays)
+
 // sut
 const {anaLogger} = require("../src/cjs/ana-logger.cjs");
-const {LOG_CONTEXT} = require("../example/cjs/contexts-def.cjs");
+const {LOG_CONTEXTS, LOG_TARGETS} = require("../example/cjs/contexts-def.cjs");
 
 describe('AnaLogger', function ()
 {
-    const LOG_CONTEXT = {STANDARD: {}, TEST: {color: "#B18904", symbol: "⏰"}, C1: null, C2: null, C3: null, DEFAULT: {}}
-    const LOG_TARGETS = {ALL: "ALL", DEV1: "TOM", DEV2: "TIM", DEV3: "ME", USER: "USER"}
-
     before(() =>
     {
-        anaLogger.setContexts(LOG_CONTEXT);
+        anaLogger.setContexts(LOG_CONTEXTS);
         anaLogger.setTargets(LOG_TARGETS);
         anaLogger.setActiveTarget(LOG_TARGETS.DEV3)
+        anaLogger.removeOverride({error: true})
     })
 
     beforeEach(() =>
     {
+        alert = sinon.spy()
+        chai.spy.on(myStub, 'myMethod');
+
         anaLogger.resetLogHistory()
         anaLogger.keepLogHistory()
+        anaLogger.resetLogFormatter();
     })
 
+    afterEach(()=>
+    {
+        chai.spy.restore(myStub.myMethod)
+    })
+
+    describe('#isContextValid()', function ()
+    {
+        it('should be true when a valid context object is passed', function ()
+        {
+            // Arrange
+            const context = LOG_CONTEXTS.TEST
+            // Act
+            const result = anaLogger.isContextValid(context)
+            // Assert
+            expect(result).to.be.true
+        });
+
+        it('should be false when an invalid context object is passed', function ()
+        {
+            // Arrange
+            const context = {}
+            // Act
+            const result = anaLogger.isContextValid(context)
+            // Assert
+            expect(result).to.be.false
+        });
+
+        it('should be false when a null context is passed', function ()
+        {
+            // Act
+            const result = anaLogger.isContextValid(null)
+            // Assert
+            expect(result).to.be.false
+        });
+    });
+
+    describe('#setOptions()', function ()
+    {
+        it('should have an option to silent the log', function ()
+        {
+            anaLogger.setOptions({silent: true})
+            const options = anaLogger.getOptions()
+            expect(options.silent).to.be.true
+        });
+    });
+
     describe('#log()', function ()
     {
         it('should emulate console.log', function ()
@@ -39,6 +100,174 @@ describe('AnaLogger', function ()
             // Assert
             expect(output).to.contain(`Test Log example C1`)
         });
+
+        it('should understand values passed with context', function ()
+        {
+            // Act
+            anaLogger.log(LOG_CONTEXTS.C1, `Test Log example C1`);
+
+            // Assert
+            expect(anaLogger.getLogHistory()).to.contain(`Test Log example C1`)
+        });
+
+        it('should understand values passed with context as value of object', function ()
+        {
+            // Act
+            anaLogger.log({context: LOG_CONTEXTS.C1}, `Test Log example C1`);
+
+            // Assert
+            expect(anaLogger.getLogHistory()).to.contain(`Test Log example C1`)
+        });
+
+        it('should understand values passed with context defined as null', function ()
+        {
+            // Act
+            anaLogger.log({context: null}, `Test Log example C1`);
+
+            // Assert
+            expect(anaLogger.getLogHistory()).to.contain(`Test Log example C1`)
+        });
+
+        it('should populate history even though the hidelog option is on', function ()
+        {
+            anaLogger.setOptions({hideLog: true})
+
+            // Act
+            anaLogger.log({context: LOG_CONTEXTS.C1, lid: 123456789233}, `The hidden log`);
+
+            // Assert
+            expect(anaLogger.getLogHistory()).to.contain(`The hidden log`)
+        });
+
+        it('should not capture or display log from another defined target', function ()
+        {
+            anaLogger.setActiveTarget(LOG_TARGETS.DEV3)
+            anaLogger.log({target: LOG_TARGETS.DEV1}, `I am for DEV1`);
+
+            // Assert
+            expect(anaLogger.getLogHistory()).to.not.contain(`I am for DEV1`)
+        });
+
+        it('should capture logs when no active target is set', function ()
+        {
+            anaLogger.setActiveTarget(null)
+            anaLogger.log({target: LOG_TARGETS.DEV3}, `I am for DEV3`);
+
+            // Assert
+            expect(anaLogger.getLogHistory()).to.contain(`I am for DEV3`)
+        });
+
+        it('should capture logs from the same target', function ()
+        {
+            anaLogger.setActiveTarget(LOG_TARGETS.DEV3)
+            anaLogger.log({target: LOG_TARGETS.DEV3}, `I am for DEV3`);
+
+            // Assert
+            expect(anaLogger.getLogHistory()).to.contain(`I am for DEV3`)
+        });
+
+        it('should capture logs from the same target', function ()
+        {
+            anaLogger.log(LOG_CONTEXTS.TEST2, `I am for DEV3`);
+
+            // Assert
+            expect(anaLogger.getLogHistory()).to.contain(`I am for DEV3`)
+        });
+
+        it('should truncate some text when too long', function ()
+        {
+            // Act
+            anaLogger.log({
+                context: LOG_CONTEXTS.C1,
+                lid    : 123456789233
+            }, `The super long Log ID (lid) will be truncated`);
+
+            // Assert
+            expect(anaLogger.getLogHistory()).to.contain(`C1: (12... )`)
+        });
+
+
+    });
+
+    describe('#error()', function ()
+    {
+        it('should not show up when hideError mode is on', function ()
+        {
+            // Arrange
+            anaLogger.setOptions({hideError: true})
+
+            // Act
+            anaLogger.error(`Test Log example C1`);
+
+            // Assert
+            expect(anaLogger.getLogHistory()).to.not.contain(`Test Log example C1`)
+        });
+
+        it('should not show up when hideError mode is off', function ()
+        {
+            // Arrange
+            anaLogger.setOptions({hideError: false})
+
+            // Act
+            anaLogger.error(`Test Log example C1`);
+
+            // Assert
+            expect(anaLogger.getLogHistory()).to.contain(`Test Log example C1`)
+        });
+    });
+
+    describe('#info()', function ()
+    {
+        it('should display some log', function ()
+        {
+            anaLogger.info(`Hello from info`)
+            expect(anaLogger.getLogHistory()).to.contain(`Hello from info`)
+        });
+    });
+
+    describe('#warn()', function ()
+    {
+        it('should display some warn', function ()
+        {
+            anaLogger.warn(`Hello from warn`)
+            expect(anaLogger.getLogHistory()).to.contain(`Hello from warn`)
+        });
+    });
+
+    describe('#alert()', function ()
+    {
+        it('should not fail on alert', function ()
+        {
+            anaLogger.alert(`Hello from alert`, {aaa: 1012})
+            expect(anaLogger.getLogHistory()).to.contain(`Hello from alert`)
+        });
+
+        describe("in a non-Node environment", function ()
+        {
+            beforeEach(function ()
+            {
+                sandbox = sinon.createSandbox();
+            });
+
+
+            it('should be called', function ()
+            {
+                sandbox
+                    .stub(anaLogger, "isNode")
+                    .withArgs("Hello from alert")
+                    .returns(
+                        true
+                    );
+
+                chai.expect(() => anaLogger.alert(`Hello from alert`)).to.throw(`alert is not defined`);
+            });
+
+            afterEach(function ()
+            {
+                sandbox.restore();
+            });
+        })
+
     });
 
     describe('#assert()', function ()
@@ -61,19 +290,32 @@ describe('AnaLogger', function ()
             expect(result).to.be.true
         });
 
+        it('should fail when function expressions fail', function ()
+        {
+            const result = anaLogger.assert(() => false, true)
+            expect(result).to.be.false
+        });
+
         it('should evaluate more complex function expressions', function ()
         {
             const result = anaLogger.assert((a, b) => a === b, true, 2, 2)
             expect(result).to.be.true
         });
+
+        it('should not break the code when an invalid function is passed', function ()
+        {
+            expect(anaLogger.assert(() => nonExistentFunctionThatIsCalledAnyway(), true, 2, 2)
+            ).to.be.false
+        });
     });
 
-    describe('#alert()', function ()
+    describe('#overrideConsole()', function ()
     {
-        it('should not fail on alert', function ()
+        it('should override the console behaviour', function ()
         {
-            anaLogger.alert(`Hello from alert`, {aaa: 1012})
-            expect(anaLogger.getLogHistory()).to.contain(`Hello from alert`)
+            anaLogger.overrideConsole({error: true})
+            console.log(`Test 1`)
+            expect(anaLogger.getLogHistory()).to.contain(`Test 1`)
         });
     });
 
@@ -84,21 +326,129 @@ describe('AnaLogger', function ()
          */
         it('should replace the default formatter function with the given callback when invoking console.log', function ()
         {
-            // Arrange
-            const methodToCall = {
-                myMethod: () => { }
-            }
+            beforeEach(function ()
+            {
+            })
+
+            afterEach(function ()
+            {
+                chai.spy.restore(myStub.myMethod)
+            })
+
+            anaLogger.setLogFormat(
+                myStub.myMethod
+            );
 
-            // Spy on methodToCall.myMethod to check it has been called
-            chai.spy.on(methodToCall, 'myMethod');
+            console.log(LOG_CONTEXTS.C1, `Test Log example C4 with new format`);
+            expect(myStub.myMethod).to.have.been.called;
+        });
 
+        it("should reset the formatter to its first value", () =>
+        {
             anaLogger.setLogFormat(
-                methodToCall.myMethod
+                () => "If you see this the test has failed"
             );
+            anaLogger.resetLogFormatter();
+            anaLogger.log(LOG_CONTEXTS.C1, `Test Log example C4 with new format`);
+            expect(anaLogger.getLogHistory()).to.contain(`C1: (      )`)
+        })
+
+        it("should reject invalid formatters", () =>
+        {
+            const res = anaLogger.setLogFormat(null);
+            expect(res).to.be.false
+        })
+    });
 
-            console.log(LOG_CONTEXT.C1, `Test Log example C4 with new format`);
-            expect(methodToCall.myMethod).to.have.been.called;
+    describe('#releaseLogHistory()', function ()
+    {
+        it('should not keep log history', function ()
+        {
+            anaLogger.releaseLogHistory()
+            anaLogger.log(`Hello you`)
+            expect(anaLogger.getLogHistory().length).to.equal(0)
+        });
+    });
+
+    describe('#getLogHistory()', function ()
+    {
+        it('should return history as a string', function ()
+        {
+            anaLogger.log(`Hello you`)
+            const arr = anaLogger.getLogHistory()
+            expect(arr).to.be.string
+        });
+
+        it('should return history as an array', function ()
+        {
+            anaLogger.log(`Hello you`)
+            const arr = anaLogger.getLogHistory(false)
+            expect(arr).to.be.array()
+        });
+
+        it('should return history as an array', function ()
+        {
+            anaLogger.log(`Hello you`)
+            const arr = anaLogger.getLogHistory(false)
+            expect(arr).to.be.array()
+        });
+    });
+
+    describe('#setErrorHandler()', function ()
+    {
+        it('should replace the error manager', function ()
+        {
+            anaLogger.setActiveTarget(LOG_TARGETS.USER)
+            anaLogger.error({target: LOG_TARGETS.USER}, `Test Error Log`);
         });
+
+        it('should replace the error manager', function ()
+        {
+            anaLogger.setErrorHandler(
+                myStub.myMethod
+            );
+
+            console.error(`Test Error Log`);
+            expect(myStub.myMethod).to.have.been.called;
+        });
+
+        it('should replace the error manager targeting the user', function ()
+        {
+            anaLogger.setActiveTarget(LOG_TARGETS.USER)
+            anaLogger.setErrorHandler(
+                myStub.myMethod
+            );
+
+            anaLogger.error(`Test Error Log`);
+            expect(myStub.myMethod).to.have.been.called;
+        });
+
+    });
+
+    describe('#setErrorHandlerForUserTarget()', function ()
+    {
+        it('should replace the error manager targetting the user', function ()
+        {
+            anaLogger.setActiveTarget(LOG_TARGETS.USER)
+            anaLogger.setErrorHandlerForUserTarget(
+                myStub.myMethod
+            );
+
+            anaLogger.error(`Test Error Log`);
+            expect(myStub.myMethod).to.have.been.called;
+        });
+
+        it('should replace the error manager targeting the user', function ()
+        {
+            anaLogger.setActiveTarget(LOG_TARGETS.USER)
+            anaLogger.setErrorHandlerForUserTarget(
+                myStub.myMethod
+            );
+
+            anaLogger.error(`Test Error Log`);
+            expect(myStub.myMethod).to.have.been.called;
+        });
+
     });