Initial commit: Report packages

odoo-bringout-oca-ocb-spreadsheet/spreadsheet/static/tests/data_fetching/data_source_test.js

@@ -0,0 +1,82 @@
+/** @odoo-module */
+
+import { nextTick } from "@web/../tests/helpers/utils";
+import { LoadableDataSource } from "@spreadsheet/data_sources/data_source";
+import { Deferred } from "@web/core/utils/concurrency";
+import { RPCError } from "@web/core/network/rpc_service";
+
+QUnit.module("spreadsheet data source", {}, () => {
+    QUnit.test(
+        "data source is ready after all concurrent requests are resolved",
+        async (assert) => {
+            const def1 = new Deferred();
+            const def2 = new Deferred();
+            let req = 0;
+            class TestDataSource extends LoadableDataSource {
+                constructor() {
+                    super(...arguments);
+                    this.data = null;
+                }
+                async _load() {
+                    this.data = null;
+                    switch (++req) {
+                        case 1:
+                            await def1;
+                            break;
+                        case 2:
+                            await def2;
+                            break;
+                    }
+                    this.data = "something";
+                }
+            }
+            const dataSource = new TestDataSource({
+                notify: () => assert.step("notify"),
+                notifyWhenPromiseResolves: () => assert.step("notify-from-promise"),
+                cancelPromise: () => assert.step("cancel-promise"),
+            });
+            dataSource.load();
+            assert.verifySteps(["notify-from-promise"]);
+            dataSource.load({ reload: true });
+            assert.strictEqual(dataSource.isReady(), false);
+            def1.resolve();
+            await nextTick();
+            assert.verifySteps(["cancel-promise", "notify-from-promise"]);
+            assert.strictEqual(dataSource.isReady(), false);
+            def2.resolve();
+            await nextTick();
+            assert.strictEqual(dataSource.isReady(), true);
+            assert.verifySteps([]);
+        }
+    );
+
+    QUnit.test("Datasources handle errors thrown at _load", async (assert) => {
+        class TestDataSource extends LoadableDataSource {
+            constructor() {
+                super(...arguments);
+                this.data = null;
+            }
+            async _load() {
+                this.data = await this._orm.call();
+            }
+        }
+
+        const dataSource = new TestDataSource({
+            notify: () => assert.step("notify"),
+            notifyWhenPromiseResolves: () => assert.step("notify-from-promise"),
+            cancelPromise: () => assert.step("cancel-promise"),
+            orm: {
+                call: () => {
+                    const error = new RPCError();
+                    error.data = { message: "Ya done!" };
+                    throw error;
+                },
+            },
+        });
+        await dataSource.load();
+        assert.verifySteps(["notify-from-promise"]);
+        assert.ok(dataSource._isFullyLoaded);
+        assert.notOk(dataSource._isValid);
+        assert.equal(dataSource._loadErrorMessage, "Ya done!");
+    });
+});

odoo-bringout-oca-ocb-spreadsheet/spreadsheet/static/tests/data_fetching/metadata_repository_test.js

@@ -0,0 +1,183 @@
+/** @odoo-module */
+
+import { nextTick } from "@web/../tests/helpers/utils";
+import { MetadataRepository } from "@spreadsheet/data_sources/metadata_repository";
+
+QUnit.module("spreadsheet > Metadata Repository", {}, () => {
+    QUnit.test("Fields_get are only loaded once", async function (assert) {
+        assert.expect(6);
+
+        const orm = {
+            call: async (model, method) => {
+                assert.step(`${method}-${model}`);
+                return model;
+            },
+        };
+
+        const metadataRepository = new MetadataRepository(orm);
+
+        const first = await metadataRepository.fieldsGet("A");
+        const second = await metadataRepository.fieldsGet("A");
+        const third = await metadataRepository.fieldsGet("B");
+
+        assert.strictEqual(first, "A");
+        assert.strictEqual(second, "A");
+        assert.strictEqual(third, "B");
+
+        assert.verifySteps(["fields_get-A", "fields_get-B"]);
+    });
+
+    QUnit.test("display_name_for on ir.model are only loaded once", async function (assert) {
+        assert.expect(6);
+
+        const orm = {
+            call: async (model, method, args) => {
+                if (method === "display_name_for" && model === "ir.model") {
+                    const [modelName] = args[0];
+                    assert.step(`${modelName}`);
+                    return [{ display_name: modelName, model: modelName }];
+                }
+            },
+        };
+
+        const metadataRepository = new MetadataRepository(orm);
+
+        const first = await metadataRepository.modelDisplayName("A");
+        const second = await metadataRepository.modelDisplayName("A");
+        const third = await metadataRepository.modelDisplayName("B");
+
+        assert.strictEqual(first, "A");
+        assert.strictEqual(second, "A");
+        assert.strictEqual(third, "B");
+
+        assert.verifySteps(["A", "B"]);
+    });
+
+    QUnit.test("Register label correctly memorize labels", function (assert) {
+        assert.expect(2);
+
+        const metadataRepository = new MetadataRepository({});
+
+        assert.strictEqual(metadataRepository.getLabel("model", "field", "value"), undefined);
+        const label = "label";
+        metadataRepository.registerLabel("model", "field", "value", label);
+        assert.strictEqual(metadataRepository.getLabel("model", "field", "value"), label);
+    });
+
+    QUnit.test("Name_get are collected and executed once by clock", async function (assert) {
+        const orm = {
+            call: async (model, method, args) => {
+                const ids = args[0];
+                assert.step(`${method}-${model}-[${ids.join(",")}]`);
+                return ids.map((id) => [id, id.toString()]);
+            },
+        };
+
+        const metadataRepository = new MetadataRepository(orm);
+        metadataRepository.addEventListener("labels-fetched", () => {
+            assert.step("labels-fetched");
+        });
+
+        assert.throws(() => metadataRepository.getRecordDisplayName("A", 1), /Data is loading/);
+        assert.throws(() => metadataRepository.getRecordDisplayName("A", 1), /Data is loading/);
+        assert.throws(() => metadataRepository.getRecordDisplayName("A", 2), /Data is loading/);
+        assert.throws(() => metadataRepository.getRecordDisplayName("B", 1), /Data is loading/);
+        assert.verifySteps([]);
+
+        await nextTick();
+        assert.verifySteps([
+            "name_get-A-[1,2]",
+            "name_get-B-[1]",
+            "labels-fetched",
+            "labels-fetched",
+        ]);
+
+        assert.strictEqual(metadataRepository.getRecordDisplayName("A", 1), "1");
+        assert.strictEqual(metadataRepository.getRecordDisplayName("A", 2), "2");
+        assert.strictEqual(metadataRepository.getRecordDisplayName("B", 1), "1");
+    });
+
+    QUnit.test("Name_get to fetch are cleared after being fetched", async function (assert) {
+        const orm = {
+            call: async (model, method, args) => {
+                const ids = args[0];
+                assert.step(`${method}-${model}-[${ids.join(",")}]`);
+                return ids.map((id) => [id, id.toString()]);
+            },
+        };
+
+        const metadataRepository = new MetadataRepository(orm);
+
+        assert.throws(() => metadataRepository.getRecordDisplayName("A", 1));
+        assert.verifySteps([]);
+
+        await nextTick();
+        assert.verifySteps(["name_get-A-[1]"]);
+
+        assert.throws(() => metadataRepository.getRecordDisplayName("A", 2));
+        await nextTick();
+        assert.verifySteps(["name_get-A-[2]"]);
+    });
+
+    QUnit.test(
+        "Assigning a result after triggering the request should not crash",
+        async function (assert) {
+            const orm = {
+                call: async (model, method, args) => {
+                    const ids = args[0];
+                    assert.step(`${method}-${model}-[${ids.join(",")}]`);
+                    return ids.map((id) => [id, id.toString()]);
+                },
+            };
+
+            const metadataRepository = new MetadataRepository(orm);
+
+            assert.throws(() => metadataRepository.getRecordDisplayName("A", 1));
+            assert.verifySteps([]);
+            metadataRepository.setDisplayName("A", 1, "test");
+            assert.strictEqual(metadataRepository.getRecordDisplayName("A", 1), "test");
+
+            await nextTick();
+            assert.verifySteps(["name_get-A-[1]"]);
+            assert.strictEqual(metadataRepository.getRecordDisplayName("A", 1), "1");
+        }
+    );
+
+    QUnit.test(
+        "Name_get will retry with one id by request in case of failure",
+        async function (assert) {
+            const orm = {
+                call: async (model, method, args) => {
+                    const ids = args[0];
+                    assert.step(`${method}-${model}-[${ids.join(",")}]`);
+                    if (model === "B" && ids.includes(1)) {
+                        throw new Error("Missing");
+                    }
+                    return ids.map((id) => [id, id.toString()]);
+                },
+            };
+
+            const metadataRepository = new MetadataRepository(orm);
+
+            assert.throws(() => metadataRepository.getRecordDisplayName("A", 1), /Data is loading/);
+            assert.throws(() => metadataRepository.getRecordDisplayName("B", 1), /Data is loading/);
+            assert.throws(() => metadataRepository.getRecordDisplayName("B", 2), /Data is loading/);
+            assert.verifySteps([]);
+
+            await nextTick();
+            assert.verifySteps([
+                "name_get-A-[1]",
+                "name_get-B-[1,2]",
+                "name_get-B-[1]",
+                "name_get-B-[2]",
+            ]);
+
+            assert.strictEqual(metadataRepository.getRecordDisplayName("A", 1), "1");
+            assert.throws(
+                () => metadataRepository.getRecordDisplayName("B", 1),
+                /Unable to fetch the label of 1 of model B/
+            );
+            assert.strictEqual(metadataRepository.getRecordDisplayName("B", 2), "2");
+        }
+    );
+});

odoo-bringout-oca-ocb-spreadsheet/spreadsheet/static/tests/data_fetching/server_data_test.js

@@ -0,0 +1,305 @@
+/** @odoo-module */
+
+import { nextTick } from "@web/../tests/helpers/utils";
+import { LoadingDataError } from "@spreadsheet/o_spreadsheet/errors";
+import BatchEndpoint, { Request, ServerData } from "@spreadsheet/data_sources/server_data";
+
+QUnit.module("spreadsheet server data", {}, () => {
+    QUnit.test("simple synchronous get", async (assert) => {
+        const orm = {
+            call: async (model, method, args) => {
+                assert.step(`${model}/${method}`);
+                return args[0];
+            },
+        };
+        const serverData = new ServerData(orm, {
+            whenDataIsFetched: () => assert.step("data-fetched-notification"),
+        });
+        assert.throws(
+            () => serverData.get("partner", "get_something", [5]),
+            LoadingDataError,
+            "it should throw when it's not loaded"
+        );
+        await nextTick();
+        assert.verifySteps(["partner/get_something", "data-fetched-notification"]);
+        assert.deepEqual(serverData.get("partner", "get_something", [5]), 5);
+        assert.verifySteps([]);
+    });
+
+    QUnit.test("synchronous get which returns an error", async (assert) => {
+        const orm = {
+            call: async (model, method, args) => {
+                assert.step(`${model}/${method}`);
+                throw new Error("error while fetching data");
+            },
+        };
+        const serverData = new ServerData(orm, {
+            whenDataIsFetched: () => assert.step("data-fetched-notification"),
+        });
+        assert.throws(
+            () => serverData.get("partner", "get_something", [5]),
+            LoadingDataError,
+            "it should throw when it's not loaded"
+        );
+        await nextTick();
+        assert.verifySteps(["partner/get_something", "data-fetched-notification"]);
+        assert.throws(() => serverData.get("partner", "get_something", [5]), Error);
+        assert.verifySteps([]);
+    });
+
+    QUnit.test("simple async fetch", async (assert) => {
+        const orm = {
+            call: async (model, method, args) => {
+                assert.step(`${model}/${method}`);
+                return args[0];
+            },
+        };
+        const serverData = new ServerData(orm, {
+            whenDataIsFetched: () => assert.step("data-fetched-notification"),
+        });
+        const result = await serverData.fetch("partner", "get_something", [5]);
+        assert.deepEqual(result, 5);
+        assert.verifySteps(["partner/get_something"]);
+        assert.deepEqual(await serverData.fetch("partner", "get_something", [5]), 5);
+        assert.verifySteps([]);
+    });
+
+    QUnit.test("async fetch which throws an error", async (assert) => {
+        const orm = {
+            call: async (model, method, args) => {
+                assert.step(`${model}/${method}`);
+                throw new Error("error while fetching data");
+            },
+        };
+        const serverData = new ServerData(orm, {
+            whenDataIsFetched: () => assert.step("data-fetched-notification"),
+        });
+        assert.rejects(serverData.fetch("partner", "get_something", [5]));
+        assert.verifySteps(["partner/get_something"]);
+        assert.rejects(serverData.fetch("partner", "get_something", [5]));
+        assert.verifySteps([]);
+    });
+
+    QUnit.test("two identical concurrent async fetch", async (assert) => {
+        const orm = {
+            call: async (model, method, args) => {
+                assert.step(`${model}/${method}`);
+                return args[0];
+            },
+        };
+        const serverData = new ServerData(orm, {
+            whenDataIsFetched: () => assert.step("data-fetched-notification"),
+        });
+        const [result1, result2] = await Promise.all([
+            serverData.fetch("partner", "get_something", [5]),
+            serverData.fetch("partner", "get_something", [5]),
+        ]);
+        assert.verifySteps(["partner/get_something"], "it should have fetch the data once");
+        assert.deepEqual(result1, 5);
+        assert.deepEqual(result2, 5);
+        assert.verifySteps([]);
+    });
+
+    QUnit.test("batch get with a single item", async (assert) => {
+        const orm = {
+            call: async (model, method, args) => {
+                assert.step(`${model}/${method}`);
+                return args[0];
+            },
+        };
+        const serverData = new ServerData(orm, {
+            whenDataIsFetched: () => assert.step("data-fetched-notification"),
+        });
+        assert.throws(
+            () => serverData.batch.get("partner", "get_something_in_batch", 5),
+            LoadingDataError,
+            "it should throw when it's not loaded"
+        );
+        await nextTick();
+        assert.verifySteps(["partner/get_something_in_batch", "data-fetched-notification"]);
+        assert.deepEqual(serverData.batch.get("partner", "get_something_in_batch", 5), 5);
+        assert.verifySteps([]);
+    });
+
+    QUnit.test("batch get with multiple items", async (assert) => {
+        const orm = {
+            call: async (model, method, args) => {
+                assert.step(`${model}/${method}`);
+                return args[0];
+            },
+        };
+        const serverData = new ServerData(orm, {
+            whenDataIsFetched: () => assert.step("data-fetched-notification"),
+        });
+        assert.throws(
+            () => serverData.batch.get("partner", "get_something_in_batch", 5),
+            LoadingDataError,
+            "it should throw when it's not loaded"
+        );
+        assert.throws(
+            () => serverData.batch.get("partner", "get_something_in_batch", 6),
+            LoadingDataError,
+            "it should throw when it's not loaded"
+        );
+        await nextTick();
+        assert.verifySteps(["partner/get_something_in_batch", "data-fetched-notification"]);
+        assert.deepEqual(serverData.batch.get("partner", "get_something_in_batch", 5), 5);
+        assert.deepEqual(serverData.batch.get("partner", "get_something_in_batch", 6), 6);
+        assert.verifySteps([]);
+    });
+
+    QUnit.test("batch get with one error", async (assert) => {
+        const orm = {
+            call: async (model, method, args) => {
+                assert.step(`${model}/${method}`);
+                if (args[0].includes(5)) {
+                    throw new Error("error while fetching data");
+                }
+                return args[0];
+            },
+        };
+        const serverData = new ServerData(orm, {
+            whenDataIsFetched: () => assert.step("data-fetched-notification"),
+        });
+        assert.throws(
+            () => serverData.batch.get("partner", "get_something_in_batch", 4),
+            LoadingDataError,
+            "it should throw when it's not loaded"
+        );
+        assert.throws(
+            () => serverData.batch.get("partner", "get_something_in_batch", 5),
+            LoadingDataError,
+            "it should throw when it's not loaded"
+        );
+        assert.throws(
+            () => serverData.batch.get("partner", "get_something_in_batch", 6),
+            LoadingDataError,
+            "it should throw when it's not loaded"
+        );
+        await nextTick();
+        assert.verifySteps([
+            // one call for the batch
+            "partner/get_something_in_batch",
+            // retries one by one
+            "partner/get_something_in_batch",
+            "partner/get_something_in_batch",
+            "partner/get_something_in_batch",
+            "data-fetched-notification",
+        ]);
+        assert.deepEqual(serverData.batch.get("partner", "get_something_in_batch", 4), 4);
+        assert.throws(() => serverData.batch.get("partner", "get_something_in_batch", 5), Error);
+        assert.deepEqual(serverData.batch.get("partner", "get_something_in_batch", 6), 6);
+        assert.verifySteps([]);
+    });
+
+    QUnit.test("concurrently fetch then get the same request", async (assert) => {
+        const orm = {
+            call: async (model, method, args) => {
+                assert.step(`${model}/${method}`);
+                return args[0];
+            },
+        };
+        const serverData = new ServerData(orm, {
+            whenDataIsFetched: () => assert.step("data-fetched-notification"),
+        });
+        const promise = serverData.fetch("partner", "get_something", [5]);
+        assert.throws(() => serverData.get("partner", "get_something", [5]), LoadingDataError);
+        const result = await promise;
+        await nextTick();
+        assert.verifySteps(
+            ["partner/get_something", "partner/get_something", "data-fetched-notification"],
+            "it loads the data independently"
+        );
+        assert.deepEqual(result, 5);
+        assert.deepEqual(serverData.get("partner", "get_something", [5]), 5);
+        assert.verifySteps([]);
+    });
+
+    QUnit.test("concurrently get then fetch the same request", async (assert) => {
+        const orm = {
+            call: async (model, method, args) => {
+                assert.step(`${model}/${method}`);
+                return args[0];
+            },
+        };
+        const serverData = new ServerData(orm, {
+            whenDataIsFetched: () => assert.step("data-fetched-notification"),
+        });
+        assert.throws(() => serverData.get("partner", "get_something", [5]), LoadingDataError);
+        const result = await serverData.fetch("partner", "get_something", [5]);
+        assert.verifySteps(
+            ["partner/get_something", "partner/get_something", "data-fetched-notification"],
+            "it should have fetch the data once"
+        );
+        assert.deepEqual(result, 5);
+        assert.deepEqual(serverData.get("partner", "get_something", [5]), 5);
+        assert.verifySteps([]);
+    });
+
+    QUnit.test("concurrently batch get then fetch the same request", async (assert) => {
+        const orm = {
+            call: async (model, method, args) => {
+                assert.step(`${model}/${method}`);
+                return args[0];
+            },
+        };
+        const serverData = new ServerData(orm, {
+            whenDataIsFetched: () => assert.step("data-fetched-notification"),
+        });
+        assert.throws(() => serverData.batch.get("partner", "get_something", 5), LoadingDataError);
+        const result = await serverData.fetch("partner", "get_something", [5]);
+        await nextTick();
+        assert.verifySteps(
+            ["partner/get_something", "partner/get_something", "data-fetched-notification"],
+            "it should have fetch the data once"
+        );
+        assert.deepEqual(result, 5);
+        assert.deepEqual(serverData.batch.get("partner", "get_something", 5), 5);
+        assert.verifySteps([]);
+    });
+
+    QUnit.test("concurrently get and batch get the same request", async (assert) => {
+        const orm = {
+            call: async (model, method, args) => {
+                assert.step(`${model}/${method}`);
+                return args[0];
+            },
+        };
+        const serverData = new ServerData(orm, {
+            whenDataIsFetched: () => assert.step("data-fetched-notification"),
+        });
+        assert.throws(() => serverData.batch.get("partner", "get_something", 5), LoadingDataError);
+        assert.throws(() => serverData.get("partner", "get_something", [5]), LoadingDataError);
+        await nextTick();
+        assert.verifySteps(
+            ["partner/get_something", "data-fetched-notification"],
+            "it should have fetch the data once"
+        );
+        assert.deepEqual(serverData.get("partner", "get_something", [5]), 5);
+        assert.deepEqual(serverData.batch.get("partner", "get_something", 5), 5);
+        assert.verifySteps([]);
+    });
+
+    QUnit.test("Call the correct callback after a batch result", async (assert) => {
+        const orm = {
+            call: async (model, method, args) => {
+                if (args[0].includes(5)) {
+                    throw new Error("error while fetching data");
+                }
+                return args[0];
+            },
+        };
+        const batchEndpoint = new BatchEndpoint(orm, "partner", "get_something", {
+            whenDataIsFetched: () => {},
+            successCallback: () => assert.step("success-callback"),
+            failureCallback: () => assert.step("failure-callback"),
+        });
+        const request = new Request("partner", "get_something", [4]);
+        const request2 = new Request("partner", "get_something", [5]);
+        batchEndpoint.call(request);
+        batchEndpoint.call(request2);
+        assert.verifySteps([]);
+        await nextTick();
+        assert.verifySteps(["success-callback", "failure-callback"]);
+    });
+});