@kaiko.io/rescript-deser 7.0.0-alpha.1 → 7.0.0-alpha.2

package/lib/es6/tests/index.js

@@ -2,9 +2,10 @@
 
 import * as Deser from "../src/Deser.js";
 import * as Qunit from "qunit";
-import * as Core__Result from "@rescript/core/lib/es6/src/Core__Result.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-var fields = {
+let fields = {
   TAG: "Object",
   _0: [
     [
@@ -25,259 +26,277 @@ var fields = {
   ]
 };
 
-var Deserializer = Deser.MakeDeserializer({
-      fields: fields
-    });
+let Deserializer = Deser.MakeDeserializer({
+  fields: fields
+});
 
-var Appointment = {
+let Appointment = {
   Deserializer: Deserializer
 };
 
-Qunit.module("Basic deserializer", (function (param) {
-        var valid = [
-          [
-            {"note": "Bicentennial doctor's appointment", "date": "2100-01-01"},
-            {
-              note: "Bicentennial doctor's appointment",
-              date: new Date("2100-01-01"),
-              extra: undefined
-            }
-          ],
-          [
-            {
+Qunit.module("Basic deserializer", param => {
+  let valid = [
+    [
+      {"note": "Bicentennial doctor's appointment", "date": "2100-01-01"},
+      {
+        note: "Bicentennial doctor's appointment",
+        date: new Date("2100-01-01"),
+        extra: undefined
+      }
+    ],
+    [
+      {
       "note": "Bicentennial doctor's appointment",
       "date": "2100-01-01",
       "extra": "Don't take your stop-aging pills the night before the appointment",
     },
-            {
-              note: "Bicentennial doctor's appointment",
-              date: new Date("2100-01-01"),
-              extra: "Don't take your stop-aging pills the night before the appointment"
-            }
-          ]
-        ];
-        Qunit.test("Correctly deserializes data", (function (qunit) {
-                qunit.expect(valid.length);
-                valid.forEach(function (param) {
-                      var data = param[0];
-                      console.log("Running sample", data);
-                      var result = Deserializer.fromJSON(data);
-                      if (result.TAG === "Ok") {
-                        qunit.deepEqual(result._0, param[1], "result == expected");
-                        return ;
-                      }
-                      console.error(result._0);
-                    });
-              }));
-        var invalid = [[
-            "Missing non-optional field",
-            {"extra": "Bicentennial doctor's appointment", "date": "2100-01-01"}
-          ]];
-        Qunit.test("Correctly catches invalid data", (function (qunit) {
-                qunit.expect(invalid.length);
-                invalid.forEach(function (param) {
-                      var data = param[1];
-                      console.log("Running sample", param[0], data);
-                      var result = Deserializer.fromJSON(data);
-                      if (result.TAG === "Ok") {
-                        console.error("Invalid being accepted: ", result._0);
-                        return ;
-                      }
-                      console.log("Correctly detected:", result._0);
-                      qunit.ok(true, true);
-                    });
-              }));
-      }));
+      {
+        note: "Bicentennial doctor's appointment",
+        date: new Date("2100-01-01"),
+        extra: "Don't take your stop-aging pills the night before the appointment"
+      }
+    ]
+  ];
+  Qunit.test("Correctly deserializes data", qunit => {
+    qunit.expect(valid.length);
+    valid.forEach(param => {
+      let data = param[0];
+      console.log("Running sample", data);
+      let result = Deserializer.fromJSON(data);
+      if (result.TAG === "Ok") {
+        qunit.deepEqual(result._0, param[1], "result == expected");
+        return;
+      }
+      console.error(result._0);
+    });
+  });
+  let invalid = [[
+      "Missing non-optional field",
+      {"extra": "Bicentennial doctor's appointment", "date": "2100-01-01"}
+    ]];
+  Qunit.test("Correctly catches invalid data", qunit => {
+    qunit.expect(invalid.length);
+    invalid.forEach(param => {
+      let data = param[1];
+      console.log("Running sample", param[0], data);
+      let result = Deserializer.fromJSON(data);
+      if (result.TAG === "Ok") {
+        console.error("Invalid being accepted: ", result._0);
+        return;
+      }
+      console.log("Correctly detected:", result._0);
+      qunit.ok(true, true);
+    });
+  });
+});
 
-Qunit.module("Recursive deserializer", (function (param) {
-        var fields = {
-          TAG: "Object",
-          _0: [
-            [
-              "data",
-              "Any"
-            ],
-            [
-              "children",
+Qunit.module("Recursive deserializer", param => {
+  let fields = {
+    TAG: "Object",
+    _0: [
+      [
+        "data",
+        "Any"
+      ],
+      [
+        "children",
+        {
+          TAG: "Array",
+          _0: "Self"
+        }
+      ]
+    ]
+  };
+  let DeserializerImpl = Deser.MakeDeserializer({
+    fields: fields
+  });
+  let checkFieldsSanity = DeserializerImpl.checkFieldsSanity;
+  let valid = [[
+      {"data": "A", "children": [{"data": "A1", "children": []}, {"data": "B", "children": [{"data": "C", "children": []}, {"data": "D", "children": []}]}]},
+      {
+        data: "A",
+        children: [
+          {
+            data: "A1",
+            children: []
+          },
+          {
+            data: "B",
+            children: [
               {
-                TAG: "Array",
-                _0: "Self"
+                data: "C",
+                children: []
+              },
+              {
+                data: "D",
+                children: []
               }
             ]
-          ]
-        };
-        var DeserializerImpl = Deser.MakeDeserializer({
-              fields: fields
-            });
-        var checkFieldsSanity = DeserializerImpl.checkFieldsSanity;
-        var fromJSON = function (data) {
-          return Core__Result.map(DeserializerImpl.fromJSON(data), (function (x) {
-                        return x;
-                      }));
-        };
-        var valid = [[
-            {"data": "A", "children": [{"data": "A1", "children": []}, {"data": "B", "children": [{"data": "C", "children": []}, {"data": "D", "children": []}]}]},
-            {
-              data: "A",
-              children: [
-                {
-                  data: "A1",
-                  children: []
-                },
-                {
-                  data: "B",
-                  children: [
-                    {
-                      data: "C",
-                      children: []
-                    },
-                    {
-                      data: "D",
-                      children: []
-                    }
-                  ]
-                }
-              ]
-            }
-          ]];
-        Qunit.test("Trivial recursion detection: Ok", (function (qunit) {
-                qunit.expect(1);
-                qunit.deepEqual(checkFieldsSanity(), {
-                      TAG: "Ok",
-                      _0: undefined
-                    }, "Ok");
-              }));
-        Qunit.test("Infinite list", (function (qunit) {
-                var fields = {
-                  TAG: "Object",
-                  _0: [
-                    [
-                      "head",
-                      "String"
-                    ],
-                    [
-                      "tail",
-                      "Self"
-                    ]
-                  ]
-                };
-                var InfiniteList = Deser.MakeDeserializer({
-                      fields: fields
-                    });
-                qunit.expect(1);
-                qunit.deepEqual(Core__Result.isError(InfiniteList.checkFieldsSanity()), true, "Ok");
-              }));
-        Qunit.test("Finite list", (function (qunit) {
-                var fields = {
-                  TAG: "Object",
-                  _0: [
-                    [
-                      "head",
-                      "String"
-                    ],
-                    [
-                      "tail",
-                      {
-                        TAG: "Optional",
-                        _0: "Self"
-                      }
-                    ]
-                  ]
-                };
-                var List = Deser.MakeDeserializer({
-                      fields: fields
-                    });
-                qunit.expect(1);
-                qunit.deepEqual(List.checkFieldsSanity(), {
-                      TAG: "Ok",
-                      _0: undefined
-                    }, "Ok");
-              }));
-        Qunit.test("Correctly deserializes recursive data", (function (qunit) {
-                qunit.expect(valid.length);
-                valid.forEach(function (param) {
-                      var data = param[0];
-                      console.log("Running sample", data);
-                      var result = fromJSON(data);
-                      if (result.TAG === "Ok") {
-                        qunit.deepEqual(result._0, param[1], "result == expected");
-                        return ;
-                      }
-                      console.error(result._0);
-                    });
-              }));
-        Qunit.test("Recursion in sub-deserializer", (function (qunit) {
-                var fields = {
-                  TAG: "Object",
-                  _0: [
-                    [
-                      "head",
-                      "String"
-                    ],
-                    [
-                      "tail",
-                      {
-                        TAG: "Optional",
-                        _0: "Self"
-                      }
-                    ]
-                  ]
-                };
-                var List = Deser.MakeDeserializer({
-                      fields: fields
-                    });
-                var fields$1 = {
-                  TAG: "Object",
-                  _0: [
-                    [
-                      "records",
-                      {
-                        TAG: "Deserializer",
-                        _0: List
-                      }
-                    ],
-                    [
-                      "next",
-                      {
-                        TAG: "Optional",
-                        _0: "Self"
-                      }
-                    ]
-                  ]
-                };
-                var Ledger = Deser.MakeDeserializer({
-                      fields: fields$1
-                    });
-                var data = {"records": {"head": "A", "tail": {"head": "B"}},
+          }
+        ]
+      }
+    ]];
+  Qunit.test("Trivial recursion detection: Ok", qunit => {
+    qunit.expect(1);
+    qunit.deepEqual(checkFieldsSanity(), {
+      TAG: "Ok",
+      _0: undefined
+    }, "Ok");
+  });
+  Qunit.test("Infinite list", qunit => {
+    let fields = {
+      TAG: "Object",
+      _0: [
+        [
+          "head",
+          "String"
+        ],
+        [
+          "tail",
+          "Self"
+        ]
+      ]
+    };
+    let InfiniteList = Deser.MakeDeserializer({
+      fields: fields
+    });
+    qunit.expect(1);
+    qunit.deepEqual(Stdlib_Result.isError(InfiniteList.checkFieldsSanity()), true, "Ok");
+  });
+  Qunit.test("Finite list", qunit => {
+    let fields = {
+      TAG: "Object",
+      _0: [
+        [
+          "head",
+          "String"
+        ],
+        [
+          "tail",
+          {
+            TAG: "Optional",
+            _0: "Self"
+          }
+        ]
+      ]
+    };
+    let List = Deser.MakeDeserializer({
+      fields: fields
+    });
+    qunit.expect(1);
+    qunit.deepEqual(List.checkFieldsSanity(), {
+      TAG: "Ok",
+      _0: undefined
+    }, "Ok");
+  });
+  Qunit.test("Correctly deserializes recursive data", qunit => {
+    qunit.expect(valid.length);
+    valid.forEach(param => {
+      let data = param[0];
+      console.log("Running sample", data);
+      let result = Stdlib_Result.map(DeserializerImpl.fromJSON(data), x => x);
+      if (result.TAG === "Ok") {
+        qunit.deepEqual(result._0, param[1], "result == expected");
+        return;
+      }
+      console.error(result._0);
+    });
+  });
+  Qunit.test("Recursion in sub-deserializer", qunit => {
+    let fields = {
+      TAG: "Object",
+      _0: [
+        [
+          "head",
+          "String"
+        ],
+        [
+          "tail",
+          {
+            TAG: "Optional",
+            _0: "Self"
+          }
+        ]
+      ]
+    };
+    let List = Deser.MakeDeserializer({
+      fields: fields
+    });
+    let fields$1 = {
+      TAG: "Object",
+      _0: [
+        [
+          "records",
+          {
+            TAG: "Deserializer",
+            _0: List
+          }
+        ],
+        [
+          "next",
+          {
+            TAG: "Optional",
+            _0: "Self"
+          }
+        ]
+      ]
+    };
+    let Ledger = Deser.MakeDeserializer({
+      fields: fields$1
+    });
+    let data = {"records": {"head": "A", "tail": {"head": "B"}},
         "next": {"records": {"head": "A", "tail": {"head": "B"}}}};
-                var expected = {
-                  records: {
-                    head: "A",
-                    tail: {
-                      head: "B",
-                      tail: undefined
-                    }
-                  },
-                  next: {
-                    records: {
-                      head: "A",
-                      tail: {
-                        head: "B",
-                        tail: undefined
-                      }
-                    },
-                    next: undefined
-                  }
-                };
-                qunit.expect(1);
-                qunit.deepEqual(Ledger.fromJSON(data), {
-                      TAG: "Ok",
-                      _0: expected
-                    }, "nice ledger");
-              }));
-      }));
+    let expected = {
+      records: {
+        head: "A",
+        tail: {
+          head: "B",
+          tail: undefined
+        }
+      },
+      next: {
+        records: {
+          head: "A",
+          tail: {
+            head: "B",
+            tail: undefined
+          }
+        },
+        next: undefined
+      }
+    };
+    qunit.expect(1);
+    qunit.deepEqual(Ledger.fromJSON(data), {
+      TAG: "Ok",
+      _0: expected
+    }, "nice ledger");
+  });
+});
+
+Qunit.module("Type safety limits", param => {
+  Qunit.test("ill-defined deserializer can cheat the type system", qunit => {
+    let X = Deser.MakeDeserializer({
+      fields: {
+        TAG: "Array",
+        _0: "Int"
+      }
+    });
+    let data = [1];
+    qunit.throws(param => {
+      let illString = Stdlib_Result.getOr(X.fromJSON(data), "");
+      try {
+        console.info("Index", "This will fail with a type error", illString.charAt(0));
+        return;
+      } catch (raw_e) {
+        let e = Primitive_exceptions.internalToException(raw_e);
+        console.error(e);
+        throw e;
+      }
+    }, "Expected: TypeError: illString.charAt is not a function");
+  });
+});
 
 export {
-  Appointment ,
+  Appointment,
 }
 /* Deserializer Not a pure module */