remult 0.14.6 → 0.14.7

package/src/shared-tests/db-tests-setup.js

@@ -1,66 +1,170 @@
-import { Remult } from "../context";
-import { InMemoryDataProvider } from "../data-providers/in-memory-database";
-import { Categories } from "../tests/remult-3-entities";
-export function itWithFocus(key, what, focus = false) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testAllDbs = exports.testInMemory = exports.addDatabaseToTest = exports.testAll = exports.itWithFocus = void 0;
+var tslib_1 = require("tslib");
+var context_1 = require("../context");
+var in_memory_database_1 = require("../data-providers/in-memory-database");
+var remult_3_entities_1 = require("../tests/remult-3-entities");
+function itWithFocus(key, what, focus) {
+    if (focus === void 0) { focus = false; }
     if (focus)
         fit(key, what);
     else
         it(key, what);
 }
-export function testAll(key, what, focus = false) {
-    for (const test of databasesTesters) {
-        test(key, what, focus);
+exports.itWithFocus = itWithFocus;
+function testAll(key, what, focus) {
+    var e_1, _a;
+    if (focus === void 0) { focus = false; }
+    try {
+        for (var databasesTesters_1 = tslib_1.__values(databasesTesters), databasesTesters_1_1 = databasesTesters_1.next(); !databasesTesters_1_1.done; databasesTesters_1_1 = databasesTesters_1.next()) {
+            var test_1 = databasesTesters_1_1.value;
+            test_1(key, what, focus);
+        }
     }
-    loadedTests.push(x => {
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (databasesTesters_1_1 && !databasesTesters_1_1.done && (_a = databasesTesters_1.return)) _a.call(databasesTesters_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    loadedTests.push(function (x) {
         x(key, what, focus);
     });
 }
-const databasesTesters = [];
-const loadedTests = [];
-export function addDatabaseToTest(tester) {
-    for (const test of loadedTests) {
-        test(tester);
+exports.testAll = testAll;
+var databasesTesters = [];
+var loadedTests = [];
+function addDatabaseToTest(tester) {
+    var e_2, _a;
+    try {
+        for (var loadedTests_1 = tslib_1.__values(loadedTests), loadedTests_1_1 = loadedTests_1.next(); !loadedTests_1_1.done; loadedTests_1_1 = loadedTests_1.next()) {
+            var test_2 = loadedTests_1_1.value;
+            test_2(tester);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (loadedTests_1_1 && !loadedTests_1_1.done && (_a = loadedTests_1.return)) _a.call(loadedTests_1);
+        }
+        finally { if (e_2) throw e_2.error; }
     }
     databasesTesters.push(tester);
 }
-export function testInMemory(key, what, focus = false) {
-    itWithFocus(key + " - in memory", async () => {
-        let remult = new Remult();
-        let db = new InMemoryDataProvider();
-        remult.setDataProvider(db);
-        await what({ db, remult, createEntity: async (x) => remult.repo(x) });
-    }, focus);
+exports.addDatabaseToTest = addDatabaseToTest;
+function testInMemory(key, what, focus) {
+    var _this = this;
+    if (focus === void 0) { focus = false; }
+    itWithFocus(key + " - in memory", function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        var remult, db;
+        var _this = this;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    remult = new context_1.Remult();
+                    db = new in_memory_database_1.InMemoryDataProvider();
+                    remult.setDataProvider(db);
+                    return [4 /*yield*/, what({ db: db, remult: remult, createEntity: function (x) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                                return [2 /*return*/, remult.repo(x)];
+                            }); }); } })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); }, focus);
 }
+exports.testInMemory = testInMemory;
 databasesTesters.push(testInMemory);
-export async function testAllDbs(key, doTest, focus = false) {
-    testAll(key, async ({ remult, createEntity }) => {
-        let createData = async (doInsert, entity) => {
-            if (!entity)
-                entity = Categories;
-            let rep = await createEntity(entity);
-            if (doInsert)
-                await doInsert(async (id, name, description, status) => {
-                    let c = rep.create();
-                    c.id = id;
-                    c.categoryName = name;
-                    c.description = description;
-                    if (status)
-                        c.status = status;
-                    await rep.save(c);
+function testAllDbs(key, doTest, focus) {
+    if (focus === void 0) { focus = false; }
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var _this = this;
+        return tslib_1.__generator(this, function (_a) {
+            testAll(key, function (_a) {
+                var remult = _a.remult, createEntity = _a.createEntity;
+                return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var createData;
+                    var _this = this;
+                    return tslib_1.__generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                createData = function (doInsert, entity) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                    var rep;
+                                    var _this = this;
+                                    return tslib_1.__generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                if (!entity)
+                                                    entity = remult_3_entities_1.Categories;
+                                                return [4 /*yield*/, createEntity(entity)];
+                                            case 1:
+                                                rep = _a.sent();
+                                                if (!doInsert) return [3 /*break*/, 3];
+                                                return [4 /*yield*/, doInsert(function (id, name, description, status) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                                        var c;
+                                                        return tslib_1.__generator(this, function (_a) {
+                                                            switch (_a.label) {
+                                                                case 0:
+                                                                    c = rep.create();
+                                                                    c.id = id;
+                                                                    c.categoryName = name;
+                                                                    c.description = description;
+                                                                    if (status)
+                                                                        c.status = status;
+                                                                    return [4 /*yield*/, rep.save(c)];
+                                                                case 1:
+                                                                    _a.sent();
+                                                                    return [2 /*return*/];
+                                                            }
+                                                        });
+                                                    }); })];
+                                            case 2:
+                                                _a.sent();
+                                                _a.label = 3;
+                                            case 3: return [2 /*return*/, rep];
+                                        }
+                                    });
+                                }); };
+                                return [4 /*yield*/, doTest({
+                                        remult: remult,
+                                        createData: createData,
+                                        insertFourRows: function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                            var _this = this;
+                                            return tslib_1.__generator(this, function (_a) {
+                                                return [2 /*return*/, createData(function (i) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                                        return tslib_1.__generator(this, function (_a) {
+                                                            switch (_a.label) {
+                                                                case 0: return [4 /*yield*/, i(1, 'noam', 'x')];
+                                                                case 1:
+                                                                    _a.sent();
+                                                                    return [4 /*yield*/, i(4, 'yael', 'x')];
+                                                                case 2:
+                                                                    _a.sent();
+                                                                    return [4 /*yield*/, i(2, 'yoni', 'y')];
+                                                                case 3:
+                                                                    _a.sent();
+                                                                    return [4 /*yield*/, i(3, 'maayan', 'y')];
+                                                                case 4:
+                                                                    _a.sent();
+                                                                    return [2 /*return*/];
+                                                            }
+                                                        });
+                                                    }); })];
+                                            });
+                                        }); }
+                                    })];
+                            case 1:
+                                _b.sent();
+                                return [2 /*return*/];
+                        }
+                    });
                 });
-            return rep;
-        };
-        await doTest({
-            remult,
-            createData,
-            insertFourRows: async () => {
-                return createData(async (i) => {
-                    await i(1, 'noam', 'x');
-                    await i(4, 'yael', 'x');
-                    await i(2, 'yoni', 'y');
-                    await i(3, 'maayan', 'y');
-                });
-            }
+            }, focus);
+            return [2 /*return*/];
         });
-    }, focus);
+    });
 }
+exports.testAllDbs = testAllDbs;