Fix actor reminder and timer period parameter (#536)

* Update ActorClientHTTP.ts

Signed-off-by: heunghingwan <[email protected]>

* Add actor reminder e2e test

Signed-off-by: heunghingwan <[email protected]>

* Add actor timer e2e test

Signed-off-by: heunghingwan <[email protected]>

---------

Signed-off-by: heunghingwan <[email protected]>

Author: heunghingwan

src/actors/client/ActorClient/ActorClientHTTP.ts

@@ -63,7 +63,7 @@ export default class ActorClientHTTP implements IClientActor {
         "Content-Type": "application/json",
       },
       body: {
-        period: reminder.period.toString().toLocaleLowerCase().replace("pt", ""),
+        period: reminder?.period?.toString()?.toLocaleLowerCase().replace("pt", ""),
         dueTime: reminder?.dueTime?.toString()?.toLocaleLowerCase().replace("pt", ""),
         ttl: reminder?.ttl?.toString()?.toLocaleLowerCase().replace("pt", ""),
         data: reminder.data,
@@ -89,7 +89,7 @@ export default class ActorClientHTTP implements IClientActor {
         "Content-Type": "application/json",
       },
       body: {
-        period: timer.period.toString().toLocaleLowerCase().replace("pt", ""),
+        period: timer?.period?.toString()?.toLocaleLowerCase().replace("pt", ""),
         dueTime: timer?.dueTime?.toString()?.toLocaleLowerCase().replace("pt", ""),
         ttl: timer?.ttl?.toString()?.toLocaleLowerCase().replace("pt", ""),
         data: timer.data,

test/actor/DemoActorReminderOnceImpl.ts

@@ -0,0 +1,51 @@
+/*
+Copyright 2023 The Dapr Authors
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { AbstractActor, Temporal } from "../../src";
+import DemoActorReminderInterface from "./DemoActorReminderInterface";
+
+export default class DemoActorReminderOnceImpl extends AbstractActor implements DemoActorReminderInterface {
+  counter = 0;
+
+  async init(): Promise<string> {
+    await super.registerActorReminder(
+      "my-reminder-name",
+      Temporal.Duration.from({ milliseconds: 1500 }),
+      undefined,
+      undefined,
+      100,
+    );
+
+    return "Actor Initialized";
+  }
+
+  async count(): Promise<void> {
+    this.counter++;
+  }
+
+  async getCounter(): Promise<number> {
+    return this.counter;
+  }
+
+  async removeReminder(): Promise<void> {
+    return this.unregisterActorReminder("my-reminder-name");
+  }
+
+  /**
+   * @override
+   * @param data
+   */
+  async receiveReminder(data: string): Promise<void> {
+    this.counter += parseInt(data);
+  }
+}

test/actor/DemoActorTimerOnceImpl.ts

@@ -0,0 +1,47 @@
+/*
+Copyright 2023 The Dapr Authors
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { AbstractActor, Temporal } from "../../src";
+import DemoActorTimerInterface from "./DemoActorTimerInterface";
+
+export default class DemoActorTimerOnceImpl extends AbstractActor implements DemoActorTimerInterface {
+  counter = 0;
+
+  async init(): Promise<string> {
+    await super.registerActorTimer(
+      "my-timer-name",
+      "countBy",
+      Temporal.Duration.from({ seconds: 2 }),
+      undefined,
+      undefined,
+      100,
+    );
+    return "Actor Initialized";
+  }
+
+  async count(): Promise<void> {
+    this.counter++;
+  }
+
+  async getCounter(): Promise<number> {
+    return this.counter;
+  }
+
+  async countBy(amount: string): Promise<void> {
+    this.counter += parseInt(amount);
+  }
+
+  async removeTimer(): Promise<void> {
+    return await this.unregisterActorTimer("my-timer-name");
+  }
+}

test/e2e/http/actors.test.ts

@@ -22,10 +22,12 @@ import DemoActorCounterImpl from "../../actor/DemoActorCounterImpl";
 import DemoActorCounterInterface from "../../actor/DemoActorCounterInterface";
 import DemoActorReminderImpl from "../../actor/DemoActorReminderImpl";
 import DemoActorReminder2Impl from "../../actor/DemoActorReminder2Impl";
+import DemoActorReminderOnceImpl from "../../actor/DemoActorReminderOnceImpl";
 import DemoActorReminderInterface from "../../actor/DemoActorReminderInterface";
 import DemoActorSayImpl from "../../actor/DemoActorSayImpl";
 import DemoActorSayInterface from "../../actor/DemoActorSayInterface";
 import DemoActorTimerImpl from "../../actor/DemoActorTimerImpl";
+import DemoActorTimerOnceImpl from "../../actor/DemoActorTimerOnceImpl";
 import DemoActorTimerInterface from "../../actor/DemoActorTimerInterface";
 import DemoActorTimerTtlImpl from "../../actor/DemoActorTimerTtlImpl";
 import DemoActorReminderTtlImpl from "../../actor/DemoActorReminderTtlImpl";
@@ -82,7 +84,9 @@ describe("http/actors", () => {
     await server.actor.registerActor(DemoActorSayImpl);
     await server.actor.registerActor(DemoActorReminderImpl);
     await server.actor.registerActor(DemoActorReminder2Impl);
+    await server.actor.registerActor(DemoActorReminderOnceImpl);
     await server.actor.registerActor(DemoActorTimerImpl);
+    await server.actor.registerActor(DemoActorTimerOnceImpl);
     await server.actor.registerActor(DemoActorActivateImpl);
     await server.actor.registerActor(DemoActorTimerTtlImpl);
     await server.actor.registerActor(DemoActorReminderTtlImpl);
@@ -292,6 +296,32 @@ describe("http/actors", () => {
       const res4 = await actor.getCounter();
       expect(res4).toEqual(200);
     }, 10000);
+
+    it("should only fire once when period is not set to a timer", async () => {
+      const builder = new ActorProxyBuilder<DemoActorTimerInterface>(DemoActorTimerOnceImpl, client);
+      const actor = builder.build(ActorId.createRandomId());
+
+      // Activate our actor
+      await actor.init();
+
+      const res0 = await actor.getCounter();
+      expect(res0).toEqual(0);
+
+      // Now we wait for dueTime (2s)
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+
+      // After that the timer callback will be called
+      // In our case, the callback increments the count attribute
+      // the count attribute is +100 due to the passed state
+      const res1 = await actor.getCounter();
+      expect(res1).toEqual(100);
+
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+
+      // Make sure the counter didn't change
+      const res2 = await actor.getCounter();
+      expect(res2).toEqual(100);
+    }, 5000);
   });
 
   describe("reminders", () => {
@@ -379,5 +409,31 @@ describe("http/actors", () => {
       const res2 = await actor.getCounter();
       expect(res2).toEqual(123);
     });
+
+    it("should only fire once when period is not set to a reminder", async () => {
+      const builder = new ActorProxyBuilder<DemoActorReminderInterface>(DemoActorReminderOnceImpl, client);
+      const actor = builder.build(ActorId.createRandomId());
+
+      // Activate our actor
+      // this will initialize the reminder to be called
+      await actor.init();
+
+      const res0 = await actor.getCounter();
+      expect(res0).toEqual(0);
+
+      // Now we wait for dueTime (1.5s)
+      await NodeJSUtil.sleep(1500);
+
+      // After that the reminder callback will be called
+      // In our case, the callback increments the count attribute
+      const res1 = await actor.getCounter();
+      expect(res1).toEqual(100);
+
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+
+      // Make sure the counter didn't change
+      const res2 = await actor.getCounter();
+      expect(res2).toEqual(100);
+    }, 5000);
   });
 });