feat: throw an error if task name is duplicate

src/errors.ts

@@ -14,6 +14,19 @@ export class UnexpectedStateError extends ExtendableError {
   }
 }
 
+export class DuplicateTaskNameError extends UnexpectedStateError {
+  duplicateTaskName: string;
+
+  constructor (duplicateTaskName: any) {
+    super(
+      'Task name is duplicate.',
+      'DUPLICATE_TASK_NAME',
+    );
+
+    this.duplicateTaskName = duplicateTaskName;
+  }
+}
+
 export class UnexpectedTaskInstructionsError extends UnexpectedStateError {
   unexpectedTaskInstructions: any;
 

src/factories/createPlanton.ts

@@ -4,6 +4,7 @@ import {
 } from 'serialize-error';
 import Logger from '../Logger';
 import {
+  DuplicateTaskNameError,
   UnexpectedTaskInstructionsError,
 } from '../errors';
 import type {
@@ -83,6 +84,12 @@ const createPlanton = (configuration: PlantonConfigurationInput): Planton => {
   for (const inputTask of configuration.tasks) {
     log.debug('registered %s task', inputTask.name);
 
+    for (const existingTask of tasks) {
+      if (existingTask.name === inputTask.name) {
+        throw new DuplicateTaskNameError(existingTask.name);
+      }
+    }
+
     const calculateDelay = inputTask.delay || (() => {
       return 1_000;
     });

src/index.ts

@@ -2,5 +2,6 @@ export {
   createPlanton,
 } from './factories';
 export {
+  DuplicateTaskNameError,
   UnexpectedTaskInstructionsError,
 } from './errors';

test/planton/factories/createPlanton.ts

@@ -32,6 +32,41 @@ test('schedules tasks at a interval', async (t) => {
   await planton.terminate();
 });
 
+test('throws if multiple tasks are registered with the same name', (t) => {
+  const error = t.throws(() => {
+    createPlanton({
+      getActiveTaskInstructions: () => {
+        return [];
+      },
+      tasks: [
+        {
+          delay: () => {
+            return 90;
+          },
+          name: 'foo',
+          schedule: async () => {
+            return [];
+          },
+        },
+        {
+          delay: () => {
+            return 90;
+          },
+          name: 'foo',
+          schedule: async () => {
+            return [];
+          },
+        },
+      ],
+    });
+  });
+
+  t.like(error, {
+    code: 'DUPLICATE_TASK_NAME',
+    duplicateTaskName: 'foo',
+  });
+});
+
 test('stops scheduling after Planton is terminated', async (t) => {
   const schedule = sinon
     .stub()