render-script 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "render-script",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "main": "./lib/index.cjs",
   "type": "module",
   "author": {
@@ -16,6 +16,7 @@
   "scripts": {
     "lint": "eslint . --ext .cjs --ext .mjs",
     "lint:fix": "npm run lint -- --fix",
+    "test": "cross-env NODE_ENV=test mocha test --recursive --verbose --color",
     "clean": "rimraf lib",
     "build": "npm run babel",
     "babel": "babel src -d lib --out-file-extension .cjs",
@@ -32,19 +33,20 @@
     "@babel/eslint-parser": "^7.15.8",
     "@babel/preset-env": "^7.15.8",
     "babel-plugin-module-resolver": "^4.1.0",
+    "chai": "^4.3.4",
     "core-js": "^3.18.3",
+    "cross-env": "^7.0.3",
     "eslint": "7.12.1",
     "eslint-config-standard": "^16.0.3",
     "eslint-import-resolver-babel-module": "^5.3.1",
     "eslint-plugin-import": "^2.25.2",
+    "eslint-plugin-mocha": "^9.0.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^5.1.0",
     "husky": "^7.0.2",
+    "mocha": "^9.1.3",
     "rimraf": "^3.0.2"
   },
-  "imports": {
-    "#~": "./src/index.mjs"
-  },
   "exports": {
     "import": "./src/index.mjs",
     "require": "./lib/index.cjs"

package/test/.eslintrc

@@ -0,0 +1,5 @@
+{
+  "env": {
+    "mocha": true
+  }
+}

package/test/index.spec.mjs

@@ -0,0 +1,302 @@
+import {
+  expect
+} from 'chai'
+
+import evaluate, {
+  evaluateRuleForConfiguration,
+  getRuleMap,
+  getConfigurationMap,
+  getEvaluation
+} from 'render-script'
+
+describe('~', () => {
+  describe('`evaluate`', () => {
+    it('is a function', () => {
+      return expect(evaluate)
+        .to.be.a('function')
+    })
+  })
+
+  describe('`evaluateRuleForConfiguration`', () => {
+    it('is a function', () => {
+      return expect(evaluateRuleForConfiguration)
+        .to.be.a('function')
+    })
+  })
+
+  describe('`getRuleMap`', () => {
+    it('is a function', () => {
+      return expect(getRuleMap)
+        .to.be.a('function')
+    })
+  })
+
+  describe('`getConfigurationMap`', () => {
+    it('is a function', () => {
+      return expect(getConfigurationMap)
+        .to.be.a('function')
+    })
+  })
+
+  describe('`getEvaluation`', () => {
+    it('is a function', () => {
+      return expect(getEvaluation)
+        .to.be.a('function')
+    })
+  })
+
+  describe('`evaluate()`', () => {
+    describe('`rule` has rules', () => {
+      describe('`configuration` has configuration', () => {
+        describe('`configuration` has a match', () => {
+          it('returns true', () => {
+            return expect(evaluate('+A', '+A'))
+              .to.be.true
+          })
+        })
+
+        describe('`configuration` does not have a match', () => {
+          it('returns false', () => {
+            return expect(evaluate('+B', '+A'))
+              .to.be.false
+          })
+        })
+
+        describe('Every rule must be true', () => {
+          describe('`configuration` has a combination match', () => {
+            it('returns true', () => {
+              return expect(evaluate('+1/2/3+A+4/5/6+B', '+1+6+A+B'))
+                .to.be.true
+            })
+          })
+
+          describe('`configuration` does not have a combination match', () => {
+            it('returns false', () => {
+              return expect(evaluate('+1/2/3+A+4/5/6+B', '+6+A'))
+                .to.be.false
+            })
+          })
+
+          describe('`configuration` has a negation match', () => {
+            it('returns false', () => {
+              return expect(evaluate('+1/2/3+A+4/5/6+!B', '+1+6+A+B'))
+                .to.be.false
+            })
+          })
+
+          describe('`configuration` does not have a negation match', () => {
+            it('returns true', () => {
+              return expect(evaluate('+1/2/3+A+4/5/6+!C', '+1+6+A+B'))
+                .to.be.true
+            })
+          })
+        })
+
+        describe('At least one rule must be true', () => {
+          describe('`configuration` has a combination match', () => {
+            it('returns true', () => {
+              return expect(evaluate('+1/2/3+A;+4/5/6+B', '+6+B'))
+                .to.be.true
+            })
+          })
+
+          describe('`configuration` does not have a combination match', () => {
+            it('returns false', () => {
+              return expect(evaluate('+1/2/3+A;+4/5/6+B', '+6+A'))
+                .to.be.false
+            })
+          })
+
+          describe('`configuration` has a negation match', () => {
+            it('returns false', () => {
+              return expect(evaluate('+!A;+!B', '+1+6+A+B'))
+                .to.be.false
+            })
+          })
+
+          describe('`configuration` does not have a negation match', () => {
+            it('returns true', () => {
+              return expect(evaluate('+1/2/3+A;!B', '+1+6+A+B'))
+                .to.be.true
+            })
+          })
+
+          describe('`configuration` has a negation match in combination', () => {
+            it('returns false', () => {
+              return expect(evaluate('+1/2/3+A;+4/5/6+B;+7/8/9+C;+!A+!B+!C', '+C'))
+                .to.be.false
+            })
+          })
+
+          describe('`configuration` does not have a negation match in combination', () => {
+            it('returns true', () => {
+              return expect(evaluate('+1/2/3+A;+4/5/6+B;+7/8/9+C;+!A+!B+!C;', '+9+C'))
+                .to.be.true
+            })
+          })
+        })
+      })
+
+      describe('`configuration` does not have configuration', () => {
+        it('returns false', () => {
+          return expect(evaluate('+A'))
+            .to.be.false
+        })
+      })
+    })
+
+    describe('`rule` does not have rules', () => {
+      describe('`configuration` has configuration', () => {
+        it('returns false', () => {
+          return expect(evaluate('', '+A'))
+            .to.be.false
+        })
+      })
+
+      describe('`configuration` does not have configuration', () => {
+        it('returns false', () => {
+          return expect(evaluate())
+            .to.be.false
+        })
+      })
+    })
+  })
+
+  describe('`getRuleMap()`', () => {
+    it('is a `Map`', () => {
+      return expect(getRuleMap())
+        .to.be.an.instanceof(Map)
+    })
+  })
+
+  describe('`getConfigurationMap`', () => {
+    it('is a `Map`', () => {
+      return expect(getConfigurationMap())
+        .to.be.an.instanceof(Map)
+    })
+  })
+
+  describe('`getEvaluation`', () => {
+    it('returns false', () => {
+      return expect(getEvaluation())
+        .to.be.false
+    })
+  })
+
+  describe('`evaluateRuleForConfiguration()`', () => {
+    describe('`rule` has rules', () => {
+      describe('`configuration` has configuration', () => {
+        describe('`configuration` has a match', () => {
+          it('returns true', () => {
+            return expect(evaluateRuleForConfiguration('+A', '+A'))
+              .to.be.true
+          })
+        })
+
+        describe('`configuration` does not have a match', () => {
+          it('returns false', () => {
+            return expect(evaluateRuleForConfiguration('+B', '+A'))
+              .to.be.false
+          })
+        })
+
+        describe('Every rule must be true', () => {
+          describe('`configuration` has a combination match', () => {
+            it('returns true', () => {
+              return expect(evaluateRuleForConfiguration('+1/2/3+A+4/5/6+B', '+1+6+A+B'))
+                .to.be.true
+            })
+          })
+
+          describe('`configuration` does not have a combination match', () => {
+            it('returns false', () => {
+              return expect(evaluateRuleForConfiguration('+1/2/3+A+4/5/6+B', '+6+A'))
+                .to.be.false
+            })
+          })
+
+          describe('`configuration` has a negation match', () => {
+            it('returns false', () => {
+              return expect(evaluateRuleForConfiguration('+1/2/3+A+4/5/6+!B', '+1+6+A+B'))
+                .to.be.false
+            })
+          })
+
+          describe('`configuration` does not have a negation match', () => {
+            it('returns true', () => {
+              return expect(evaluateRuleForConfiguration('+1/2/3+A+4/5/6+!C', '+1+6+A+B'))
+                .to.be.true
+            })
+          })
+        })
+
+        describe('At least one rule must be true', () => {
+          describe('`configuration` has a combination match', () => {
+            it('returns true', () => {
+              return expect(evaluateRuleForConfiguration('+1/2/3+A;+4/5/6+B', '+6+B'))
+                .to.be.true
+            })
+          })
+
+          describe('`configuration` does not have a combination match', () => {
+            it('returns false', () => {
+              return expect(evaluateRuleForConfiguration('+1/2/3+A;+4/5/6+B', '+6+A'))
+                .to.be.false
+            })
+          })
+
+          describe('`configuration` has a negation match', () => {
+            it('returns false', () => {
+              return expect(evaluateRuleForConfiguration('+!A;+!B', '+1+6+A+B'))
+                .to.be.false
+            })
+          })
+
+          describe('`configuration` does not have a negation match', () => {
+            it('returns true', () => {
+              return expect(evaluateRuleForConfiguration('+1/2/3+A;!B', '+1+6+A+B'))
+                .to.be.true
+            })
+          })
+
+          describe('`configuration` has a negation match in combination', () => {
+            it('returns false', () => {
+              return expect(evaluateRuleForConfiguration('+1/2/3+A;+4/5/6+B;+7/8/9+C;+!A+!B+!C', '+C'))
+                .to.be.false
+            })
+          })
+
+          describe('`configuration` does not have a negation match in combination', () => {
+            it('returns true', () => {
+              return expect(evaluateRuleForConfiguration('+1/2/3+A;+4/5/6+B;+7/8/9+C;+!A+!B+!C;', '+9+C'))
+                .to.be.true
+            })
+          })
+        })
+      })
+
+      describe('`configuration` does not have configuration', () => {
+        it('returns false', () => {
+          return expect(evaluateRuleForConfiguration('+A'))
+            .to.be.false
+        })
+      })
+    })
+
+    describe('`rule` does not have rules', () => {
+      describe('`configuration` has configuration', () => {
+        it('returns false', () => {
+          return expect(evaluateRuleForConfiguration('', '+A'))
+            .to.be.false
+        })
+      })
+
+      describe('`configuration` does not have configuration', () => {
+        it('returns false', () => {
+          return expect(evaluateRuleForConfiguration())
+            .to.be.false
+        })
+      })
+    })
+  })
+})