Initial commit: Core packages

odoo-bringout-oca-ocb-web/web/static/tests/env_tests.js

@@ -0,0 +1,247 @@
+/** @odoo-module **/
+
+import { makeEnv, startServices } from "@web/env";
+import { registry } from "@web/core/registry";
+import {
+    clearRegistryWithCleanup,
+    clearServicesMetadataWithCleanup,
+    makeTestEnv,
+} from "./helpers/mock_env";
+import { makeDeferred, nextTick, patchWithCleanup } from "./helpers/utils";
+
+const serviceRegistry = registry.category("services");
+
+QUnit.module("env");
+
+QUnit.test("can start a service", async (assert) => {
+    serviceRegistry.add("test", {
+        start() {
+            return 17;
+        },
+    });
+    const env = await makeTestEnv();
+    assert.strictEqual(env.services.test, 17);
+});
+
+QUnit.test("properly handle crash in service start", async (assert) => {
+    patchWithCleanup(console, {
+        error: () => assert.step("log"),
+    });
+    serviceRegistry.add("test", {
+        start() {
+            return 17;
+        },
+    });
+    serviceRegistry.add("ouch", {
+        start() {
+            throw new Error("boom");
+        },
+    });
+    const env = await makeTestEnv();
+    assert.strictEqual(env.services.test, 17);
+    assert.ok(env.services.ouch instanceof Error);
+    assert.verifySteps(["log"]);
+});
+
+QUnit.test("properly handle crash in async service start", async (assert) => {
+    patchWithCleanup(console, {
+        error: () => assert.step("log"),
+    });
+    serviceRegistry.add("test", {
+        start() {
+            return 17;
+        },
+    });
+    serviceRegistry.add("ouch", {
+        async start() {
+            throw new Error("boom");
+        },
+    });
+    const env = await makeTestEnv();
+    assert.strictEqual(env.services.test, 17);
+    assert.ok(env.services.ouch instanceof Error);
+    assert.verifySteps(["log"]);
+});
+
+QUnit.test("can start an asynchronous service", async (assert) => {
+    const def = makeDeferred();
+    serviceRegistry.add("test", {
+        async start() {
+            assert.step("before");
+            const result = await def;
+            assert.step("after");
+            return result;
+        },
+    });
+    const prom = makeTestEnv();
+    await Promise.resolve(); // Wait for startServices
+    assert.verifySteps(["before"]);
+    def.resolve(15);
+    const env = await prom;
+    assert.verifySteps(["after"]);
+    assert.strictEqual(env.services.test, 15);
+});
+
+QUnit.test("can start two sequentially dependant asynchronous services", async (assert) => {
+    const def1 = makeDeferred();
+    const def2 = makeDeferred();
+    serviceRegistry.add("test2", {
+        dependencies: ["test1"],
+        start() {
+            assert.step("test2");
+            return def2;
+        },
+    });
+    serviceRegistry.add("test1", {
+        start() {
+            assert.step("test1");
+            return def1;
+        },
+    });
+    serviceRegistry.add("test3", {
+        dependencies: ["test2"],
+        start() {
+            assert.step("test3");
+        },
+    });
+    const promise = makeTestEnv();
+    await nextTick();
+    assert.verifySteps(["test1"]);
+    def2.resolve();
+    await nextTick();
+    assert.verifySteps([]);
+    def1.resolve();
+    await nextTick();
+    assert.verifySteps(["test2", "test3"]);
+    await promise;
+});
+
+QUnit.test("can start two independant asynchronous services in parallel", async (assert) => {
+    const def1 = makeDeferred();
+    const def2 = makeDeferred();
+    serviceRegistry.add("test1", {
+        start() {
+            assert.step("test1");
+            return def1;
+        },
+    });
+    serviceRegistry.add("test2", {
+        start() {
+            assert.step("test2");
+            return def2;
+        },
+    });
+    serviceRegistry.add("test3", {
+        dependencies: ["test1", "test2"],
+        start() {
+            assert.step("test3");
+        },
+    });
+    const promise = makeTestEnv();
+    await nextTick();
+    assert.verifySteps(["test1", "test2"]);
+    def1.resolve();
+    await nextTick();
+    assert.verifySteps([]);
+    def2.resolve();
+    await nextTick();
+    assert.verifySteps(["test3"]);
+    await promise;
+});
+
+QUnit.test("can start a service with a dependency", async (assert) => {
+    serviceRegistry.add("aang", {
+        dependencies: ["appa"],
+        start() {
+            assert.step("aang");
+        },
+    });
+    serviceRegistry.add("appa", {
+        start() {
+            assert.step("appa");
+        },
+    });
+    await makeTestEnv();
+    assert.verifySteps(["appa", "aang"]);
+});
+
+QUnit.test("get an object containing dependencies as second arg", async (assert) => {
+    serviceRegistry.add("aang", {
+        dependencies: ["appa"],
+        start(env, deps) {
+            assert.deepEqual(deps, { appa: "flying bison" });
+        },
+    });
+    serviceRegistry.add("appa", {
+        start() {
+            return "flying bison";
+        },
+    });
+    await makeTestEnv();
+});
+
+QUnit.test(
+    "startServices: throws if all dependencies are not met in the same microtick as the call",
+    async function (assert) {
+        assert.expect(3);
+        clearRegistryWithCleanup(serviceRegistry);
+        clearServicesMetadataWithCleanup();
+
+        const serviceA = {
+            start() {
+                return "a";
+            },
+        };
+        const serviceB = {
+            dependencies: ["a"],
+            start() {
+                return "b";
+            },
+        };
+        const env = makeEnv();
+
+        serviceRegistry.add("b", serviceB);
+        const prom = startServices(env);
+        await Promise.resolve();
+        await assert.rejects(
+            prom,
+            "Some services could not be started: b. Missing dependencies: a"
+        );
+        assert.deepEqual(env.services, {});
+
+        serviceRegistry.add("a", serviceA);
+        await startServices(env);
+        assert.deepEqual(env.services, { a: "a", b: "b" });
+    }
+);
+
+QUnit.test(
+    "startServices: waits for all synchronous code before attempting to start services",
+    async function (assert) {
+        assert.expect(1);
+        clearRegistryWithCleanup(serviceRegistry);
+        clearServicesMetadataWithCleanup();
+
+        const serviceA = {
+            start() {
+                return "a";
+            },
+        };
+        const serviceB = {
+            dependencies: ["a"],
+            start() {
+                return "b";
+            },
+        };
+
+        const env = makeEnv();
+        serviceRegistry.add("b", serviceB);
+        const prom = startServices(env);
+        // Dependency added in the same microtick doesn't cause startServices to throw even if it was added after the call
+        // (eg, a module is defined after main.js)
+        serviceRegistry.add("a", serviceA);
+
+        await prom;
+        assert.deepEqual(env.services, { a: "a", b: "b" });
+    }
+);