Change format of test and errors

TotalTechGeek · TotalTechGeek · commit 288a0d540013 · 2025-01-23T14:54:29.000-06:00
diff --git a/compatible.test.js b/compatible.test.js
@@ -1,3 +1,4 @@
+/* eslint-disable no-ex-assign */
 import fs from 'fs'
 import { LogicEngine, AsyncLogicEngine } from './index.js'
 
@@ -57,7 +58,9 @@ describe('All of the compatible tests', () => {
           expect(correction(result)).toStrictEqual(testCase.result)
         } catch (err) {
           if (err.message && err.message.includes('expect')) throw err
-          expect(testCase.error).toStrictEqual(true)
+          if (Number.isNaN(err)) err = { type: 'NaN' }
+          else if (err.message) err = { type: err.message }
+          expect(err).toMatchObject(testCase.error)
         }
       })
 
@@ -72,7 +75,9 @@ describe('All of the compatible tests', () => {
           expect(correction(result)).toStrictEqual(testCase.result)
         } catch (err) {
           if (err.message && err.message.includes('expect')) throw err
-          expect(testCase.error).toStrictEqual(true)
+          if (Number.isNaN(err)) err = { type: 'NaN' }
+          else if (err.message) err = { type: err.message }
+          expect(err).toMatchObject(testCase.error)
         }
       })
     }
diff --git a/defaultMethods.js b/defaultMethods.js
@@ -117,7 +117,7 @@ const defaultMethods = {
   throw: (type) => {
     if (Array.isArray(type)) type = type[0]
     if (typeof type === 'object') throw type
-    throw { error: type }
+    throw { type }
   },
   max: (data) => Math.max(...data),
   min: (data) => Math.min(...data),
@@ -345,7 +345,7 @@ const defaultMethods = {
       for (let i = 0; i < arr.length; i++) {
         try {
           // Todo: make this message thing more robust.
-          if (lastError) item = engine.run(arr[i], { error: lastError.error || lastError.message || lastError.constructor.name }, { above: [null, _1, _2] })
+          if (lastError) item = engine.run(arr[i], { type: lastError.type || lastError.error || lastError.message || lastError.constructor.name }, { above: [null, _1, _2] })
           else item = executeInLoop ? engine.run(arr[i], _1, { above: _2 }) : arr[i]
           return item
         } catch (e) {
@@ -366,7 +366,7 @@ const defaultMethods = {
       for (let i = 0; i < arr.length; i++) {
         try {
           // Todo: make this message thing more robust.
-          if (lastError) item = await engine.run(arr[i], { error: lastError.error || lastError.message || lastError.constructor.name }, { above: [null, _1, _2] })
+          if (lastError) item = await engine.run(arr[i], { type: lastError.type || lastError.error || lastError.message || lastError.constructor.name }, { above: [null, _1, _2] })
           else item = executeInLoop ? await engine.run(arr[i], _1, { above: _2 }) : arr[i]
           return item
         } catch (e) {
diff --git a/suites/divide.json b/suites/divide.json
@@ -150,31 +150,31 @@
     {
         "description": "Divide by Zero",
         "rule": { "/": [0, 0] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Divide with String produces NaN",
         "rule": { "/": [1, "a"] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Divide with Array produces NaN",
         "rule": { "/": [1, [1]] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Any division by zero should return NaN",
         "rule": { "/": [1, 0] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Any division by zero should return NaN (2)",
         "rule": { "/": [8, 2, 0] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     }
 ]
diff --git a/suites/minus.json b/suites/minus.json
@@ -118,13 +118,13 @@
     {
         "description": "Subtraction with string produces NaN",
         "rule": { "-": ["Hey", 1] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Subtraction with Array produces NaN",
         "rule": { "-": [[1], 1] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     }
 ]
diff --git a/suites/modulo.json b/suites/modulo.json
@@ -161,13 +161,13 @@
     {
         "description": "Modulo with string produces NaN",
         "rule": { "%": ["Hey", 1] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Modulo with array produces NaN",
         "rule": { "%": [[1], 1] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     }
 ]
diff --git a/suites/multiply.json b/suites/multiply.json
@@ -148,19 +148,19 @@
     {
         "description": "Multiply with string produces NaN",
         "rule": { "*": ["Hey", 1] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Multiply with a single string produces NaN",
         "rule": { "*": ["Hey"] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Multiply with Array produces NaN",
         "rule": { "*": [[1], 1] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     }
 ]
diff --git a/suites/plus.json b/suites/plus.json
@@ -144,49 +144,49 @@
     {
         "description": "Addition with string produces NaN",
         "rule": { "+": ["Hey", 1] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Addition with Array produces NaN",
         "rule": { "+": [[1], 1] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Addition with Array from context produces NaN",
         "rule": { "+": [{ "val": "x" }, 1] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": { "x": [1] }
     },
     {
         "description": "Addition with Object produces NaN",
         "rule": { "+": [{ "val": "x" }, 1] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": { "x": {} }
     },
     {
         "description": "Plus Operator with Single Operand, Invalid String Produces NaN",
         "rule": { "+": "Hello" },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Plus Operator with Single Operand, Array Input Produces NaN",
         "rule": { "+": [[1]] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Plus Operator with Single Operand, Object Input Produces NaN",
         "rule": { "+": [{}] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Plus Operator with Single Operand, Direct Object Input Produces NaN",
         "rule": { "+": {} },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     }
 ]
diff --git a/suites/throw.json b/suites/throw.json
@@ -3,18 +3,18 @@
         "description": "Creates an error object",
         "rule": { "throw": "hello" },
         "data": null,
-        "error": true
+        "error": { "type": "hello" }
     },
     {
         "description": "NaN creates an error object or measured equivalent (equivalence class test)",
         "rule": { "throw": "NaN" },
         "data": null,
-        "error": true
+        "error": { "type": "NaN" }
     },
     {
         "description": "Can throw an error object",
         "rule": { "throw": { "val": "x" } },
-        "data": { "x": { "error": "Some error" }},
-        "error": true
+        "data": { "x": { "type": "Some error" }},
+        "error": { "type": "Some error" }
     }
 ]
diff --git a/suites/try.json b/suites/try.json
@@ -21,44 +21,44 @@
     {
         "description": "Panics if none of the values are valid",
         "rule": { "try": [{ "throw": "Some error" }, { "throw": "Some other error" }] },
-        "error": true,
+        "error": { "type": "Some other error" },
         "data": null
     },
     {
         "description": "Panics if none of the values are valid (2)",
         "rule": { "try": [{ "throw": "Some error" }, { "/": [0, 0] }] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Panics if none of the values are valid (3)",
         "rule": { "try": [{ "/": [0, 0] }, { "/": [1, 0] }, { "/": [2, 0] }] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Panics when the only argument is an error",
         "rule": { "try": { "throw": "Some error" } },
-        "error": true,
+        "error": { "type": "Some error" },
         "data": null
     },
     {
         "description": "Panic with an error emitted from an operator",
         "rule": { "try": [{ "/": [1, 0] }] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Panic within an iterator",
         "rule": { "map": [[1, 2, 3], { "try": [{ "/": [0,0] }] }] },
-        "error": true,
+        "error": { "type": "NaN" },
         "data": null
     },
     {
         "description": "Panic based on an error emitted from an if",
         "rule": { "try": [{ "if": [{"val": ["user", "admin"]}, true, { "throw": "Not an admin" }] }] },
         "data": { "user": { "admin": false } },
-        "error": true
+        "error": { "type": "Not an admin" }
     },
     {
         "description": "Try can work further up the AST with Exceptions",
@@ -79,7 +79,7 @@
         "rule": {
             "try": [
                 { "throw": "Some error" },
-                { "val": "error" }
+                { "val": "type" }
             ]
         },
         "result": "Some error",
@@ -90,7 +90,7 @@
         "rule": {
             "try": [
                 { "if": [true, { "throw": "Some error" }, null] },
-                { "val": "error" }
+                { "val": "type" }
             ]
         },
         "result": "Some error",
@@ -102,7 +102,7 @@
             "try": [
                 { "throw": "A" },
                 { "throw": "B" },
-                { "val": "error" }
+                { "val": "type" }
             ]
         },
         "result": "B",
@@ -111,9 +111,9 @@
     {
         "description": "Error can pull from an error object",
         "rule": {
-            "try": [{ "throw": { "val": "x" } }, { "val": "error" }]
+            "try": [{ "throw": { "val": "x" } }, { "val": "type" }]
         },
-        "data": { "x": { "error": "Some error" }},
+        "data": { "x": { "type": "Some error" }},
         "result": "Some error"
     },
     {
@@ -125,7 +125,7 @@
                     { "map": [[1,2,3], {"/": [0, 0] }]},
                     null
                 ]
-            }, { "val": "error" }]
+            }, { "val": "type" }]
         },
         "result": "NaN",
         "data": null
@@ -136,7 +136,7 @@
             "try": [
                 { "if": [{ "/": [1, { "val": "x" }] }, { "throw": "Some error" }, null] },
                 {
-                    "if": [{ "===": [{ "val": "error" }, "NaN"]}, "Handled", { "throw": { "val": [] } }]
+                    "if": [{ "===": [{ "val": "type" }, "NaN"]}, "Handled", { "throw": { "val": [] } }]
                 }
             ]
         },
@@ -148,10 +148,10 @@
         "rule": {
             "try": [
                 { "if": [{ "/": [1, { "val": "x" }] }, { "throw": "Some error" }, null] },
-                { "if": [{ "===": [{ "val": "error" }, "NaN"]}, "Handled", { "throw": { "val": [] } }] }
+                { "if": [{ "===": [{ "val": "type" }, "NaN"]}, "Handled", { "throw": { "val": [] } }] }
             ]
         },
-        "error": true,
+        "error": { "type": "Some error" },
         "data": { "x": 1 }
     },
     "# Not Proposed",

Original file line number	Diff line number	Diff line change
`@@ -150,31 +150,31 @@`
`150`	`150`	`{`
`151`	`151`	`"description": "Divide by Zero",`
`152`	`152`	`"rule": { "/": [0, 0] },`
`153`		`- "error": true,`
	`153`	`+ "error": { "type": "NaN" },`
`154`	`154`	`"data": null`
`155`	`155`	`},`
`156`	`156`	`{`
`157`	`157`	`"description": "Divide with String produces NaN",`
`158`	`158`	`"rule": { "/": [1, "a"] },`
`159`		`- "error": true,`
	`159`	`+ "error": { "type": "NaN" },`
`160`	`160`	`"data": null`
`161`	`161`	`},`
`162`	`162`	`{`
`163`	`163`	`"description": "Divide with Array produces NaN",`
`164`	`164`	`"rule": { "/": [1, [1]] },`
`165`		`- "error": true,`
	`165`	`+ "error": { "type": "NaN" },`
`166`	`166`	`"data": null`
`167`	`167`	`},`
`168`	`168`	`{`
`169`	`169`	`"description": "Any division by zero should return NaN",`
`170`	`170`	`"rule": { "/": [1, 0] },`
`171`		`- "error": true,`
	`171`	`+ "error": { "type": "NaN" },`
`172`	`172`	`"data": null`
`173`	`173`	`},`
`174`	`174`	`{`
`175`	`175`	`"description": "Any division by zero should return NaN (2)",`
`176`	`176`	`"rule": { "/": [8, 2, 0] },`
`177`		`- "error": true,`
	`177`	`+ "error": { "type": "NaN" },`
`178`	`178`	`"data": null`
`179`	`179`	`}`
`180`	`180`	`]`
Original file line number	Diff line number	Diff line change
`@@ -118,13 +118,13 @@`
`118`	`118`	`{`
`119`	`119`	`"description": "Subtraction with string produces NaN",`
`120`	`120`	`"rule": { "-": ["Hey", 1] },`
`121`		`- "error": true,`
	`121`	`+ "error": { "type": "NaN" },`
`122`	`122`	`"data": null`
`123`	`123`	`},`
`124`	`124`	`{`
`125`	`125`	`"description": "Subtraction with Array produces NaN",`
`126`	`126`	`"rule": { "-": [[1], 1] },`
`127`		`- "error": true,`
	`127`	`+ "error": { "type": "NaN" },`
`128`	`128`	`"data": null`
`129`	`129`	`}`
`130`	`130`	`]`
Original file line number	Diff line number	Diff line change
`@@ -161,13 +161,13 @@`
`161`	`161`	`{`
`162`	`162`	`"description": "Modulo with string produces NaN",`
`163`	`163`	`"rule": { "%": ["Hey", 1] },`
`164`		`- "error": true,`
	`164`	`+ "error": { "type": "NaN" },`
`165`	`165`	`"data": null`
`166`	`166`	`},`
`167`	`167`	`{`
`168`	`168`	`"description": "Modulo with array produces NaN",`
`169`	`169`	`"rule": { "%": [[1], 1] },`
`170`		`- "error": true,`
	`170`	`+ "error": { "type": "NaN" },`
`171`	`171`	`"data": null`
`172`	`172`	`}`
`173`	`173`	`]`
Original file line number	Diff line number	Diff line change
`@@ -148,19 +148,19 @@`
`148`	`148`	`{`
`149`	`149`	`"description": "Multiply with string produces NaN",`
`150`	`150`	`"rule": { "*": ["Hey", 1] },`
`151`		`- "error": true,`
	`151`	`+ "error": { "type": "NaN" },`
`152`	`152`	`"data": null`
`153`	`153`	`},`
`154`	`154`	`{`
`155`	`155`	`"description": "Multiply with a single string produces NaN",`
`156`	`156`	`"rule": { "*": ["Hey"] },`
`157`		`- "error": true,`
	`157`	`+ "error": { "type": "NaN" },`
`158`	`158`	`"data": null`
`159`	`159`	`},`
`160`	`160`	`{`
`161`	`161`	`"description": "Multiply with Array produces NaN",`
`162`	`162`	`"rule": { "*": [[1], 1] },`
`163`		`- "error": true,`
	`163`	`+ "error": { "type": "NaN" },`
`164`	`164`	`"data": null`
`165`	`165`	`}`
`166`	`166`	`]`
Original file line number	Diff line number	Diff line change
`@@ -3,18 +3,18 @@`
`3`	`3`	`"description": "Creates an error object",`
`4`	`4`	`"rule": { "throw": "hello" },`
`5`	`5`	`"data": null,`
`6`		`- "error": true`
	`6`	`+ "error": { "type": "hello" }`
`7`	`7`	`},`
`8`	`8`	`{`
`9`	`9`	`"description": "NaN creates an error object or measured equivalent (equivalence class test)",`
`10`	`10`	`"rule": { "throw": "NaN" },`
`11`	`11`	`"data": null,`
`12`		`- "error": true`
	`12`	`+ "error": { "type": "NaN" }`
`13`	`13`	`},`
`14`	`14`	`{`
`15`	`15`	`"description": "Can throw an error object",`
`16`	`16`	`"rule": { "throw": { "val": "x" } },`
`17`		`- "data": { "x": { "error": "Some error" }},`
`18`		`- "error": true`
	`17`	`+ "data": { "x": { "type": "Some error" }},`
	`18`	`+ "error": { "type": "Some error" }`
`19`	`19`	`}`
`20`	`20`	`]`