fix: unit test

Author: loopingz

packages/async/src/services/asyncjobservice.spec.ts

@@ -291,6 +291,7 @@ class AsyncJobServiceTest extends WebdaTest {
     service.getParameters().fallbackOnFirst = true;
     await handler();
     assert.strictEqual((await AsyncAction.ref("plop").get()).status, "STARTING");
+    await assert.rejects(() => service["handleEvent"](<any>{ uuid: "plop2", type: "Async" }), /Item not found/);
   }
 
   @test

packages/async/src/services/asyncjobservice.ts

@@ -372,10 +372,6 @@ export default class AsyncJobService<T extends AsyncJobServiceParameters = Async
     this.log("INFO", `Starting action ${event.uuid}`);
     await this.model.ref(event.uuid).patch({ uuid: event.uuid, status: "STARTING" });
     const action = await this.model.ref(event.uuid).get();
-    if (!action) {
-      this.log("ERROR", `Action NOT found`, { event });
-      return Promise.resolve();
-    }
     const job = await selectedRunner.launchAction(action, this.getJobInfo(action));
     await action.patch({ job }, null);
     return job.promise || Promise.resolve();
@@ -683,9 +679,9 @@ export default class AsyncJobService<T extends AsyncJobServiceParameters = Async
       time -= time % this.parameters.schedulerResolution;
       // Queue all actions
       await Promise.all(
-        (await this.model.query(`status = 'SCHEDULED' AND scheduled < ${time + 1}`)).results.map(a =>
-          this.launchAction(a)
-        )
+        (
+          await this.model.query(`status = 'SCHEDULED' AND scheduled < ${time + 1}`)
+        ).results.map(a => this.launchAction(a))
       );
       time += this.parameters.schedulerResolution;
       // Wait for next scheduler resolution

packages/async/src/services/servicerunner.ts

@@ -2,7 +2,7 @@ import { ConsoleLogger, MemoryLogger, WorkerLogLevel, WorkerMessage, WorkerOutpu
 import { AsyncAction, AsyncOperationAction, AsyncWebdaAction } from "../models";
 import AsyncJobService, { JobInfo } from "./asyncjobservice";
 import { AgentInfo, Runner, RunnerParameters } from "./runner";
-import { OperationContext } from "@webda/core";
+import { OperationContext, SimpleOperationContext } from "@webda/core";
 
 /**
  * Type of action returned by LocalRunner
@@ -122,21 +122,11 @@ export default class ServiceRunner<T extends ServiceRunnerParameters = ServiceRu
         if (action instanceof AsyncWebdaAction) {
           await this.getService(action.serviceName)[action.method](...(action.arguments || []));
         } else {
-          let ctx = new OperationContext(this.getWebda());
-          //@ts-expect-error temporary fix
-          ctx.session = action.context.session;
-          //@ts-expect-error temporary fix
-          ctx.input = action.context.input.data;
-          ctx.getRawInput = async function () {
-            //@ts-expect-error temporary fix
-            return Buffer.from(ctx.input || []);
-          };
-          ctx.getCurrentUserId = function () {
-            if (this.session) {
-              return this.session.userId;
-            }
-            return undefined;
-          };
+          let ctx: SimpleOperationContext = new SimpleOperationContext(this.getWebda());
+          // Unserialization might not have happened
+          ctx.setSession(action.context.getSession ? action.context.getSession() : action.context["session"]);
+          // Unserialization might not have happened
+          ctx.setInput(Buffer.from(action.context["input"]?.data || []));
           await this.getWebda().callOperation(ctx, action.operationId);
         }
         await logger.saveAndClose();

packages/core/src/queues/filequeue.spec.ts

@@ -45,7 +45,7 @@ class FileQueueTest extends QueueTest {
     // Check if the deletion is not crashing even if the content file is removed
     unlinkSync(`${queue.getParameters().folder}/${msg2[0].ReceiptHandle}.json`);
     await queue.deleteMessage(msg2[0].ReceiptHandle);
-    
+
     // Check if default parameter is correctly set
     queue = new FileQueue(this.webda, "q", {});
     assert.strictEqual(queue.getParameters().expire, 30000);

packages/core/src/services/binary.spec.ts

@@ -95,12 +95,8 @@ class BinaryTest<T extends BinaryService = BinaryService> extends WebdaTest {
     var user;
     var ctx;
     this.log("DEBUG", "Initializing users");
-    user1 = await userStore.save({
-      test: "plop"
-    });
-    user2 = await userStore.save({
-      test: "plop"
-    });
+    user1 = await userStore.save({ test: "plop" });
+    user2 = await userStore.save({ test: "plop" });
     this.log("DEBUG", "Store a local file");
     await binary.store(user1, map, new LocalBinaryFile(this.getTestFile()), {});
     user1 = await userStore.get(user1.uuid);
@@ -128,10 +124,7 @@ class BinaryTest<T extends BinaryService = BinaryService> extends WebdaTest {
     value = await binary.getUsageCount(hash);
     assert.strictEqual(value, 1);
     // Try to get images on user1 as user2
-    ctx = await this.newContext({
-      type: "CRUD",
-      uuid: "PLOP"
-    });
+    ctx = await this.newContext({ type: "CRUD", uuid: "PLOP" });
     ctx.session.userId = user2.uuid;
     let executor = this.getExecutor(
       ctx,
@@ -206,9 +199,7 @@ class BinaryTest<T extends BinaryService = BinaryService> extends WebdaTest {
   async notMapped() {
     let userStore = this.getUserStore();
     let binary = this.getBinary();
-    let user1 = await userStore.save({
-      test: "plop"
-    });
+    let user1 = await userStore.save({ test: "plop" });
     binary.getParameters().models = {};
     await assert.rejects(
       () => binary.store(user1, "images2", new LocalBinaryFile(this.getTestFile()), {}),
@@ -224,9 +215,7 @@ class BinaryTest<T extends BinaryService = BinaryService> extends WebdaTest {
     var user1;
     var user;
     let hash;
-    user1 = await userStore.save({
-      test: "plop"
-    });
+    user1 = await userStore.save({ test: "plop" });
     await binary.store(user1, map, new LocalBinaryFile(this.getTestFile()), {});
     user = await userStore.get(user1.uuid);
     assert.notStrictEqual(user[map], undefined);
@@ -246,9 +235,7 @@ class BinaryTest<T extends BinaryService = BinaryService> extends WebdaTest {
   @test
   async httpCreate() {
     let userStore = this.getUserStore();
-    let user1 = await userStore.save({
-      test: "plop"
-    });
+    let user1 = await userStore.save({ test: "plop" });
     let ctx = await this.newContext();
     let executor = this.getExecutor(ctx, "test.webda.io", "POST", `/binary/users/${user1.getUuid()}/images`, {});
     await assert.rejects(
@@ -388,10 +375,7 @@ class BinaryTest<T extends BinaryService = BinaryService> extends WebdaTest {
       "test.webda.io",
       "PUT",
       `/binary/users/${user1.getUuid()}/images/0/${user1.images[0].hash}`,
-      {
-        "my-metadata": "updated",
-        "my-other-metadata": true
-      }
+      { "my-metadata": "updated", "my-other-metadata": true }
     );
     await executor.execute(ctx);
     let user = await this.getUserStore().get(ctx.getCurrentUserId());
@@ -403,10 +387,7 @@ class BinaryTest<T extends BinaryService = BinaryService> extends WebdaTest {
       "test.webda.io",
       "PUT",
       `/binary/users/${user1.getUuid()}/images/0/${user1.images[0].hash}`,
-      {
-        "my-metadata": "updated".repeat(4096),
-        "my-other-metadata": true
-      }
+      { "my-metadata": "updated".repeat(4096), "my-other-metadata": true }
     );
     await assert.rejects(
       () => executor.execute(ctx),
@@ -420,26 +401,17 @@ class BinaryTest<T extends BinaryService = BinaryService> extends WebdaTest {
     await assert.rejects(
       () =>
         // @ts-ignore
-        this.getBinary().get({
-          hash: "none",
-          mimetype: "",
-          size: 10
-        }),
+        this.getBinary().get({ hash: "none", mimetype: "", size: 10 }),
       BinaryNotFoundError
     );
   }
 
-  async setupDefault(withLogin: boolean = true): Promise<{
-    userStore: Store;
-    binary: BinaryService;
-    user1: ImageUser;
-    ctx: WebContext;
-  }> {
+  async setupDefault(
+    withLogin: boolean = true
+  ): Promise<{ userStore: Store; binary: BinaryService; user1: ImageUser; ctx: WebContext }> {
     let userStore = this.getUserStore();
     let binary = this.getBinary();
-    let user1: ImageUser = await userStore.save({
-      test: "plop"
-    });
+    let user1: ImageUser = await userStore.save({ test: "plop" });
     await binary.store(user1, "images", new LocalBinaryFile(this.getTestFile()));
     await user1.refresh();
     let ctx = await this.newContext();
@@ -456,9 +428,7 @@ class BinaryTest<T extends BinaryService = BinaryService> extends WebdaTest {
       Buffer.from("PLOP"),
       <BinaryFileInfo>(<unknown>{})
     ).getHashes();
-    let metadata = {
-      plop: "test"
-    };
+    let metadata = { plop: "test" };
     let executor = this.getExecutor(ctx, "test.webda.io", "PUT", `/binary/upload/users/${user1.getUuid()}/images`, {
       hash,
       challenge,
@@ -533,24 +503,10 @@ class BinaryTest<T extends BinaryService = BinaryService> extends WebdaTest {
   async sendChallengeData(info: any, data: string) {
     let res;
     try {
-      res = await axios.request({
-        method: info.method,
-        url: info.url,
-        data,
-        headers: info.headers
-      });
+      res = await axios.request({ method: info.method, url: info.url, data, headers: info.headers });
       return res;
     } catch (err) {
-      console.log(
-        "sendChallengeDataError",
-        {
-          method: info.method,
-          url: info.url,
-          data,
-          headers: info.headers
-        },
-        err
-      );
+      console.log("sendChallengeDataError", { method: info.method, url: info.url, data, headers: info.headers }, err);
       throw err;
     }
   }

packages/core/src/utils/context.ts

@@ -373,7 +373,7 @@ export class OperationContext<T = any, U = any> extends EventEmitter {
    * Get the current user id from session
    */
   getCurrentUserId() {
-    return undefined;
+    return this.session?.userId;
   }
 
   /**

packages/graphql/src/graphql.spec.ts

@@ -507,7 +507,10 @@ class GraphQLSubscriptionTest {
             await Course.ref("test").delete();
           } else if (i === 4) {
             // Finishing the test
-            assert.deepStrictEqual(event.data?.Courses.results.map(c => c.name), ["test2b", "test3"]);
+            assert.deepStrictEqual(
+              event.data?.Courses.results.map(c => c.name),
+              ["test2b", "test3"]
+            );
             break;
           }
         }
@@ -685,5 +688,6 @@ class TypesTest {
     assert.throws(() => DateScalar.serialize("test"), /GraphQL Date Scalar serializer expected a `Date` object/);
     assert.ok(DateScalar.parseLiteral({ kind: Kind.STRING, value: "2020-01-01T00:00:00.000Z" }) instanceof Date);
     assert.strictEqual(DateScalar.parseLiteral({ kind: Kind.INT, value: "2020-01-01T00:00:00.000Z" }), null);
+    assert.strictEqual(DateScalar.parseValue(null), undefined);
   }
 }