@webda/core 2.0.0-beta.1 → 2.0.0

package/lib/stores/file.spec.js

@@ -1,31 +1,20 @@
-"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.FileStoreTest = void 0;
-const mocha_1 = require("@testdeck/mocha");
-const assert = require("assert");
-const fs_1 = require("fs");
-const fs_extra_1 = require("fs-extra");
-const sinon = require("sinon");
-const index_1 = require("../index");
-const httpcontext_1 = require("../utils/httpcontext");
-const store_1 = require("./store");
-const store_spec_1 = require("./store.spec");
-let FileStoreTest = class FileStoreTest extends store_spec_1.StoreTest {
+import { suite, test } from "@testdeck/mocha";
+import * as assert from "assert";
+import { existsSync } from "fs";
+import pkg from "fs-extra";
+import * as sinon from "sinon";
+import { FileUtils } from "../index.js";
+import { HttpContext } from "../utils/httpcontext.js";
+import { StoreNotFoundError, UpdateConditionFailError } from "./store.js";
+import { StoreTest } from "./store.spec.js";
+const { removeSync } = pkg;
+let FileStoreTest = class FileStoreTest extends StoreTest {
     getUserStore() {
         return this.getService("Users");
     }
@@ -33,319 +22,302 @@ let FileStoreTest = class FileStoreTest extends store_spec_1.StoreTest {
         // Need to slow down the _get
         let store = this.getService("Idents");
         let original = store._get.bind(store);
-        store._get = (...args) => __awaiter(this, void 0, void 0, function* () {
-            yield this.sleep(1);
+        store._get = async (...args) => {
+            await this.sleep(1);
             return original(...args);
-        });
+        };
         return store;
     }
-    getIndex() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getService("memoryaggregators").get("idents-index");
-        });
+    async getIndex() {
+        return this.getService("memoryaggregators").get("idents-index");
     }
-    recreateIndex() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let store = this.getService("memoryaggregators");
-            yield store.__clean();
-            yield this.getService("identsindexer").createAggregate();
-        });
+    async recreateIndex() {
+        let store = this.getService("memoryaggregators");
+        await store.__clean();
+        await this.getService("identsindexer").createAggregate();
     }
-    update(delay = 100) {
-        const _super = Object.create(null, {
-            update: { get: () => super.update }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            // Increase the delay for FileStore
-            return _super.update.call(this, delay);
-        });
+    async update(delay = 100) {
+        // Increase the delay for FileStore
+        return super.update(delay);
     }
-    cov() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let identStore = this.getService("idents");
-            let userStore = this.getService("users");
-            let user = yield userStore.save({});
-            let ident = yield identStore.save({
-                _user: user.getUuid()
-            });
-            let res = yield identStore.get(user.getUuid());
-            assert.strictEqual(res, undefined);
-            const stub = sinon.stub(identStore, "_get").callsFake(() => __awaiter(this, void 0, void 0, function* () { return user; }));
-            try {
-                res = yield identStore.get(user.getUuid());
-                assert.strictEqual(res, undefined);
-                yield assert.rejects(() => identStore.update({
-                    uuid: user.getUuid(),
-                    plop: true
-                }), store_1.StoreNotFoundError);
-                yield user.refresh();
-                assert.strictEqual(user.plop, undefined);
-                yield identStore.delete(user.getUuid());
-            }
-            finally {
-                stub.restore();
-            }
-            // Shoud return directly
-            yield identStore.incrementAttribute("test", "test", 0);
-            (0, fs_extra_1.removeSync)(identStore.getParameters().folder);
-            // Should not fail
-            yield identStore.__clean();
-            // Should recreate folder
-            identStore.computeParameters();
-            (0, fs_1.existsSync)(identStore.getParameters().folder);
-            ident = new identStore._model();
-            identStore.initModel(ident);
-            assert.notStrictEqual(ident.getUuid(), undefined);
-            // Test guard-rails (seems hardly reachable so might be useless)
-            assert.throws(() => identStore.checkCollectionUpdateCondition(ident, "plops", undefined, 1, null), store_1.UpdateConditionFailError);
-            // @ts-ignore
-            ident.plops = [];
-            assert.throws(() => identStore.checkCollectionUpdateCondition(ident, "plops", undefined, 1, null), store_1.UpdateConditionFailError);
-            identStore.checkCollectionUpdateCondition(ident, "plops", undefined, 0, null);
-            assert.rejects(() => identStore.simulateUpsertItemToCollection(undefined, "__proto__", undefined, new Date()), /Cannot update __proto__: js\/prototype-polluting-assignment/);
+    async cov() {
+        let identStore = this.getService("idents");
+        let userStore = this.getService("users");
+        let user = await userStore.save({});
+        let ident = await identStore.save({
+            _user: user.getUuid()
         });
+        let res = await identStore.get(user.getUuid());
+        assert.strictEqual(res, undefined);
+        const stub = sinon.stub(identStore, "_get").callsFake(async () => user);
+        try {
+            res = await identStore.get(user.getUuid());
+            assert.strictEqual(res, undefined);
+            await assert.rejects(() => identStore.update({
+                uuid: user.getUuid(),
+                plop: true
+            }), StoreNotFoundError);
+            await user.refresh();
+            assert.strictEqual(user.plop, undefined);
+            await identStore.delete(user.getUuid());
+        }
+        finally {
+            stub.restore();
+        }
+        // Shoud return directly
+        await identStore.incrementAttribute("test", "test", 0);
+        removeSync(identStore.getParameters().folder);
+        // Should not fail
+        await identStore.__clean();
+        // Should recreate folder
+        identStore.computeParameters();
+        existsSync(identStore.getParameters().folder);
+        ident = new identStore._model();
+        identStore.initModel(ident);
+        assert.notStrictEqual(ident.getUuid(), undefined);
+        // Test guard-rails (seems hardly reachable so might be useless)
+        assert.throws(() => identStore.checkCollectionUpdateCondition(ident, "plops", undefined, 1, null), UpdateConditionFailError);
+        // @ts-ignore
+        ident.plops = [];
+        assert.throws(() => identStore.checkCollectionUpdateCondition(ident, "plops", undefined, 1, null), UpdateConditionFailError);
+        identStore.checkCollectionUpdateCondition(ident, "plops", undefined, 0, null);
+        assert.rejects(() => identStore.simulateUpsertItemToCollection(undefined, "__proto__", undefined, new Date()), /Cannot update __proto__: js\/prototype-polluting-assignment/);
+        // Add a queryMethod test
+        userStore.getParameters().url = "/users";
+        userStore.getParameters().expose = {
+            queryMethod: "PUT",
+            restrict: {}
+        };
+        userStore.initRoutes();
+        userStore.getUrl("/url", ["GET"]);
     }
-    configuration() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let identStore = this.getService("idents");
-            assert.strictEqual(identStore.canTriggerConfiguration("plop", () => { }), false);
-            assert.strictEqual(yield identStore.getConfiguration("plop"), undefined);
-            yield identStore.save({ plop: 1, other: true, uuid: "plop" });
-            assert.deepStrictEqual(yield identStore.getConfiguration("plop"), {
-                other: true,
-                plop: 1
-            });
+    async configuration() {
+        let identStore = this.getService("idents");
+        assert.strictEqual(identStore.canTriggerConfiguration("plop", () => { }), false);
+        assert.strictEqual(await identStore.getConfiguration("plop"), undefined);
+        await identStore.save({ plop: 1, other: true, uuid: "plop" });
+        assert.deepStrictEqual(await identStore.getConfiguration("plop"), {
+            other: true,
+            plop: 1
         });
     }
-    modelActions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let identStore = this.getService("idents");
-            assert.notStrictEqual(identStore.getModel(), undefined);
-            let eventFired = 0;
-            let executor, ctx;
-            identStore.on("Store.Action", evt => {
-                eventFired++;
-            });
-            identStore.on("Store.Actioned", evt => {
-                eventFired++;
-            });
-            ctx = yield this.newContext({
-                type: "CRUD",
-                uuid: "PLOP"
-            });
-            executor = this.getExecutor(ctx, "test.webda.io", "PUT", "/idents/coucou/plop");
-            assert.notStrictEqual(executor, undefined);
-            yield assert.rejects(executor.execute(ctx), err => err == 404);
-            yield identStore.save({
-                uuid: "coucou"
-            });
-            yield 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", "/idents/coucou/yop"), null);
-            executor = this.getExecutor(ctx, "test.webda.io", "GET", "/idents/coucou/yop");
-            assert.notStrictEqual(executor, null);
-            // Test with action returning the result instead of writing it
-            ctx.resetResponse();
-            yield executor.execute(ctx);
-            assert.strictEqual(ctx.getResponseBody(), "youpi");
+    async modelActions() {
+        let identStore = this.getService("idents");
+        assert.notStrictEqual(identStore.getModel(), undefined);
+        let eventFired = 0;
+        let executor, ctx;
+        identStore.on("Store.Action", evt => {
+            eventFired++;
         });
-    }
-    cacheMishit() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let identStore = this.getService("idents");
-            let ident = yield identStore.save({ uuid: "test" });
-            yield identStore._cacheStore.__clean();
-            yield ident.update({ retest: true }, false, true);
+        identStore.on("Store.Actioned", evt => {
+            eventFired++;
         });
-    }
-    modelStaticActions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let identStore = this.getService("idents");
-            let ctx, executor;
-            let eventFired = 0;
-            identStore.on("Store.Action", evt => {
-                eventFired++;
-            });
-            ctx = yield this.newContext({
-                type: "CRUD",
-                uuid: "PLOP"
-            });
-            executor = this.getExecutor(ctx, "test.webda.io", "GET", "/idents/index");
-            assert.notStrictEqual(executor, undefined);
-            yield executor.execute(ctx);
-            // Our fake index action is just outputing 'indexer'
-            assert.strictEqual(ctx.getResponseBody(), "indexer");
-            assert.strictEqual(eventFired, 1);
-            ctx.resetResponse();
-            // Return some infos instead of using ctx
-            // @ts-ignore
-            identStore._model._index = () => __awaiter(this, void 0, void 0, function* () {
-                return "vouzouf";
-            });
-            yield executor.execute(ctx);
-            // Our fake index action is just outputing 'indexer'
-            assert.strictEqual(ctx.getResponseBody(), "vouzouf");
+        ctx = await this.newContext({
+            type: "CRUD",
+            uuid: "PLOP"
+        });
+        executor = this.getExecutor(ctx, "test.webda.io", "PUT", "/idents/coucou/plop");
+        assert.notStrictEqual(executor, undefined);
+        await assert.rejects(executor.execute(ctx), err => err == 404);
+        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", "/idents/coucou/yop"), null);
+        executor = this.getExecutor(ctx, "test.webda.io", "GET", "/idents/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");
     }
-    httpCRUD() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let eventFired;
-            let userStore = this.getUserStore();
-            let ctx, executor;
-            yield userStore.__clean();
-            ctx = yield this.newContext({});
-            ctx.session.login("fake_user", "fake_ident");
-            executor = this.getExecutor(ctx, "test.webda.io", "POST", "/users", {
-                type: "CRUD",
-                uuid: "PLOP"
-            });
-            assert.notStrictEqual(executor, undefined);
-            yield executor.execute(ctx);
-            ctx.body = undefined;
-            assert.strictEqual((yield userStore.getAll()).length, 1);
-            yield this.getExecutor(ctx, "test.webda.io", "GET", "/users/PLOP").execute(ctx);
-            assert.notStrictEqual(ctx.getResponseBody(), undefined);
-            assert.strictEqual(ctx.getResponseBody().indexOf("_lastUpdate") >= 0, true);
-            executor = this.getExecutor(ctx, "test.webda.io", "POST", "/users", {
-                type: "CRUD2",
-                uuid: "PLOP"
-            });
-            yield assert.rejects(executor.execute(ctx), err => err == 409);
-            // Verify the none overide of UUID
-            yield this.execute(ctx, "test.webda.io", "PUT", "/users/PLOP", {
-                type: "CRUD2",
-                additional: "field",
-                uuid: "PLOP2",
-                user: "fake_user"
-            });
-            let user = yield userStore.get("PLOP");
-            assert.strictEqual(user.uuid, "PLOP");
-            assert.strictEqual(user.type, "CRUD2");
-            assert.strictEqual(user.additional, "field");
-            assert.strictEqual(user.user, "fake_user");
-            assert.strictEqual(user._user, "fake_user");
-            // Add a role to the user
-            user.addRole("plop");
-            yield user.save();
-            user = yield userStore.get("PLOP");
-            assert.deepStrictEqual(user.getRoles(), ["plop"]);
-            ctx.resetResponse();
-            // Check PATH
-            yield this.execute(ctx, "test.webda.io", "PATCH", "/users/PLOP", {
-                type: "CRUD3",
-                uuid: "PLOP2",
-                _testor: "_ should not be update by client"
-            });
-            user = yield userStore.get("PLOP");
-            assert.strictEqual(user.uuid, "PLOP");
-            assert.strictEqual(user.type, "CRUD3");
-            assert.strictEqual(user.additional, "field");
-            assert.strictEqual(user._testor, undefined);
-            assert.strictEqual(user._user, "fake_user");
-            assert.deepStrictEqual(user.getRoles(), ["plop"]);
-            executor = this.getExecutor(ctx, "test.webda.io", "PUT", "/users/PLOP", {
-                type: "CRUD3",
-                uuid: "PLOP2",
-                _testor: "_ should not be update by client"
-            });
-            yield executor.execute(ctx);
-            user = yield 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.getRoles(), ["plop"]);
-            yield this.getExecutor(ctx, "test.webda.io", "DELETE", "/users/PLOP").execute(ctx);
-            eventFired = 0;
-            executor = this.getExecutor(ctx, "test.webda.io", "GET", "/users/PLOP");
-            yield assert.rejects(() => executor.execute(ctx), err => err == 404);
-            eventFired++;
-            executor = this.getExecutor(ctx, "test.webda.io", "DELETE", "/users/PLOP");
-            yield assert.rejects(() => executor.execute(ctx), err => err == 404);
-            eventFired++;
-            executor = this.getExecutor(ctx, "test.webda.io", "PUT", "/users/PLOP");
-            yield assert.rejects(() => executor.execute(ctx), err => err == 404);
+    async cacheMishit() {
+        let identStore = this.getService("idents");
+        let ident = await identStore.save({ uuid: "test" });
+        await identStore._cacheStore.__clean();
+        await ident.update({ retest: true });
+    }
+    async modelStaticActions() {
+        let identStore = this.getService("idents");
+        let ctx, executor;
+        let eventFired = 0;
+        identStore.on("Store.Action", evt => {
             eventFired++;
-            assert.strictEqual(eventFired, 3);
         });
+        ctx = await this.newContext({
+            type: "CRUD",
+            uuid: "PLOP"
+        });
+        executor = this.getExecutor(ctx, "test.webda.io", "GET", "/idents/index");
+        assert.notStrictEqual(executor, undefined);
+        await executor.execute(ctx);
+        // Our fake index action is just outputing 'indexer'
+        assert.strictEqual(ctx.getResponseBody(), "indexer");
+        assert.strictEqual(eventFired, 1);
+        ctx.resetResponse();
+        // Return some infos instead of using ctx
+        // @ts-ignore
+        identStore._model._index = async () => {
+            return "vouzouf";
+        };
+        await executor.execute(ctx);
+        // Our fake index action is just outputing 'indexer'
+        assert.strictEqual(ctx.getResponseBody(), "vouzouf");
     }
-    getURL() {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.strictEqual(this.webda.getService("users").getUrl(), "/users");
+    async httpCRUD() {
+        let eventFired;
+        let userStore = this.getUserStore();
+        let ctx, executor;
+        await userStore.__clean();
+        ctx = await this.newContext({});
+        ctx.session.login("fake_user", "fake_ident");
+        executor = this.getExecutor(ctx, "test.webda.io", "POST", "/users", {
+            type: "CRUD",
+            uuid: "PLOP"
+        });
+        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", "/users/PLOP").execute(ctx);
+        assert.notStrictEqual(ctx.getResponseBody(), undefined);
+        assert.strictEqual(ctx.getResponseBody().indexOf("_lastUpdate") >= 0, true);
+        executor = this.getExecutor(ctx, "test.webda.io", "POST", "/users", {
+            type: "CRUD2",
+            uuid: "PLOP"
+        });
+        await assert.rejects(executor.execute(ctx), err => err == 409);
+        // Verify the none overide of UUID
+        await this.execute(ctx, "test.webda.io", "PUT", "/users/PLOP", {
+            type: "CRUD2",
+            additional: "field",
+            uuid: "PLOP2",
+            user: "fake_user"
         });
+        let user = await userStore.get("PLOP");
+        assert.strictEqual(user.uuid, "PLOP");
+        assert.strictEqual(user.type, "CRUD2");
+        assert.strictEqual(user.additional, "field");
+        assert.strictEqual(user.user, "fake_user");
+        assert.strictEqual(user._user, "fake_user");
+        // Add a role to the user
+        user.addRole("plop");
+        await user.save();
+        user = await userStore.get("PLOP");
+        assert.deepStrictEqual(user.getRoles(), ["plop"]);
+        ctx.resetResponse();
+        // Check PATH
+        await this.execute(ctx, "test.webda.io", "PATCH", "/users/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.strictEqual(user._user, "fake_user");
+        assert.deepStrictEqual(user.getRoles(), ["plop"]);
+        executor = this.getExecutor(ctx, "test.webda.io", "PUT", "/users/PLOP", {
+            type: "CRUD3",
+            uuid: "PLOP2",
+            _testor: "_ should not be update by client"
+        });
+        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.getRoles(), ["plop"]);
+        await this.getExecutor(ctx, "test.webda.io", "DELETE", "/users/PLOP").execute(ctx);
+        eventFired = 0;
+        executor = this.getExecutor(ctx, "test.webda.io", "GET", "/users/PLOP");
+        await assert.rejects(() => executor.execute(ctx), err => err == 404);
+        eventFired++;
+        executor = this.getExecutor(ctx, "test.webda.io", "DELETE", "/users/PLOP");
+        await assert.rejects(() => executor.execute(ctx), err => err == 404);
+        eventFired++;
+        executor = this.getExecutor(ctx, "test.webda.io", "PUT", "/users/PLOP");
+        await assert.rejects(() => executor.execute(ctx), err => err == 404);
+        eventFired++;
+        assert.strictEqual(eventFired, 3);
+    }
+    async getURL() {
+        //assert.strictEqual((<Store<CoreModel>>this.webda.getService("users")).getUrl(), "/users");
     }
-    schemaCreate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let taskStore = this.webda.getService("Tasks");
-            let ctx = yield this.webda.newContext(new httpcontext_1.HttpContext("webda.io", "GET", "/"));
-            let executor = this.getExecutor(ctx, "test.webda.io", "POST", "/tasks", {
-                noname: "Task #1"
-            });
-            this.webda.getModules().schemas["webdatest/task"] = index_1.FileUtils.load("./test/schemas/task.json");
-            assert.notStrictEqual(executor, undefined);
-            ctx.getSession().login("fake_user", "fake_ident");
-            yield assert.rejects(executor.execute(ctx), err => err == 400, "Should reject for bad schema");
-            executor = this.getExecutor(ctx, "test.webda.io", "POST", "/tasks", {
-                name: "Task #1"
-            });
-            yield executor.execute(ctx);
-            let task = JSON.parse(ctx.getResponseBody());
-            // It is two because the Saved has been called two
-            assert.notStrictEqual(task.uuid, undefined);
-            assert.strictEqual(task._autoListener, 2);
-            task = yield taskStore.get(task.uuid);
-            assert.strictEqual(task._autoListener, 1);
-            executor = this.getExecutor(ctx, "test.webda.io", "PUT", `/tasks/${task.uuid}`, {
-                test: "plop"
-            });
-            yield assert.rejects(() => executor.execute(ctx), /400/);
-            executor = this.getExecutor(ctx, "test.webda.io", "PATCH", `/tasks/${task.uuid}`, {
-                name: 123
-            });
-            yield assert.rejects(() => executor.execute(ctx), /400/);
+    async schemaCreate() {
+        let taskStore = this.webda.getService("Tasks");
+        let ctx = await this.webda.newContext(new HttpContext("webda.io", "GET", "/"));
+        let executor = this.getExecutor(ctx, "test.webda.io", "POST", "/tasks", {
+            noname: "Task #1"
+        });
+        this.webda.getModules().schemas["webdatest/task"] = FileUtils.load("./test/schemas/task.json");
+        assert.notStrictEqual(executor, undefined);
+        ctx.getSession().login("fake_user", "fake_ident");
+        await assert.rejects(executor.execute(ctx), err => err == 400, "Should reject for bad schema");
+        executor = this.getExecutor(ctx, "test.webda.io", "POST", "/tasks", {
+            name: "Task #1"
+        });
+        await executor.execute(ctx);
+        let task = JSON.parse(ctx.getResponseBody());
+        // It is two because the Saved has been called two
+        assert.notStrictEqual(task.uuid, undefined);
+        assert.strictEqual(task._autoListener, 2);
+        task = await taskStore.get(task.uuid);
+        assert.strictEqual(task._autoListener, 1);
+        executor = this.getExecutor(ctx, "test.webda.io", "PUT", `/tasks/${task.uuid}`, {
+            test: "plop"
+        });
+        await assert.rejects(() => executor.execute(ctx), /400/);
+        executor = this.getExecutor(ctx, "test.webda.io", "PATCH", `/tasks/${task.uuid}`, {
+            name: 123
         });
+        await assert.rejects(() => executor.execute(ctx), /400/);
     }
     computeParams() {
         let usersStore = this.getUserStore();
-        (0, fs_extra_1.removeSync)(usersStore.getParameters().folder);
+        removeSync(usersStore.getParameters().folder);
         usersStore.computeParameters();
-        assert.ok((0, fs_1.existsSync)(usersStore.getParameters().folder));
+        assert.ok(existsSync(usersStore.getParameters().folder));
     }
 };
 __decorate([
-    mocha_1.test
+    test
 ], FileStoreTest.prototype, "update", null);
 __decorate([
-    mocha_1.test
+    test
 ], FileStoreTest.prototype, "cov", null);
 __decorate([
-    mocha_1.test
+    test
 ], FileStoreTest.prototype, "configuration", null);
 __decorate([
-    mocha_1.test
+    test
 ], FileStoreTest.prototype, "modelActions", null);
 __decorate([
-    mocha_1.test
+    test
 ], FileStoreTest.prototype, "cacheMishit", null);
 __decorate([
-    mocha_1.test
+    test
 ], FileStoreTest.prototype, "modelStaticActions", null);
 __decorate([
-    mocha_1.test
+    test
 ], FileStoreTest.prototype, "httpCRUD", null);
 __decorate([
-    mocha_1.test
+    test
 ], FileStoreTest.prototype, "getURL", null);
 __decorate([
-    (0, mocha_1.test)("JSON Schema - Create")
+    test("JSON Schema - Create")
 ], FileStoreTest.prototype, "schemaCreate", null);
 __decorate([
-    mocha_1.test
+    test
 ], FileStoreTest.prototype, "computeParams", null);
 FileStoreTest = __decorate([
-    mocha_1.suite
+    suite
 ], FileStoreTest);
-exports.FileStoreTest = FileStoreTest;
+export { FileStoreTest };
 //# sourceMappingURL=file.spec.js.map