@webda/core 3.16.4 → 4.0.0-beta.2

package/lib/stores/store.spec.js

@@ -4,15 +4,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { suite, test } from "@testdeck/mocha";
+import { test } from "@testdeck/mocha";
 import * as assert from "assert";
 import { stub } from "sinon";
-import { v4 as uuidv4 } from "uuid";
-import { Ident } from "../../test/models/ident.js";
-import { StoreParameters, WebdaError } from "../index.js";
+import { randomUUID } from "crypto";
+import { TestIdent } from "../test.js";
+import { AggregatorService, MapperService } from "../index.js";
 import { CoreModel } from "../models/coremodel.js";
-import { WebdaTest } from "../test.js";
-import { HttpContext } from "../utils/httpcontext.js";
+import { WebdaSimpleTest } from "../test.js";
 import { StoreNotFoundError, UpdateConditionFailError } from "./store.js";
 /**
  * Fake model that refuse the half of the items
@@ -25,50 +24,31 @@ export class PermissionModel extends CoreModel {
         return true;
     }
 }
-let StoreParametersTest = class StoreParametersTest {
-    cov() {
-        let params = new StoreParameters({ expose: "/plop", lastUpdateField: "bz", creationDateField: "c" }, undefined);
-        assert.deepStrictEqual(params.expose, {
-            queryMethod: "GET",
-            url: "/plop",
-            restrict: {}
-        });
-        assert.throws(() => new StoreParameters({ map: {} }, undefined), Error);
-        assert.throws(() => new StoreParameters({ index: [] }, undefined), Error);
-    }
-};
-__decorate([
-    test
-], StoreParametersTest.prototype, "cov", null);
-StoreParametersTest = __decorate([
-    suite
-], StoreParametersTest);
-class StoreTest extends WebdaTest {
-    /**
-     * By default no testing index
-     * @returns
-     */
-    async getIndex() {
-        return undefined;
-    }
-    /**
-     * Recreate index if needed
-     */
-    async recreateIndex() { }
+class StoreTest extends WebdaSimpleTest {
     async before() {
         await super.before();
-        await this.getUserStore()?.__clean();
-        await this.getIdentStore()?.__clean();
-        await this.recreateIndex();
+        this.userStore = await this.getUserStore();
+        this.identStore = await this.getIdentStore();
+        // ensure service are registered
+        this.registerService(this.userStore);
+        this.registerService(this.identStore);
+        await this.userStore?.__clean();
+        await this.identStore?.__clean();
+        this.getIdentStore = () => {
+            throw new Error("Use this.identStore instead");
+        };
+        this.getUserStore = () => {
+            throw new Error("Use this.userStore instead");
+        };
     }
     getModelClass() {
-        return Ident;
+        return TestIdent;
     }
     /**
      * Get the base of documents to query
      */
     getQueryDocuments() {
-        let docs = [];
+        const docs = [];
         for (let i = 0; i < 1000; i++) {
             docs.push({
                 state: ["CA", "OR", "NY", "FL"][i % 4],
@@ -86,14 +66,14 @@ class StoreTest extends WebdaTest {
      * Fill the Store with data to be queried
      */
     async fillForQuery() {
-        let userStore = this.getUserStore();
+        const userStore = this.userStore;
         this.webda.getApplication().getModel("Webda/User").prototype.canAct = async () => true;
         userStore._model.prototype.canAct = async () => true;
         await Promise.all(this.getQueryDocuments().map(d => userStore.save(d)));
         return userStore;
     }
     async query() {
-        let userStore = await this.fillForQuery();
+        const userStore = await this.fillForQuery();
         const queries = {
             'state = "CA"': 250,
             "team.id > 15": 200,
@@ -113,7 +93,7 @@ class StoreTest extends WebdaTest {
             "role = 4": 100,
             "": 1000
         };
-        for (let i in queries) {
+        for (const i in queries) {
             assert.strictEqual((await userStore.query(i)).results.length, queries[i], `Query: ${i} should return ${queries[i]}`);
         }
         // Verify pagination system
@@ -131,44 +111,6 @@ class StoreTest extends WebdaTest {
                 assert.strictEqual(res.results.length, 100, `Query: LIMIT 100 ${offset ? 'OFFSET "' + offset + '"' : ""} should return 0`);
             }
         } while (offset !== undefined);
-        // Verify permission issue and half pagination
-        userStore.setModel(PermissionModel);
-        userStore.getParameters().forceModel = true;
-        if (userStore._cacheStore) {
-            userStore._cacheStore.getParameters().forceModel = true;
-        }
-        let context = await this.newContext();
-        // Verify pagination system
-        i = 0;
-        let total = 0;
-        let q;
-        // To ensure we trigger slowQuery
-        userStore.getParameters().slowQueryThreshold = 0;
-        do {
-            q = `team.id > 10 LIMIT 100 ${offset ? 'OFFSET "' + offset + '"' : ""}`;
-            context.setHttpContext(new HttpContext("test.webda.io", i++ % 2 ? "GET" : "PUT", userStore.getParameters().expose.url + "?q=" + encodeURI(q), "https", 443));
-            context.getHttpContext().setBody({ q });
-            context.getParameters().q = q;
-            // @ts-ignore
-            await userStore.httpQuery(context);
-            res = JSON.parse(context.getResponseBody());
-            offset = res.continuationToken;
-            total += res.results.length;
-        } while (offset !== undefined);
-        assert.strictEqual(total, 180);
-        q = "BAD QUERY !";
-        context.setHttpContext(new HttpContext("test.webda.io", "PUT", userStore.getParameters().expose.url, "https", 443));
-        context.getHttpContext().setBody({ q });
-        await assert.rejects(() => userStore["httpQuery"](context), (err) => err.getResponseCode() === 400);
-        let mock = stub(userStore, "query").callsFake(() => {
-            throw new Error("Plop");
-        });
-        try {
-            await assert.rejects(() => userStore["httpQuery"](context), /Plop/);
-        }
-        finally {
-            mock.restore();
-        }
         return userStore;
     }
     /**
@@ -184,8 +126,8 @@ class StoreTest extends WebdaTest {
         };
     }
     async queryOrder() {
-        let userStore = await this.fillForQuery();
-        let model = await userStore.save({
+        const userStore = await this.fillForQuery();
+        const model = await userStore.save({
             order: 996,
             state: "CA",
             team: { id: 16 }
@@ -231,11 +173,24 @@ class StoreTest extends WebdaTest {
         }
     }
     async mapper() {
-        let identStore = this.getIdentStore();
-        let userStore = this.getUserStore();
-        let user1, ident1, ident2, user2;
-        var eventFired = 0;
-        var events = [
+        // Create a mapper - keep the test here as it is a good test for stores
+        const identStore = this.identStore;
+        const userStore = this.userStore;
+        await this.addService(MapperService, {
+            source: identStore.getName(),
+            targetAttribute: "idents",
+            target: userStore.getName(),
+            attribute: "_user",
+            fields: ["type", "_lastUpdate"],
+            cascade: true
+        }, "Mapper");
+        await this.addService(AggregatorService, {
+            source: identStore.getName(),
+            key: "idents-index",
+            fields: ["type"]
+        });
+        let eventFired = 0;
+        const events = [
             "Store.Save",
             "Store.Saved",
             "Store.Get",
@@ -246,20 +201,20 @@ class StoreTest extends WebdaTest {
             "Store.Query",
             "Store.Queried"
         ];
-        for (let evt in events) {
-            identStore.on(events[evt], function (evt) {
+        for (const evt in events) {
+            identStore.on(events[evt], evt => {
                 eventFired++;
             });
         }
         assert.strictEqual(await userStore.get(undefined), undefined);
-        user1 = (await userStore.save({
+        let user1 = (await userStore.save({
             name: "test"
         })).getUuid();
         let user = await userStore.get(user1);
         // Save a user and add an ident
         assert.notStrictEqual(user, undefined);
         user1 = user.getUuid();
-        ident1 = await identStore.save({
+        const ident1 = await identStore.save({
             type: "facebook",
             _user: user.getUuid()
         });
@@ -269,7 +224,7 @@ class StoreTest extends WebdaTest {
         assert.notStrictEqual(user.idents, undefined);
         assert.strictEqual(user.idents.length, 1);
         // Retrieve index to verify it is in it too
-        let index = await this.getIndex();
+        const index = await this.webda.getRegistry().get("idents-index");
         // Do not force index test for store
         if (index) {
             assert.notStrictEqual(index[ident1.uuid], undefined);
@@ -297,7 +252,7 @@ class StoreTest extends WebdaTest {
         await user.refresh();
         assert.notStrictEqual(user.idents[0]._lastUpdate.length, 0);
         this.assertLastUpdateNotEqual(user.idents[0]._lastUpdate, lastUpdate, "lastUpdate on a map after deleteItemFromCollection");
-        ident2 = await identStore.save({
+        const ident2 = await identStore.save({
             type: "google",
             _user: user.uuid
         });
@@ -314,7 +269,7 @@ class StoreTest extends WebdaTest {
         }
         ident2.type = "google2";
         // Update ident2 to check mapper update
-        let res = await identStore.patch({
+        const res = await identStore.patch({
             uuid: ident2.uuid,
             type: "google2"
         }, true, null);
@@ -336,7 +291,7 @@ class StoreTest extends WebdaTest {
         user = await userStore.save({
             name: "test2"
         });
-        user2 = user.uuid;
+        const user2 = user.uuid;
         // Move ident2 from user1 to user2
         await identStore.patch({
             _user: user.uuid,
@@ -369,24 +324,19 @@ class StoreTest extends WebdaTest {
         assert.strictEqual(user.idents[0].type, "google2");
         // Verify delete cascade
         await userStore.delete(user2);
-        let ident = await identStore.get(ident2.uuid);
-        assert.strictEqual(ident.__deleted, true);
+        const ident = await identStore.get(ident2.uuid);
+        assert.strictEqual(ident, undefined);
         // Check index
         if (index) {
             await index.refresh();
             assert.strictEqual(index[ident2.uuid], undefined);
             assert.strictEqual(index[ident1.uuid], undefined);
         }
-        assert.strictEqual(eventFired, 9);
-        // Force sync delete - overriding the asyncDelete parameter
-        await identStore.forceDelete(ident2.uuid);
-        ident = await identStore.get(ident2.uuid);
-        assert.strictEqual(ident, undefined);
-        assert.strictEqual(eventFired, 11);
+        assert.strictEqual(eventFired, 8);
     }
     async collection() {
-        let identStore = this.getIdentStore();
-        var ident;
+        const identStore = this.identStore;
+        let ident;
         ident = await identStore.save({
             test: "plop"
         });
@@ -446,16 +396,14 @@ class StoreTest extends WebdaTest {
         assert.strictEqual(ident.actions[0].uuid, "action_2");
     }
     async getAll() {
-        let userStore = this.getUserStore();
-        var user1;
-        var user3;
-        user1 = await userStore.save({
+        const userStore = this.userStore;
+        const user1 = await userStore.save({
             name: "test1"
         });
         await userStore.save({
             name: "test2"
         });
-        user3 = await userStore.save({
+        const user3 = await userStore.save({
             name: "test3"
         });
         let users = await userStore.getAll();
@@ -463,15 +411,15 @@ class StoreTest extends WebdaTest {
         assert.strictEqual(users[0] instanceof userStore._model, true);
         assert.strictEqual(users[1] instanceof userStore._model, true);
         assert.strictEqual(users[2] instanceof userStore._model, true);
-        users = await userStore.getAll([user1.uuid, user3.uuid, uuidv4()]);
+        users = await userStore.getAll([user1.uuid, user3.uuid, randomUUID()]);
         assert.strictEqual(users.length, 2);
         assert.strictEqual(users[0] instanceof userStore._model, true);
         assert.strictEqual(users[1] instanceof userStore._model, true);
     }
     async crud() {
-        let identStore = this.getIdentStore();
-        var eventFired = 0;
-        var events = [
+        const identStore = this.identStore;
+        let eventFired = 0;
+        const events = [
             "Store.Save",
             "Store.Saved",
             "Store.Get",
@@ -485,8 +433,8 @@ class StoreTest extends WebdaTest {
             "Store.Query",
             "Store.Queried"
         ];
-        for (let evt in events) {
-            identStore.on(events[evt], function (e) {
+        for (const evt in events) {
+            identStore.on(events[evt], e => {
                 eventFired++;
             });
         }
@@ -521,7 +469,6 @@ class StoreTest extends WebdaTest {
         getter.details.blank = "";
         getter.details.bouzouf = undefined;
         getter.empty = [];
-        let object;
         this.log("DEBUG", "Update ident");
         await identStore.update(getter);
         assert.strictEqual(eventFired, 2);
@@ -534,7 +481,7 @@ class StoreTest extends WebdaTest {
         assert.strictEqual(eventFired, 2);
         eventFired = 0;
         this.log("DEBUG", "Get ident to check update");
-        object = await identStore.get(ident1.uuid);
+        const object = await identStore.get(ident1.uuid);
         this.log("DEBUG", "Retrieved object", object);
         assert.strictEqual(object.test, "plop2");
         assert.strictEqual(object.details.plop, "plop2");
@@ -564,7 +511,7 @@ class StoreTest extends WebdaTest {
         assert.strictEqual(ident1.counter, -2);
         // Check DELETE
         eventFired = 0;
-        await identStore.forceDelete(ident1.uuid);
+        await identStore.delete(ident1.uuid);
         assert.strictEqual(eventFired, 2);
         eventFired = 0;
         ident = await identStore.get(ident1.uuid);
@@ -576,42 +523,42 @@ class StoreTest extends WebdaTest {
         assert.notStrictEqual(d1, d2, msg);
     }
     async exists() {
-        let store = this.getIdentStore();
-        let model = await store.save({});
+        const store = this.identStore;
+        const model = await store.save({});
         assert.ok(await store.exists(model.getUuid()));
         assert.ok(await store.exists(model));
-        assert.ok(!(await store.exists(uuidv4())));
+        assert.ok(!(await store.exists(randomUUID())));
     }
     async incrementAttribute() {
-        let store = this.getIdentStore();
-        let model = await store.save({ counter: 0 });
+        const store = this.identStore;
+        const model = await store.save({ counter: 0 });
         await store.incrementAttribute(model.getUuid(), "counter", 3);
         await store.incrementAttribute(model.getUuid(), "counter2", 2);
         await model.refresh();
         assert.strictEqual(model.counter, 3);
         assert.strictEqual(model.counter2, 2);
-        await assert.rejects(() => store.incrementAttribute(uuidv4(), "counter", 1), StoreNotFoundError);
+        await assert.rejects(() => store.incrementAttribute(randomUUID(), "counter", 1), StoreNotFoundError);
     }
     async removeAttribute() {
-        let store = this.getIdentStore();
-        let model = await store.save({ counter: 0, counter2: 12, counter3: 13 });
+        const store = this.identStore;
+        const model = await store.save({ counter: 0, counter2: 12, counter3: 13 });
         await store.removeAttribute(model.getUuid(), "counter");
         await model.refresh();
         assert.strictEqual(model.counter, undefined);
-        await assert.rejects(() => store.removeAttribute(uuidv4(), "counter"), StoreNotFoundError);
+        await assert.rejects(() => store.removeAttribute(randomUUID(), "counter"), StoreNotFoundError);
         await assert.rejects(() => store.removeAttribute(model.getUuid(), "counter2", 10, "counter3"), UpdateConditionFailError);
         await model.refresh();
         assert.strictEqual(model.counter2, 12);
     }
     async setAttribute() {
-        let store = this.getIdentStore();
-        let model = await store.save({ counter: 0 });
+        const store = this.identStore;
+        const model = await store.save({ counter: 0 });
         await store.setAttribute(model.getUuid(), "counter", 3);
         await store.setAttribute(model.getUuid(), "status", "TESTED");
         await model.refresh();
         assert.strictEqual(model.counter, 3);
         assert.strictEqual(model.status, "TESTED");
-        await assert.rejects(() => store.setAttribute(uuidv4(), "counter", 4), StoreNotFoundError);
+        await assert.rejects(() => store.setAttribute(randomUUID(), "counter", 4), StoreNotFoundError);
         store.on("Store.PatchUpdate", async () => {
             model._lastUpdate = new Date(100);
             // @ts-ignore
@@ -625,10 +572,10 @@ class StoreTest extends WebdaTest {
             await this.sleep(1);
         });
         await assert.rejects(() => store.setAttribute(model.getUuid(), "counter", 4), err => err instanceof StoreNotFoundError || err instanceof UpdateConditionFailError);
-        await assert.rejects(() => store.setAttribute(uuidv4(), "counter", 4), err => err instanceof StoreNotFoundError || err instanceof UpdateConditionFailError);
+        await assert.rejects(() => store.setAttribute(randomUUID(), "counter", 4), err => err instanceof StoreNotFoundError || err instanceof UpdateConditionFailError);
     }
     async deleteAsync() {
-        let store = this.getIdentStore();
+        const store = this.identStore;
         let model = await store.save({ counter: 1 });
         // Delete with condition
         await assert.rejects(() => store.delete(model.getUuid(), 4, "counter"), UpdateConditionFailError);
@@ -637,11 +584,11 @@ class StoreTest extends WebdaTest {
         model = await store.save({ counter: 2 });
         await store.delete(model);
         // Deleting a non-existing object should be ignored
-        await store.forceDelete(uuidv4());
+        await store.delete(randomUUID());
     }
     async delete() {
         // UserStore is not supposed to be async
-        let store = this.getUserStore();
+        const store = this.userStore;
         let model = await store.save({ counter: 1 });
         // Delete with condition
         await assert.rejects(() => store.delete(model.getUuid(), 4, "counter"), UpdateConditionFailError);
@@ -650,11 +597,11 @@ class StoreTest extends WebdaTest {
         model = await store.save({ counter: 2 });
         await store.delete(model);
         // Deleting a non-existing object should be ignored
-        await store.forceDelete(uuidv4());
+        await store.delete(randomUUID());
     }
     async deleteConcurrent() {
-        let store = this.getUserStore();
-        let model = await store.save({ counter: 1 });
+        const store = this.userStore;
+        const model = await store.save({ counter: 1 });
         store.addListener("Store.Delete", async () => {
             await store.incrementAttribute(model.getUuid(), "counter", 1);
         });
@@ -663,8 +610,8 @@ class StoreTest extends WebdaTest {
         await store.delete(model.getUuid(), 2, "counter");
     }
     async conditionUpdate() {
-        let store = this.getIdentStore();
-        let model = await store.save({ counter: 1 });
+        const store = this.identStore;
+        const model = await store.save({ counter: 1 });
         assert.ok(await store.conditionalPatch(model.getUuid(), {
             plop: 12,
             counter: 2
@@ -684,14 +631,14 @@ class StoreTest extends WebdaTest {
         }, "counter", 1), /Fake Error/);
     }
     async update(delay = 1) {
-        let store = this.getIdentStore();
-        let model = await store.save({ counter: 1 });
+        const store = this.identStore;
+        const model = await store.save({ counter: 1 });
         model.saveUpdateCompat = true;
         await store.save(model, await this.newContext());
         model.saveInnerMethod = true;
         model.setContext(await this.newContext());
         await model.save();
-        let model2 = await store.get(model.getUuid());
+        const model2 = await store.get(model.getUuid());
         store.on("Store.Update", async () => {
             model2._lastUpdate = new Date(100);
             // @ts-ignore
@@ -707,13 +654,13 @@ class StoreTest extends WebdaTest {
             await this.sleep(delay);
         });
         await assert.rejects(() => store.update(model), err => err instanceof StoreNotFoundError || err instanceof UpdateConditionFailError);
-        await assert.rejects(() => store.update({ uuid: uuidv4(), test: true }), err => err instanceof StoreNotFoundError || err instanceof UpdateConditionFailError);
+        await assert.rejects(() => store.update({ uuid: randomUUID(), test: true }), err => err instanceof StoreNotFoundError || err instanceof UpdateConditionFailError);
     }
     async upsertItem() {
-        let store = this.getIdentStore();
+        const store = this.identStore;
         this.log("DEBUG", "Save empty logs array");
-        let model = await store.save({ logs: [] });
-        let ps = [];
+        const model = await store.save({ logs: [] });
+        const ps = [];
         this.log("DEBUG", "Upsert 10 lines");
         for (let i = 0; i < 10; i++) {
             ps.push(store.upsertItemToCollection(model.getUuid(), "logs", `line${i}`));
@@ -723,12 +670,12 @@ class StoreTest extends WebdaTest {
         assert.strictEqual(model.logs.length, 10);
         // Depending on the implementation it can be swallowed by the backend
         this.log("DEBUG", "Upsert on unknown doc");
-        await assert.rejects(() => store.upsertItemToCollection(uuidv4(), "logs", `line`), err => err instanceof StoreNotFoundError || err instanceof UpdateConditionFailError);
+        await assert.rejects(() => store.upsertItemToCollection(randomUUID(), "logs", `line`), err => err instanceof StoreNotFoundError || err instanceof UpdateConditionFailError);
         this.log("DEBUG", "Delete on unknown doc");
-        await assert.rejects(() => store.deleteItemFromCollection(uuidv4(), "logs", 0, undefined, undefined), err => err instanceof StoreNotFoundError || err instanceof UpdateConditionFailError);
+        await assert.rejects(() => store.deleteItemFromCollection(randomUUID(), "logs", 0, undefined, undefined), err => err instanceof StoreNotFoundError || err instanceof UpdateConditionFailError);
     }
     async put() {
-        const store = this.getIdentStore();
+        const store = this.identStore;
         const uuid = store.getWebda().getUuid();
         if (await store.exists(uuid)) {
             await store.delete(uuid);
@@ -737,122 +684,6 @@ class StoreTest extends WebdaTest {
         // Verify put acts like a upsert
         await store.put(uuid, { test: false });
     }
-    async httpCRUD(url = "/users") {
-        let eventFired;
-        let userStore = this.getUserStore();
-        let ctx, executor;
-        await userStore.__clean();
-        ctx = await this.newContext({});
-        ctx.session.login("PLOP", "fake_ident");
-        executor = this.getExecutor(ctx, "test.webda.io", "POST", url, {
-            type: "CRUD",
-            uuid: "PLOP",
-            displayName: "Coucou"
-        });
-        assert.notStrictEqual(executor, undefined);
-        await executor.execute(ctx);
-        ctx.body = undefined;
-        assert.strictEqual((await userStore.getAll()).length, 1);
-        await this.getExecutor(ctx, "test.webda.io", "GET", `${url}/PLOP`).execute(ctx);
-        assert.notStrictEqual(ctx.getResponseBody(), undefined);
-        assert.strictEqual(ctx.getResponseBody().indexOf("_lastUpdate") >= 0, true);
-        executor = this.getExecutor(ctx, "test.webda.io", "POST", url, {
-            type: "CRUD2",
-            uuid: "PLOP",
-            displayName: "Coucou 2"
-        });
-        await assert.rejects(executor.execute(ctx), (err) => err.getResponseCode() === 409);
-        // Verify the none overide of UUID
-        await this.execute(ctx, "test.webda.io", "PUT", `${url}/PLOP`, {
-            type: "CRUD2",
-            additional: "field",
-            uuid: "PLOP2",
-            user: "fake_user",
-            displayName: "Coucou 3",
-            roles: []
-        });
-        let user = await userStore.get("PLOP");
-        assert.strictEqual(user.getUuid(), "PLOP");
-        assert.strictEqual(user.type, "CRUD2");
-        assert.strictEqual(user.additional, "field");
-        assert.strictEqual(user.user, "fake_user");
-        // Add a role to the user
-        user.roles.push("plop");
-        await user.save();
-        user = await userStore.get("PLOP");
-        assert.deepStrictEqual(user.roles, ["plop"]);
-        ctx.resetResponse();
-        // Check PATH
-        await this.execute(ctx, "test.webda.io", "PATCH", `${url}/PLOP`, {
-            type: "CRUD3",
-            uuid: "PLOP2",
-            _testor: "_ should not be update by client"
-        });
-        user = await userStore.get("PLOP");
-        assert.strictEqual(user.uuid, "PLOP");
-        assert.strictEqual(user.type, "CRUD3");
-        assert.strictEqual(user.additional, "field");
-        assert.strictEqual(user._testor, undefined);
-        assert.deepStrictEqual(user.roles, ["plop"]);
-        executor = this.getExecutor(ctx, "test.webda.io", "PUT", `${url}/PLOP`, {
-            type: "CRUD3",
-            uuid: "PLOP2",
-            _testor: "_ should not be update by client",
-            displayName: "yep"
-        });
-        await executor.execute(ctx);
-        user = await userStore.get("PLOP");
-        assert.strictEqual(user.uuid, "PLOP");
-        assert.strictEqual(user.type, "CRUD3");
-        assert.strictEqual(user.additional, undefined);
-        assert.strictEqual(user._testor, undefined);
-        assert.deepStrictEqual(user.roles, undefined);
-        await this.getExecutor(ctx, "test.webda.io", "DELETE", `${url}/PLOP`).execute(ctx);
-        eventFired = 0;
-        executor = this.getExecutor(ctx, "test.webda.io", "GET", `${url}/PLOP`);
-        await assert.rejects(() => executor.execute(ctx), WebdaError.NotFound);
-        eventFired++;
-        executor = this.getExecutor(ctx, "test.webda.io", "DELETE", `${url}/PLOP`);
-        await assert.rejects(() => executor.execute(ctx), WebdaError.NotFound);
-        eventFired++;
-        executor = this.getExecutor(ctx, "test.webda.io", "PUT", `${url}/PLOP`);
-        await assert.rejects(() => executor.execute(ctx), WebdaError.NotFound);
-        eventFired++;
-        assert.strictEqual(eventFired, 3);
-    }
-    async modelActions(url = "/idents") {
-        let identStore = this.getIdentStore();
-        assert.notStrictEqual(identStore.getModel(), undefined);
-        let eventFired = 0;
-        let executor, ctx;
-        identStore.on("Store.Action", evt => {
-            eventFired++;
-        });
-        identStore.on("Store.Actioned", evt => {
-            eventFired++;
-        });
-        ctx = await this.newContext({
-            type: "CRUD",
-            uuid: "PLOP"
-        });
-        executor = this.getExecutor(ctx, "test.webda.io", "PUT", `${url}/coucou/plop`);
-        assert.notStrictEqual(executor, undefined);
-        await assert.rejects(executor.execute(ctx), WebdaError.NotFound);
-        await identStore.save({
-            uuid: "coucou"
-        });
-        await executor.execute(ctx);
-        // Our fake action is pushing true to _plop
-        assert.strictEqual(JSON.parse(ctx.getResponseBody())._plop, true);
-        assert.strictEqual(eventFired, 2);
-        assert.notStrictEqual(this.getExecutor(ctx, "test.webda.io", "POST", `${url}/coucou/yop`), null);
-        executor = this.getExecutor(ctx, "test.webda.io", "GET", `${url}/coucou/yop`);
-        assert.notStrictEqual(executor, null);
-        // Test with action returning the result instead of writing it
-        ctx.resetResponse();
-        await executor.execute(ctx);
-        assert.strictEqual(ctx.getResponseBody(), "youpi");
-    }
 }
 __decorate([
     test