Add tasks

README.md

@@ -33,6 +33,40 @@ describe("My tests", () => {
 });
 ```
 
+### Events and Tasks
+
+We also include mocks to override Ampt events and tasks. They can be used with a testing library in a similar fashion:
+
+```js
+import { task, events } from "ampt-data-mock";
+
+jest.mock("@ampt/sdk", () => ({
+  task,
+  events,
+}));
+```
+
+Events are triggered immediately upon publishing so that you can syncronously validate your end to end tests.
+
+Tasks can be tested by exporting them and calling `.run()` inside your tests suite.
+
+```js
+// Your code
+import { task } from "@ampt/sdk";
+
+const myTask = task("my task", (event) => {
+  return true;
+});
+
+// Your test
+describe("My Task", () => {
+  it("Should run my task", async () => {
+    const result = await myTask.run();
+    expect(result).toEqual(true);
+  });
+});
+```
+
 ## Resetting
 
 Since this package persists data in memory, it is best practice to reset the data before each unit test using the `reset()` function

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ampt-data-mock",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "",
   "main": "lib/index.js",
   "scripts": {

src/__tests__/task.spec.ts

@@ -0,0 +1,13 @@
+import { task } from "../task";
+
+describe("Task", () => {
+  it("Should create and run a task", async () => {
+    const myTask = task("myTask", async (event, context) => {
+      return event.body;
+    });
+
+    const result = await myTask.run({ message: "Hello, World!" });
+
+    expect(result).toEqual({ message: "Hello, World!" });
+  });
+});

src/index.ts

@@ -1,3 +1,5 @@
 export * from "./data";
 export * from "./events";
 export * from "./helpers";
+export * from "./task";
+export * from "./storage";

src/storage.ts

@@ -0,0 +1,4 @@
+export const storage = () => ({
+  read: async () => {},
+  write: async () => {},
+});

src/task.ts

@@ -0,0 +1,57 @@
+interface EventHandlerEvent<BodyType = any> {
+  target: string;
+  id: string;
+  name: string;
+  body: BodyType;
+  time: number;
+  delay: number;
+  attempt?: number;
+}
+
+declare interface TaskContext {
+  setTimeout(ms: number): void;
+  progress(message: string, percent: number): void;
+}
+
+declare interface TaskEvent<T> extends EventHandlerEvent<T> {}
+
+declare interface TaskHandler<BodyType = any> {
+  (event: TaskEvent<BodyType>, context: TaskContext): Promise<any>;
+}
+
+interface ITaskOptions {
+  timeout?: number;
+  attempts?: number;
+}
+
+export const task = (
+  taskName: string,
+  handlerOrOptions: ITaskOptions | TaskHandler,
+  handler?: TaskHandler
+) => {
+  return {
+    run: async (expressionOrInput: string | any, input?: any) => {
+      const fn = handler || (handlerOrOptions as TaskHandler);
+      return await fn(
+        {
+          delay: 0,
+          id: new Date().getTime().toString(),
+          name: taskName,
+          target: taskName,
+          time: new Date().getTime(),
+          body: input || expressionOrInput,
+        },
+        {
+          setTimeout: (ms: number) => {},
+          progress: (message: string, percent: number) => {},
+        }
+      );
+    },
+    every: (interval: string, input?: any) => {},
+    cron: (expression: string, input?: any) => {},
+  };
+};
+
+task.status = (executionId: string) => {
+  return {};
+};