@webda/core 2.0.0-beta.3 → 2.0.0

package/lib/stores/store.spec.js

@@ -1,88 +1,64 @@
-"use strict";
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     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;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StoreTest = exports.PermissionModel = void 0;
-const mocha_1 = require("@testdeck/mocha");
-const assert = require("assert");
-const sinon_1 = require("sinon");
-const uuid_1 = require("uuid");
-const Idents = require("../../test/models/ident");
-const index_1 = require("../index");
-const coremodel_1 = require("../models/coremodel");
-const test_1 = require("../test");
-const httpcontext_1 = require("../utils/httpcontext");
-const store_1 = require("./store");
+import { suite, 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 } from "../index.js";
+import { CoreModel } from "../models/coremodel.js";
+import { WebdaTest } from "../test.js";
+import { HttpContext } from "../utils/httpcontext.js";
+import { StoreNotFoundError, UpdateConditionFailError } from "./store.js";
 /**
  * Fake model that refuse the half of the items
  */
-class PermissionModel extends coremodel_1.CoreModel {
-    canAct(ctx, _action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.order % 200 < 120) {
-                throw 403;
-            }
-            return this;
-        });
+export class PermissionModel extends CoreModel {
+    async canAct(ctx, _action) {
+        if (this.order % 200 < 120) {
+            throw 403;
+        }
+        return this;
     }
 }
-exports.PermissionModel = PermissionModel;
 let StoreParametersTest = class StoreParametersTest {
     cov() {
-        let params = new index_1.StoreParameters({ expose: "/plop", lastUpdateField: "bz", creationDateField: "c" }, undefined);
+        let params = new StoreParameters({ expose: "/plop", lastUpdateField: "bz", creationDateField: "c" }, undefined);
         assert.deepStrictEqual(params.expose, { queryMethod: "GET", url: "/plop", restrict: {} });
-        assert.throws(() => new index_1.StoreParameters({ map: {} }, undefined), Error);
-        assert.throws(() => new index_1.StoreParameters({ index: [] }, undefined), Error);
+        assert.throws(() => new StoreParameters({ map: {} }, undefined), Error);
+        assert.throws(() => new StoreParameters({ index: [] }, undefined), Error);
     }
 };
 __decorate([
-    mocha_1.test
+    test
 ], StoreParametersTest.prototype, "cov", null);
 StoreParametersTest = __decorate([
-    mocha_1.suite
+    suite
 ], StoreParametersTest);
-class StoreTest extends test_1.WebdaTest {
+class StoreTest extends WebdaTest {
     /**
      * By default no testing index
      * @returns
      */
-    getIndex() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return undefined;
-        });
+    async getIndex() {
+        return undefined;
     }
     /**
      * Recreate index if needed
      */
-    recreateIndex() {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
-    before() {
-        const _super = Object.create(null, {
-            before: { get: () => super.before }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.before.call(this);
-            yield this.getUserStore().__clean();
-            yield this.getIdentStore().__clean();
-            yield this.recreateIndex();
-        });
+    async recreateIndex() { }
+    async before() {
+        await super.before();
+        await this.getUserStore().__clean();
+        await this.getIdentStore().__clean();
+        await this.recreateIndex();
     }
     getModelClass() {
-        return Idents;
+        return Ident;
     }
     /**
      * Get the base of documents to query
@@ -104,89 +80,85 @@ class StoreTest extends test_1.WebdaTest {
     /**
      * Fill the Store with data to be queried
      */
-    fillForQuery() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let userStore = this.getUserStore();
-            yield Promise.all(this.getQueryDocuments().map(d => userStore.save(d)));
-            return userStore;
-        });
+    async fillForQuery() {
+        let userStore = this.getUserStore();
+        await Promise.all(this.getQueryDocuments().map(d => userStore.save(d)));
+        return userStore;
     }
-    query() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let userStore = yield this.fillForQuery();
-            const queries = {
-                'state = "CA"': 250,
-                "team.id > 15": 200,
-                "team.id >= 15": 250,
-                "team.id <= 14": 750,
-                'state IN ["CA", "NY"]': 500,
-                'state IN ["CA", "NY", "NV"]': 500,
-                'state = "CA" AND team.id > 15': 50,
-                "team.id < 5 OR team.id > 15": 450,
-                "role < 5 AND team.id > 10 OR team.id > 15": 400,
-                "role < 5 AND (team.id > 10 OR team.id > 15)": 200,
-                'state LIKE "C_"': 250,
-                'state LIKE "C__"': 0,
-                'state LIKE "C%"': 250,
-                'state != "CA"': 750,
-                "": 1000
-            };
-            for (let i in queries) {
-                assert.strictEqual((yield userStore.query(i)).results.length, queries[i], `Query: ${i} should return ${queries[i]}`);
+    async query() {
+        let userStore = await this.fillForQuery();
+        const queries = {
+            'state = "CA"': 250,
+            "team.id > 15": 200,
+            "team.id >= 15": 250,
+            "team.id <= 14": 750,
+            'state IN ["CA", "NY"]': 500,
+            'state IN ["CA", "NY", "NV"]': 500,
+            'state = "CA" AND team.id > 15': 50,
+            "team.id < 5 OR team.id > 15": 450,
+            "role < 5 AND team.id > 10 OR team.id > 15": 400,
+            "role < 5 AND (team.id > 10 OR team.id > 15)": 200,
+            'state LIKE "C_"': 250,
+            'state LIKE "C__"': 0,
+            'state LIKE "C%"': 250,
+            'state != "CA"': 750,
+            "": 1000
+        };
+        for (let i in queries) {
+            assert.strictEqual((await userStore.query(i)).results.length, queries[i], `Query: ${i} should return ${queries[i]}`);
+        }
+        // Verify pagination system
+        let offset;
+        let res;
+        let i = 0;
+        do {
+            res = await userStore.query(`LIMIT 100 ${offset ? 'OFFSET "' + offset + '"' : ""}`);
+            offset = res.continuationToken;
+            if (i++ > 9) {
+                assert.strictEqual(res.results.length, 0, `Query: LIMIT 100 ${offset ? 'OFFSET "' + offset + '"' : ""} should return 0`);
+                assert.strictEqual(offset, undefined);
+            }
+            else {
+                assert.strictEqual(res.results.length, 100, `Query: LIMIT 100 ${offset ? 'OFFSET "' + offset + '"' : ""} should return 0`);
             }
-            // Verify pagination system
-            let offset;
-            let res;
-            let i = 0;
-            do {
-                res = yield userStore.query(`LIMIT 100 ${offset ? 'OFFSET "' + offset + '"' : ""}`);
-                offset = res.continuationToken;
-                if (i++ > 9) {
-                    assert.strictEqual(res.results.length, 0, `Query: LIMIT 100 ${offset ? 'OFFSET "' + offset + '"' : ""} should return 0`);
-                    assert.strictEqual(offset, undefined);
-                }
-                else {
-                    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);
-            let context = yield this.newContext();
-            // Verify pagination system
-            i = 0;
-            let total = 0;
-            let q;
-            // To ensure we trigger slowQuery
-            userStore.getParameters().slowQueryThreshold = 0;
-            do {
-                q = `LIMIT 100 ${offset ? 'OFFSET "' + offset + '"' : ""}`;
-                context.setHttpContext(new httpcontext_1.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
-                yield userStore.httpQuery(context);
-                res = JSON.parse(context.getResponseBody());
-                offset = res.continuationToken;
-                total += res.results.length;
-            } while (offset !== undefined);
-            assert.strictEqual(total, 400);
-            q = "BAD QUERY !";
-            context.setHttpContext(new httpcontext_1.HttpContext("test.webda.io", "PUT", userStore.getParameters().expose.url, "https", 443));
+        } while (offset !== undefined);
+        // Verify permission issue and half pagination
+        userStore.setModel(PermissionModel);
+        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 = `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
-            yield assert.rejects(() => userStore.httpQuery(context), /400/);
-            let mock = (0, sinon_1.stub)(userStore, "query").callsFake(() => {
-                throw new Error("Plop");
-            });
-            try {
-                // @ts-ignore
-                yield assert.rejects(() => userStore.httpQuery(context), /Plop/);
-            }
-            finally {
-                mock.restore();
-            }
-            return userStore;
+            await userStore.httpQuery(context);
+            res = JSON.parse(context.getResponseBody());
+            offset = res.continuationToken;
+            total += res.results.length;
+        } while (offset !== undefined);
+        assert.strictEqual(total, 400);
+        q = "BAD QUERY !";
+        context.setHttpContext(new HttpContext("test.webda.io", "PUT", userStore.getParameters().expose.url, "https", 443));
+        context.getHttpContext().setBody({ q });
+        // @ts-ignore
+        await assert.rejects(() => userStore.httpQuery(context), /400/);
+        let mock = stub(userStore, "query").callsFake(() => {
+            throw new Error("Plop");
         });
+        try {
+            // @ts-ignore
+            await assert.rejects(() => userStore.httpQuery(context), /Plop/);
+        }
+        finally {
+            mock.restore();
+        }
+        return userStore;
     }
     /**
      * Simplify model
@@ -200,600 +172,583 @@ class StoreTest extends test_1.WebdaTest {
             state: model.state
         };
     }
-    queryOrder() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let userStore = yield this.fillForQuery();
-            let model = yield userStore.save({
-                order: 996,
-                state: "CA",
-                team: { id: 16 }
-            });
-            try {
-                let res = yield userStore.query('state = "CA" ORDER BY order DESC LIMIT 10');
-                assert.deepStrictEqual(res.results.map((c) => ({ state: c.state, order: c.order, teamId: c.team.id })), [
-                    { state: "CA", order: 996, teamId: 16 },
-                    { state: "CA", order: 996, teamId: 16 },
-                    { state: "CA", order: 992, teamId: 12 },
-                    { state: "CA", order: 988, teamId: 8 },
-                    { state: "CA", order: 984, teamId: 4 },
-                    { state: "CA", order: 980, teamId: 0 },
-                    { state: "CA", order: 976, teamId: 16 },
-                    { state: "CA", order: 972, teamId: 12 },
-                    { state: "CA", order: 968, teamId: 8 },
-                    { state: "CA", order: 964, teamId: 4 }
-                ]);
-                res = yield userStore.query("order > 980 ORDER BY state ASC, order DESC LIMIT 10");
-                assert.deepStrictEqual(res.results.map((c) => ({ state: c.state, order: c.order, teamId: c.team.id })), [
-                    { state: "CA", order: 996, teamId: 16 },
-                    { state: "CA", order: 996, teamId: 16 },
-                    { state: "CA", order: 992, teamId: 12 },
-                    { state: "CA", order: 988, teamId: 8 },
-                    { state: "CA", order: 984, teamId: 4 },
-                    { state: "FL", order: 999, teamId: 19 },
-                    { state: "FL", order: 995, teamId: 15 },
-                    { state: "FL", order: 991, teamId: 11 },
-                    { state: "FL", order: 987, teamId: 7 },
-                    { state: "FL", order: 983, teamId: 3 }
-                ]);
-            }
-            finally {
-                yield model.delete();
-            }
+    async queryOrder() {
+        let userStore = await this.fillForQuery();
+        let model = await userStore.save({
+            order: 996,
+            state: "CA",
+            team: { id: 16 }
         });
+        try {
+            let res = await userStore.query('state = "CA" ORDER BY order DESC LIMIT 10');
+            assert.deepStrictEqual(res.results.map((c) => ({ state: c.state, order: c.order, teamId: c.team.id })), [
+                { state: "CA", order: 996, teamId: 16 },
+                { state: "CA", order: 996, teamId: 16 },
+                { state: "CA", order: 992, teamId: 12 },
+                { state: "CA", order: 988, teamId: 8 },
+                { state: "CA", order: 984, teamId: 4 },
+                { state: "CA", order: 980, teamId: 0 },
+                { state: "CA", order: 976, teamId: 16 },
+                { state: "CA", order: 972, teamId: 12 },
+                { state: "CA", order: 968, teamId: 8 },
+                { state: "CA", order: 964, teamId: 4 }
+            ]);
+            res = await userStore.query("order > 980 ORDER BY state ASC, order DESC LIMIT 10");
+            assert.deepStrictEqual(res.results.map((c) => ({ state: c.state, order: c.order, teamId: c.team.id })), [
+                { state: "CA", order: 996, teamId: 16 },
+                { state: "CA", order: 996, teamId: 16 },
+                { state: "CA", order: 992, teamId: 12 },
+                { state: "CA", order: 988, teamId: 8 },
+                { state: "CA", order: 984, teamId: 4 },
+                { state: "FL", order: 999, teamId: 19 },
+                { state: "FL", order: 995, teamId: 15 },
+                { state: "FL", order: 991, teamId: 11 },
+                { state: "FL", order: 987, teamId: 7 },
+                { state: "FL", order: 983, teamId: 3 }
+            ]);
+        }
+        finally {
+            await model.delete();
+        }
     }
-    mapper() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let identStore = this.getIdentStore();
-            let userStore = this.getUserStore();
-            let user1, ident1, ident2, user2;
-            var eventFired = 0;
-            var events = [
-                "Store.Save",
-                "Store.Saved",
-                "Store.Get",
-                "Store.Delete",
-                "Store.Deleted",
-                "Store.Update",
-                "Store.Updated",
-                "Store.Query",
-                "Store.Queried"
-            ];
-            for (let evt in events) {
-                identStore.on(events[evt], function (evt) {
-                    eventFired++;
-                });
-            }
-            assert.strictEqual(yield userStore.get(undefined), undefined);
-            user1 = (yield userStore.save({
-                name: "test"
-            })).uuid;
-            let user = yield userStore.get(user1);
-            // Save a user and add an ident
-            assert.notStrictEqual(user, undefined);
-            user1 = user.uuid;
-            ident1 = yield identStore.save({
-                type: "facebook",
-                _user: user.uuid
-            });
-            user = yield userStore.get(user1);
-            // Verify the ident is on the user
-            assert.notStrictEqual(user, undefined);
-            assert.notStrictEqual(user.idents, undefined);
-            assert.strictEqual(user.idents.length, 1);
-            // Retrieve index to verify it is in it too
-            let index = yield this.getIndex();
-            // Do not force index test for store
-            if (index) {
-                assert.notStrictEqual(index[ident1.uuid], undefined);
-                assert.strictEqual(index[ident1.uuid].type, "facebook");
-            }
-            let lastUpdate = user.idents[0]._lastUpdate;
-            yield this.sleep(10);
-            yield identStore.incrementAttribute(ident1.uuid, "counter", 1);
-            yield user.refresh();
-            assert.notStrictEqual(user.idents[0]._lastUpdate, 0);
-            this.assertLastUpdateNotEqual(user.idents[0]._lastUpdate, lastUpdate, "lastUpdate on a map after incrementAttribute");
-            lastUpdate = user.idents[0]._lastUpdate;
-            yield this.sleep(10);
-            yield identStore.upsertItemToCollection(ident1.uuid, "actions", {
-                uuid: "action_1",
-                type: "plop",
-                date: new Date()
-            });
-            yield user.refresh();
-            assert.notStrictEqual(user.idents[0]._lastUpdate.length, 0);
-            this.assertLastUpdateNotEqual(user.idents[0]._lastUpdate, lastUpdate, "lastUpdate on a map after upsertItemToCollection");
-            lastUpdate = user.idents[0]._lastUpdate;
-            yield this.sleep(10);
-            yield identStore.deleteItemFromCollection(ident1.uuid, "actions", 0, "plop", "type");
-            yield user.refresh();
-            assert.notStrictEqual(user.idents[0]._lastUpdate.length, 0);
-            this.assertLastUpdateNotEqual(user.idents[0]._lastUpdate, lastUpdate, "lastUpdate on a map after deleteItemFromCollection");
-            ident2 = yield identStore.save({
-                type: "google",
-                _user: user.uuid
+    async mapper() {
+        let identStore = this.getIdentStore();
+        let userStore = this.getUserStore();
+        let user1, ident1, ident2, user2;
+        var eventFired = 0;
+        var events = [
+            "Store.Save",
+            "Store.Saved",
+            "Store.Get",
+            "Store.Delete",
+            "Store.Deleted",
+            "Store.Update",
+            "Store.Updated",
+            "Store.Query",
+            "Store.Queried"
+        ];
+        for (let evt in events) {
+            identStore.on(events[evt], function (evt) {
+                eventFired++;
             });
-            // Add a second ident and check it is on the user aswell
-            user = yield userStore.get(user1);
-            assert.strictEqual(user.idents.length, 2);
-            // Check index
-            if (index) {
-                yield index.refresh();
-                assert.notStrictEqual(index[ident2.uuid], undefined);
-            }
-            ident2.type = "google2";
-            // Update ident2 to check mapper update
-            let res = yield identStore.patch({
-                uuid: ident2.uuid,
-                type: "google2"
-            });
-            assert.strictEqual(res.type, "google2");
-            assert.strictEqual(res._user, user1);
-            // Check index
-            if (index) {
-                yield index.refresh();
-                assert.strictEqual(index[ident2.uuid].type, "google2");
-            }
-            user = yield userStore.get(user1);
-            assert.strictEqual(user.idents.length, 2);
-            assert.strictEqual(user.idents[1].type, "google2");
-            assert.strictEqual(user.idents[1] instanceof this.getModelClass(), true);
-            yield identStore.delete(ident1.uuid);
-            user = yield userStore.get(user1);
-            assert.strictEqual(user.idents.length, 1);
-            assert.strictEqual(user.idents[0].type, "google2");
-            // Add a second user to play
-            user = yield userStore.save({
-                name: "test2"
-            });
-            user2 = user.uuid;
-            // Move ident2 from user1 to user2
-            yield identStore.patch({
-                _user: user.uuid,
-                uuid: ident2.uuid
-            });
-            // Check user1 has no more ident
-            user = yield userStore.get(user1);
-            assert.strictEqual(user.idents.length, 0);
-            // Check user2 has one ident
-            user = yield userStore.get(user2);
-            assert.strictEqual(user.idents.length, 1);
-            assert.strictEqual(user.idents[0].type, "google2");
-            // Verify you cannot update a collection from patch
-            yield userStore.patch({
-                idents: []
-            }, user2);
-            user = yield userStore.get(user2);
-            assert.strictEqual(user.idents.length, 1);
-            // Verify you cannot update a collection from update
-            yield userStore.update({
-                idents: []
-            }, user2);
-            user = yield userStore.get(user2);
-            assert.strictEqual(user.idents.length, 1);
-            assert.strictEqual(user.idents[0].type, "google2");
-            // Verify delete cascade with empty collection
-            yield userStore.delete(user1);
-            user = yield userStore.get(user2);
-            assert.strictEqual(user.idents.length, 1);
-            assert.strictEqual(user.idents[0].type, "google2");
-            // Verify delete cascade
-            yield userStore.delete(user2);
-            let ident = yield identStore.get(ident2.uuid);
-            assert.strictEqual(ident.__deleted, true);
-            // Check index
-            if (index) {
-                yield 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
-            yield identStore.forceDelete(ident2.uuid);
-            ident = yield identStore.get(ident2.uuid);
-            assert.strictEqual(ident, undefined);
-            assert.strictEqual(eventFired, 11);
+        }
+        assert.strictEqual(await userStore.get(undefined), undefined);
+        user1 = (await userStore.save({
+            name: "test"
+        })).uuid;
+        let user = await userStore.get(user1);
+        // Save a user and add an ident
+        assert.notStrictEqual(user, undefined);
+        user1 = user.uuid;
+        ident1 = await identStore.save({
+            type: "facebook",
+            _user: user.uuid
+        });
+        user = await userStore.get(user1);
+        // Verify the ident is on the user
+        assert.notStrictEqual(user, undefined);
+        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();
+        // Do not force index test for store
+        if (index) {
+            assert.notStrictEqual(index[ident1.uuid], undefined);
+            assert.strictEqual(index[ident1.uuid].type, "facebook");
+        }
+        let lastUpdate = user.idents[0]._lastUpdate;
+        await this.sleep(10);
+        await identStore.incrementAttribute(ident1.uuid, "counter", 1);
+        await user.refresh();
+        assert.notStrictEqual(user.idents[0]._lastUpdate, 0);
+        this.assertLastUpdateNotEqual(user.idents[0]._lastUpdate, lastUpdate, "lastUpdate on a map after incrementAttribute");
+        lastUpdate = user.idents[0]._lastUpdate;
+        await this.sleep(10);
+        await identStore.upsertItemToCollection(ident1.uuid, "actions", {
+            uuid: "action_1",
+            type: "plop",
+            date: new Date()
+        });
+        await user.refresh();
+        assert.notStrictEqual(user.idents[0]._lastUpdate.length, 0);
+        this.assertLastUpdateNotEqual(user.idents[0]._lastUpdate, lastUpdate, "lastUpdate on a map after upsertItemToCollection");
+        lastUpdate = user.idents[0]._lastUpdate;
+        await this.sleep(10);
+        await identStore.deleteItemFromCollection(ident1.uuid, "actions", 0, "plop", "type");
+        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({
+            type: "google",
+            _user: user.uuid
         });
+        // Add a second ident and check it is on the user aswell
+        user = await userStore.get(user1);
+        assert.strictEqual(user.idents.length, 2);
+        // Check index
+        if (index) {
+            await index.refresh();
+            assert.notStrictEqual(index[ident2.uuid], undefined);
+        }
+        ident2.type = "google2";
+        // Update ident2 to check mapper update
+        let res = await identStore.patch({
+            uuid: ident2.uuid,
+            type: "google2"
+        });
+        assert.strictEqual(res.type, "google2");
+        assert.strictEqual(res._user, user1);
+        // Check index
+        if (index) {
+            await index.refresh();
+            assert.strictEqual(index[ident2.uuid].type, "google2");
+        }
+        user = await userStore.get(user1);
+        assert.strictEqual(user.idents.length, 2);
+        assert.strictEqual(user.idents[1].type, "google2");
+        assert.strictEqual(user.idents[1] instanceof this.getModelClass(), true);
+        await identStore.delete(ident1.uuid);
+        user = await userStore.get(user1);
+        assert.strictEqual(user.idents.length, 1);
+        assert.strictEqual(user.idents[0].type, "google2");
+        // Add a second user to play
+        user = await userStore.save({
+            name: "test2"
+        });
+        user2 = user.uuid;
+        // Move ident2 from user1 to user2
+        await identStore.patch({
+            _user: user.uuid,
+            uuid: ident2.uuid
+        });
+        // Check user1 has no more ident
+        user = await userStore.get(user1);
+        assert.strictEqual(user.idents.length, 0);
+        // Check user2 has one ident
+        user = await userStore.get(user2);
+        assert.strictEqual(user.idents.length, 1);
+        assert.strictEqual(user.idents[0].type, "google2");
+        // Verify you cannot update a collection from patch
+        await userStore.patch({
+            idents: []
+        }, user2);
+        user = await userStore.get(user2);
+        assert.strictEqual(user.idents.length, 1);
+        // Verify you cannot update a collection from update
+        await userStore.update({
+            idents: []
+        }, user2);
+        user = await userStore.get(user2);
+        assert.strictEqual(user.idents.length, 1);
+        assert.strictEqual(user.idents[0].type, "google2");
+        // Verify delete cascade with empty collection
+        await userStore.delete(user1);
+        user = await userStore.get(user2);
+        assert.strictEqual(user.idents.length, 1);
+        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);
+        // 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);
     }
-    collection() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let identStore = this.getIdentStore();
-            var ident;
-            ident = yield identStore.save({
-                test: "plop"
-            });
-            yield identStore.upsertItemToCollection(ident.uuid, "actions", {
-                uuid: "action_1",
-                type: "plop",
-                date: new Date()
-            });
-            yield ident.refresh();
-            assert.notStrictEqual(ident.actions, undefined);
-            assert.strictEqual(ident.actions.length, 1);
-            yield identStore.upsertItemToCollection(ident.uuid, "actions", {
-                uuid: "action_2",
-                type: "plop",
-                date: new Date()
-            });
-            yield ident.refresh();
-            assert.notStrictEqual(ident.actions, undefined);
-            assert.strictEqual(ident.actions.length, 2);
-            yield identStore.upsertItemToCollection(ident.uuid, "actions", {
-                uuid: "action_1",
-                type: "plop2",
-                date: new Date()
-            }, 0);
-            yield ident.refresh();
-            this.log("DEBUG", "Action", ident.actions);
-            assert.notStrictEqual(ident.actions, undefined);
-            assert.strictEqual(ident.actions.length, 2);
-            assert.strictEqual(ident.actions[0].type, "plop2");
-            assert.strictEqual(ident.actions[0].uuid, "action_1");
-            yield assert.rejects(() => identStore.upsertItemToCollection(ident.uuid, "actions", {
-                uuid: "action_1",
-                type: "plop2",
-                date: new Date()
-            }, 0, "plop", "type"), err => true);
-            yield assert.rejects(() => identStore.deleteItemFromCollection(ident.uuid, "actions", 0, "action_2"), err => true);
-            yield ident.refresh();
-            assert.strictEqual(ident.actions.length, 2);
-            assert.strictEqual(ident.actions[0].type, "plop2");
-            let lastUpdate = ident._lastUpdate;
-            yield this.sleep(10);
-            yield identStore.upsertItemToCollection(ident.uuid, "actions", {
-                uuid: "action_1",
-                type: "plop",
-                date: new Date()
-            }, 0, "plop2", "type");
-            yield ident.refresh();
-            this.assertLastUpdateNotEqual(ident._lastUpdate, lastUpdate, "lastUpdate after upsertItemToColletion failed");
-            lastUpdate = ident._lastUpdate;
-            yield this.sleep(10);
-            yield identStore.deleteItemFromCollection(ident.uuid, "actions", 0, "plop", "type");
-            ident = yield identStore.get(ident.uuid);
-            this.assertLastUpdateNotEqual(ident._lastUpdate, lastUpdate, "lastUpdate after deleteItemToColletion failed");
-            assert.notStrictEqual(ident.actions, undefined);
-            assert.strictEqual(ident.actions.length, 1);
-            assert.strictEqual(ident.actions[0].type, "plop");
-            assert.strictEqual(ident.actions[0].uuid, "action_2");
+    async collection() {
+        let identStore = this.getIdentStore();
+        var ident;
+        ident = await identStore.save({
+            test: "plop"
+        });
+        await identStore.upsertItemToCollection(ident.uuid, "actions", {
+            uuid: "action_1",
+            type: "plop",
+            date: new Date()
         });
+        await ident.refresh();
+        assert.notStrictEqual(ident.actions, undefined);
+        assert.strictEqual(ident.actions.length, 1);
+        await identStore.upsertItemToCollection(ident.uuid, "actions", {
+            uuid: "action_2",
+            type: "plop",
+            date: new Date()
+        });
+        await ident.refresh();
+        assert.notStrictEqual(ident.actions, undefined);
+        assert.strictEqual(ident.actions.length, 2);
+        await identStore.upsertItemToCollection(ident.uuid, "actions", {
+            uuid: "action_1",
+            type: "plop2",
+            date: new Date()
+        }, 0);
+        await ident.refresh();
+        this.log("DEBUG", "Action", ident.actions);
+        assert.notStrictEqual(ident.actions, undefined);
+        assert.strictEqual(ident.actions.length, 2);
+        assert.strictEqual(ident.actions[0].type, "plop2");
+        assert.strictEqual(ident.actions[0].uuid, "action_1");
+        await assert.rejects(() => identStore.upsertItemToCollection(ident.uuid, "actions", {
+            uuid: "action_1",
+            type: "plop2",
+            date: new Date()
+        }, 0, "plop", "type"), err => true);
+        await assert.rejects(() => identStore.deleteItemFromCollection(ident.uuid, "actions", 0, "action_2"), err => true);
+        await ident.refresh();
+        assert.strictEqual(ident.actions.length, 2);
+        assert.strictEqual(ident.actions[0].type, "plop2");
+        let lastUpdate = ident._lastUpdate;
+        await this.sleep(10);
+        await identStore.upsertItemToCollection(ident.uuid, "actions", {
+            uuid: "action_1",
+            type: "plop",
+            date: new Date()
+        }, 0, "plop2", "type");
+        await ident.refresh();
+        this.assertLastUpdateNotEqual(ident._lastUpdate, lastUpdate, "lastUpdate after upsertItemToColletion failed");
+        lastUpdate = ident._lastUpdate;
+        await this.sleep(10);
+        await identStore.deleteItemFromCollection(ident.uuid, "actions", 0, "plop", "type");
+        ident = await identStore.get(ident.uuid);
+        this.assertLastUpdateNotEqual(ident._lastUpdate, lastUpdate, "lastUpdate after deleteItemToColletion failed");
+        assert.notStrictEqual(ident.actions, undefined);
+        assert.strictEqual(ident.actions.length, 1);
+        assert.strictEqual(ident.actions[0].type, "plop");
+        assert.strictEqual(ident.actions[0].uuid, "action_2");
     }
-    getAll() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let userStore = this.getUserStore();
-            var user1;
-            var user3;
-            user1 = yield userStore.save({
-                name: "test1"
-            });
-            yield userStore.save({
-                name: "test2"
-            });
-            user3 = yield userStore.save({
-                name: "test3"
-            });
-            let users = yield userStore.getAll();
-            assert.strictEqual(users.length, 3);
-            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 = yield userStore.getAll([user1.uuid, user3.uuid, (0, uuid_1.v4)()]);
-            assert.strictEqual(users.length, 2);
-            assert.strictEqual(users[0] instanceof userStore._model, true);
-            assert.strictEqual(users[1] instanceof userStore._model, true);
+    async getAll() {
+        let userStore = this.getUserStore();
+        var user1;
+        var user3;
+        user1 = await userStore.save({
+            name: "test1"
+        });
+        await userStore.save({
+            name: "test2"
+        });
+        user3 = await userStore.save({
+            name: "test3"
         });
+        let users = await userStore.getAll();
+        assert.strictEqual(users.length, 3);
+        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()]);
+        assert.strictEqual(users.length, 2);
+        assert.strictEqual(users[0] instanceof userStore._model, true);
+        assert.strictEqual(users[1] instanceof userStore._model, true);
     }
-    crud() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let identStore = this.getIdentStore();
-            var eventFired = 0;
-            var events = [
-                "Store.Save",
-                "Store.Saved",
-                "Store.Get",
-                "Store.Delete",
-                "Store.Deleted",
-                "Store.Update",
-                "Store.Updated",
-                "Store.PatchUpdate",
-                "Store.PatchUpdated",
-                "Store.PartialUpdated",
-                "Store.Query",
-                "Store.Queried"
-            ];
-            for (let evt in events) {
-                identStore.on(events[evt], function (e) {
-                    eventFired++;
-                });
-            }
-            this.log("DEBUG", "Save ident");
-            // Check CREATE - READ
-            let ident1 = yield identStore.save({
-                test: "plop",
-                cool: "",
-                lastUsed: new Date(),
-                arr: [],
-                details: {
-                    plop: "plop1",
-                    clean: undefined,
-                    yop: "pouf"
-                }
+    async crud() {
+        let identStore = this.getIdentStore();
+        var eventFired = 0;
+        var events = [
+            "Store.Save",
+            "Store.Saved",
+            "Store.Get",
+            "Store.Delete",
+            "Store.Deleted",
+            "Store.Update",
+            "Store.Updated",
+            "Store.PatchUpdate",
+            "Store.PatchUpdated",
+            "Store.PartialUpdated",
+            "Store.Query",
+            "Store.Queried"
+        ];
+        for (let evt in events) {
+            identStore.on(events[evt], function (e) {
+                eventFired++;
             });
-            assert.strictEqual(eventFired, 2);
-            assert.notStrictEqual(ident1, undefined);
-            eventFired = 0;
-            this.log("DEBUG", "Get ident");
-            let getter = yield identStore.get(ident1.uuid);
-            assert.strictEqual(eventFired, 1);
-            eventFired = 0;
-            assert.notStrictEqual(getter, undefined);
-            assert.notStrictEqual(getter.lastUsed, undefined);
-            assert.notStrictEqual(getter._lastUpdate, undefined);
-            assert.strictEqual(getter.uuid, ident1.uuid);
-            assert.strictEqual(getter.test, ident1.test);
-            // Check UPDATE
-            getter.test = "plop2";
-            getter.details.plop = "plop2";
-            getter.details.blank = "";
-            getter.details.bouzouf = undefined;
-            getter.empty = [];
-            let object;
-            this.log("DEBUG", "Update ident");
-            yield identStore.update(getter);
-            assert.strictEqual(eventFired, 2);
-            eventFired = 0;
-            getter = {};
-            getter.uuid = ident1.uuid;
-            getter.bouzouf = "test";
-            this.log("DEBUG", "Patch ident");
-            yield identStore.patch(getter);
-            assert.strictEqual(eventFired, 2);
-            eventFired = 0;
-            this.log("DEBUG", "Get ident to check update");
-            object = yield identStore.get(ident1.uuid);
-            this.log("DEBUG", "Retrieved object", object);
-            assert.strictEqual(object.test, "plop2");
-            assert.strictEqual(object.details.plop, "plop2");
-            getter = yield identStore.get(object.uuid);
-            assert.strictEqual(eventFired, 2);
-            assert.strictEqual(getter.test, "plop2");
-            yield this.sleep(10);
-            this.log("DEBUG", "Increment attribute");
-            yield identStore.incrementAttribute(ident1.uuid, "counter", 1);
-            let ident = yield identStore.get(ident1.uuid);
-            // Verify lastUpdate is updated too
-            this.assertLastUpdateNotEqual(ident._lastUpdate, ident1._lastUpdate, "lastUpdate after incrementAttribute failed");
-            assert.strictEqual(ident.counter, 1);
-            yield identStore.incrementAttribute(ident1.uuid, "counter", 3);
-            ident1 = yield identStore.get(ident1.uuid);
-            assert.strictEqual(ident1.counter, 4);
-            yield identStore.incrementAttribute(ident1.uuid, "counter", -6);
-            let res = yield identStore.exists(ident1.uuid);
-            assert.strictEqual(res, true);
-            ident1 = yield identStore.get(ident1.uuid);
-            assert.strictEqual(ident1.counter, -2);
-            // Check DELETE
-            eventFired = 0;
-            yield identStore.forceDelete(ident1.uuid);
-            assert.strictEqual(eventFired, 2);
-            eventFired = 0;
-            ident = yield identStore.get(ident1.uuid);
-            assert.strictEqual(ident, undefined);
-            res = yield identStore.exists(ident1.uuid);
-            assert.strictEqual(res, false);
+        }
+        this.log("DEBUG", "Save ident");
+        // Check CREATE - READ
+        let ident1 = await identStore.save({
+            test: "plop",
+            cool: "",
+            lastUsed: new Date(),
+            arr: [],
+            details: {
+                plop: "plop1",
+                clean: undefined,
+                yop: "pouf"
+            }
         });
+        assert.strictEqual(eventFired, 2);
+        assert.notStrictEqual(ident1, undefined);
+        eventFired = 0;
+        this.log("DEBUG", "Get ident");
+        let getter = await identStore.get(ident1.uuid);
+        assert.strictEqual(eventFired, 1);
+        eventFired = 0;
+        assert.notStrictEqual(getter, undefined);
+        assert.notStrictEqual(getter.lastUsed, undefined);
+        assert.notStrictEqual(getter._lastUpdate, undefined);
+        assert.strictEqual(getter.uuid, ident1.uuid);
+        assert.strictEqual(getter.test, ident1.test);
+        // Check UPDATE
+        getter.test = "plop2";
+        getter.details.plop = "plop2";
+        getter.details.blank = "";
+        getter.details.bouzouf = undefined;
+        getter.empty = [];
+        let object;
+        this.log("DEBUG", "Update ident");
+        await identStore.update(getter);
+        assert.strictEqual(eventFired, 2);
+        eventFired = 0;
+        getter = {};
+        getter.uuid = ident1.uuid;
+        getter.bouzouf = "test";
+        this.log("DEBUG", "Patch ident");
+        await identStore.patch(getter);
+        assert.strictEqual(eventFired, 2);
+        eventFired = 0;
+        this.log("DEBUG", "Get ident to check update");
+        object = await identStore.get(ident1.uuid);
+        this.log("DEBUG", "Retrieved object", object);
+        assert.strictEqual(object.test, "plop2");
+        assert.strictEqual(object.details.plop, "plop2");
+        getter = await identStore.get(object.uuid);
+        assert.strictEqual(eventFired, 2);
+        assert.strictEqual(getter.test, "plop2");
+        await this.sleep(10);
+        this.log("DEBUG", "Increment attribute");
+        await identStore.incrementAttribute(ident1.uuid, "counter", 1);
+        let ident = await identStore.get(ident1.uuid);
+        // Verify lastUpdate is updated too
+        this.assertLastUpdateNotEqual(ident._lastUpdate, ident1._lastUpdate, "lastUpdate after incrementAttribute failed");
+        assert.strictEqual(ident.counter, 1);
+        await identStore.incrementAttribute(ident1.uuid, "counter", 3);
+        ident1 = await identStore.get(ident1.uuid);
+        assert.strictEqual(ident1.counter, 4);
+        await identStore.incrementAttribute(ident1.uuid, "counter", -6);
+        let res = await identStore.exists(ident1.uuid);
+        assert.strictEqual(res, true);
+        ident1 = await identStore.get(ident1.uuid);
+        assert.strictEqual(ident1.counter, -2);
+        // Check DELETE
+        eventFired = 0;
+        await identStore.forceDelete(ident1.uuid);
+        assert.strictEqual(eventFired, 2);
+        eventFired = 0;
+        ident = await identStore.get(ident1.uuid);
+        assert.strictEqual(ident, undefined);
+        res = await identStore.exists(ident1.uuid);
+        assert.strictEqual(res, false);
     }
     assertLastUpdateNotEqual(d1, d2, msg) {
         assert.notStrictEqual(d1, d2, msg);
     }
-    exists() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let store = this.getIdentStore();
-            let model = yield store.save({});
-            assert.ok(yield store.exists(model.getUuid()));
-            assert.ok(!(yield store.exists((0, uuid_1.v4)())));
-        });
+    async exists() {
+        let store = this.getIdentStore();
+        let model = await store.save({});
+        assert.ok(await store.exists(model.getUuid()));
+        assert.ok(!(await store.exists(uuidv4())));
     }
-    incrementAttribute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let store = this.getIdentStore();
-            let model = yield store.save({ counter: 0 });
-            yield store.incrementAttribute(model.getUuid(), "counter", 3);
-            yield store.incrementAttribute(model.getUuid(), "counter2", 2);
-            yield model.refresh();
-            assert.strictEqual(model.counter, 3);
-            assert.strictEqual(model.counter2, 2);
-            yield assert.rejects(() => store.incrementAttribute((0, uuid_1.v4)(), "counter", 1), store_1.StoreNotFoundError);
-        });
+    async incrementAttribute() {
+        let store = this.getIdentStore();
+        let 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);
     }
-    removeAttribute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let store = this.getIdentStore();
-            let model = yield store.save({ counter: 0, counter2: 12, counter3: 13 });
-            yield store.removeAttribute(model.getUuid(), "counter");
-            yield model.refresh();
-            assert.strictEqual(model.counter, undefined);
-            yield assert.rejects(() => store.removeAttribute((0, uuid_1.v4)(), "counter"), store_1.StoreNotFoundError);
-            yield assert.rejects(() => store.removeAttribute(model.getUuid(), "counter2", 10, "counter3"), store_1.UpdateConditionFailError);
-            yield model.refresh();
-            assert.strictEqual(model.counter2, 12);
-        });
+    async removeAttribute() {
+        let store = this.getIdentStore();
+        let 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(model.getUuid(), "counter2", 10, "counter3"), UpdateConditionFailError);
+        await model.refresh();
+        assert.strictEqual(model.counter2, 12);
     }
-    setAttribute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let store = this.getIdentStore();
-            let model = yield store.save({ counter: 0 });
-            yield store.setAttribute(model.getUuid(), "counter", 3);
-            yield store.setAttribute(model.getUuid(), "status", "TESTED");
-            yield model.refresh();
-            assert.strictEqual(model.counter, 3);
-            assert.strictEqual(model.status, "TESTED");
-            yield assert.rejects(() => store.setAttribute((0, uuid_1.v4)(), "counter", 4), store_1.StoreNotFoundError);
-            store.on("Store.PatchUpdate", () => __awaiter(this, void 0, void 0, function* () {
-                model._lastUpdate = new Date();
-                yield store._update(model, model.getUuid());
-                yield this.sleep(1);
-            }));
-            yield assert.rejects(() => store.setAttribute(model.getUuid(), "counter", 4), store_1.UpdateConditionFailError);
-            store.removeAllListeners("Store.PatchUpdate");
-            store.on("Store.PatchUpdate", () => __awaiter(this, void 0, void 0, function* () {
-                yield store._delete(model.getUuid());
-                yield this.sleep(1);
-            }));
-            yield assert.rejects(() => store.setAttribute(model.getUuid(), "counter", 4), err => err instanceof store_1.StoreNotFoundError || err instanceof store_1.UpdateConditionFailError);
-            yield assert.rejects(() => store.setAttribute((0, uuid_1.v4)(), "counter", 4), err => err instanceof store_1.StoreNotFoundError || err instanceof store_1.UpdateConditionFailError);
+    async setAttribute() {
+        let store = this.getIdentStore();
+        let 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);
+        store.on("Store.PatchUpdate", async () => {
+            model._lastUpdate = new Date();
+            await store._update(model, model.getUuid());
+            await this.sleep(1);
         });
-    }
-    deleteAsync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let store = this.getIdentStore();
-            let model = yield store.save({ counter: 1 });
-            // Delete with condition
-            yield assert.rejects(() => store.delete(model.getUuid(), 4, "counter"), store_1.UpdateConditionFailError);
-            yield store.delete(model.getUuid(), 1, "counter");
-            // Test without condition
-            model = yield store.save({ counter: 2 });
-            yield store.delete(model);
-            // Deleting a non-existing object should be ignored
-            yield store.forceDelete((0, uuid_1.v4)());
+        await assert.rejects(() => store.setAttribute(model.getUuid(), "counter", 4), UpdateConditionFailError);
+        store.removeAllListeners("Store.PatchUpdate");
+        store.on("Store.PatchUpdate", async () => {
+            await store._delete(model.getUuid());
+            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);
     }
-    delete() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // UserStore is not supposed to be async
-            let store = this.getUserStore();
-            let model = yield store.save({ counter: 1 });
-            // Delete with condition
-            yield assert.rejects(() => store.delete(model.getUuid(), 4, "counter"), store_1.UpdateConditionFailError);
-            yield store.delete(model.getUuid(), 1, "counter");
-            // Test without condition
-            model = yield store.save({ counter: 2 });
-            yield store.delete(model);
-            // Deleting a non-existing object should be ignored
-            yield store.forceDelete((0, uuid_1.v4)());
-        });
+    async deleteAsync() {
+        let store = this.getIdentStore();
+        let model = await store.save({ counter: 1 });
+        // Delete with condition
+        await assert.rejects(() => store.delete(model.getUuid(), 4, "counter"), UpdateConditionFailError);
+        await store.delete(model.getUuid(), 1, "counter");
+        // Test without condition
+        model = await store.save({ counter: 2 });
+        await store.delete(model);
+        // Deleting a non-existing object should be ignored
+        await store.forceDelete(uuidv4());
     }
-    deleteConcurrent() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let store = this.getUserStore();
-            let model = yield store.save({ counter: 1 });
-            store.addListener("Store.Delete", () => __awaiter(this, void 0, void 0, function* () {
-                yield store.incrementAttribute(model.getUuid(), "counter", 1);
-            }));
-            yield assert.rejects(() => store.delete(model.getUuid(), 1, "counter"), store_1.UpdateConditionFailError);
-            store.removeAllListeners();
-            yield store.delete(model.getUuid(), 2, "counter");
-        });
+    async delete() {
+        // UserStore is not supposed to be async
+        let store = this.getUserStore();
+        let model = await store.save({ counter: 1 });
+        // Delete with condition
+        await assert.rejects(() => store.delete(model.getUuid(), 4, "counter"), UpdateConditionFailError);
+        await store.delete(model.getUuid(), 1, "counter");
+        // Test without condition
+        model = await store.save({ counter: 2 });
+        await store.delete(model);
+        // Deleting a non-existing object should be ignored
+        await store.forceDelete(uuidv4());
     }
-    conditionUpdate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let store = this.getIdentStore();
-            let model = yield store.save({ counter: 1 });
-            assert.ok(yield store.conditionalPatch(model.getUuid(), {
-                plop: 12,
-                counter: 2
-            }, "counter", 1));
-            assert.strictEqual((yield store.get(model.getUuid())).plop, 12);
-            assert.ok(!(yield store.conditionalPatch(model.getUuid(), {
-                plop: 13
-            }, "counter", 1)));
-            assert.strictEqual((yield store.get(model.getUuid())).plop, 12);
-            (0, sinon_1.stub)(store, "_patch").callsFake(() => {
-                throw new Error("Fake Error");
-            });
-            yield assert.rejects(() => store.conditionalPatch(model.getUuid(), {
-                plop: 12,
-                counter: 2
-            }, "counter", 1), /Fake Error/);
+    async deleteConcurrent() {
+        let store = this.getUserStore();
+        let model = await store.save({ counter: 1 });
+        store.addListener("Store.Delete", async () => {
+            await store.incrementAttribute(model.getUuid(), "counter", 1);
         });
+        await assert.rejects(() => store.delete(model.getUuid(), 1, "counter"), UpdateConditionFailError);
+        store.removeAllListeners();
+        await store.delete(model.getUuid(), 2, "counter");
     }
-    update(delay = 1) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let store = this.getIdentStore();
-            let model = yield store.save({ counter: 1 });
-            let model2 = yield store.get(model.getUuid());
-            store.on("Store.Update", () => __awaiter(this, void 0, void 0, function* () {
-                model2._lastUpdate = new Date();
-                yield store._update(model2, model2.getUuid());
-                yield this.sleep(delay);
-            }));
-            model.plop = "yop";
-            // Delete with condition
-            yield assert.rejects(() => store.update(model), store_1.UpdateConditionFailError);
-            store.removeAllListeners("Store.Update");
-            store.on("Store.Update", () => __awaiter(this, void 0, void 0, function* () {
-                yield store._delete(model.getUuid());
-                yield this.sleep(delay);
-            }));
-            yield assert.rejects(() => store.update(model), err => err instanceof store_1.StoreNotFoundError || err instanceof store_1.UpdateConditionFailError);
-            yield assert.rejects(() => store.update({ uuid: (0, uuid_1.v4)(), test: true }), err => err instanceof store_1.StoreNotFoundError || err instanceof store_1.UpdateConditionFailError);
+    async conditionUpdate() {
+        let store = this.getIdentStore();
+        let model = await store.save({ counter: 1 });
+        assert.ok(await store.conditionalPatch(model.getUuid(), {
+            plop: 12,
+            counter: 2
+        }, "counter", 1));
+        assert.strictEqual((await store.get(model.getUuid())).plop, 12);
+        assert.ok(!(await store.conditionalPatch(model.getUuid(), {
+            plop: 13
+        }, "counter", 1)));
+        assert.strictEqual((await store.get(model.getUuid())).plop, 12);
+        stub(store, "_patch").callsFake(() => {
+            throw new Error("Fake Error");
         });
+        await assert.rejects(() => store.conditionalPatch(model.getUuid(), {
+            plop: 12,
+            counter: 2
+        }, "counter", 1), /Fake Error/);
     }
-    upsertItem() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let store = this.getIdentStore();
-            this.log("DEBUG", "Save empty logs array");
-            let model = yield store.save({ logs: [] });
-            let ps = [];
-            this.log("DEBUG", "Upsert 10 lines");
-            for (let i = 0; i < 10; i++) {
-                ps.push(store.upsertItemToCollection(model.getUuid(), "logs", `line${i}`));
-            }
-            yield Promise.all(ps);
-            yield model.refresh();
-            assert.strictEqual(model.logs.length, 10);
-            // Depending on the implementation it can be swallowed by the backend
-            this.log("DEBUG", "Upsert on unknown doc");
-            yield assert.rejects(() => store.upsertItemToCollection((0, uuid_1.v4)(), "logs", `line`), err => err instanceof store_1.StoreNotFoundError || err instanceof store_1.UpdateConditionFailError);
-            this.log("DEBUG", "Delete on unknown doc");
-            yield assert.rejects(() => store.deleteItemFromCollection((0, uuid_1.v4)(), "logs", 0, undefined, undefined), err => err instanceof store_1.StoreNotFoundError || err instanceof store_1.UpdateConditionFailError);
+    async update(delay = 1) {
+        let store = this.getIdentStore();
+        let model = await store.save({ counter: 1 });
+        let model2 = await store.get(model.getUuid());
+        store.on("Store.Update", async () => {
+            model2._lastUpdate = new Date();
+            await store._update(model2, model2.getUuid());
+            await this.sleep(delay);
         });
+        model.plop = "yop";
+        // Delete with condition
+        await assert.rejects(() => store.update(model), UpdateConditionFailError);
+        store.removeAllListeners("Store.Update");
+        store.on("Store.Update", async () => {
+            await store._delete(model.getUuid());
+            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);
+    }
+    async upsertItem() {
+        let store = this.getIdentStore();
+        this.log("DEBUG", "Save empty logs array");
+        let model = await store.save({ logs: [] });
+        let ps = [];
+        this.log("DEBUG", "Upsert 10 lines");
+        for (let i = 0; i < 10; i++) {
+            ps.push(store.upsertItemToCollection(model.getUuid(), "logs", `line${i}`));
+        }
+        await Promise.all(ps);
+        await model.refresh();
+        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);
+        this.log("DEBUG", "Delete on unknown doc");
+        await assert.rejects(() => store.deleteItemFromCollection(uuidv4(), "logs", 0, undefined, undefined), err => err instanceof StoreNotFoundError || err instanceof UpdateConditionFailError);
+    }
+    async put() {
+        const store = this.getIdentStore();
+        const uuid = store.getWebda().getUuid();
+        if (await store.exists(uuid)) {
+            await store.delete(uuid);
+        }
+        await store.put(uuid, { test: true });
+        // Verify put acts like a upsert
+        await store.put(uuid, { test: false });
     }
 }
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "query", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "queryOrder", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "mapper", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "collection", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "getAll", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "crud", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "exists", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "incrementAttribute", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "removeAttribute", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "setAttribute", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "deleteAsync", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "delete", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "conditionUpdate", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "update", null);
 __decorate([
-    mocha_1.test
+    test
 ], StoreTest.prototype, "upsertItem", null);
-exports.StoreTest = StoreTest;
+__decorate([
+    test
+], StoreTest.prototype, "put", null);
+export { StoreTest };
 //# sourceMappingURL=store.spec.js.map