taskbuffer/test/test.1.task.ts

import { expect, tap } from '@push.rocks/tapbundle';
import * as taskbuffer from '../ts/index.js';
import * as smartpromise from '@push.rocks/smartpromise';
import * as smartdelay from '@push.rocks/smartdelay';

tap.test('new Task() should return a new task', async () => {
  const testTask = new taskbuffer.Task({
    taskFunction: async () => {
      console.log('executed twice');
    },
  });
  expect(testTask).toBeInstanceOf(taskbuffer.Task);
});

tap.test('should have bufferMax set to the provided value', async () => {
  const task2 = new taskbuffer.Task({
    taskFunction: async () => {},
  });
  expect(task2.bufferMax).toBeUndefined();  // test for a task without bufferMax set
  const bufferedTask = new taskbuffer.Task({
    taskFunction: async () => {},
    buffered: true,
    bufferMax: 3,
  });
  expect(bufferedTask.bufferMax).toEqual(3);
});

tap.test('should be able to trigger tasks multiple times', async () => {
  let task1Counter = 0; 
  const task1 = new taskbuffer.Task({
    name: 'Task 1',
    taskFunction: () => {
      let done = smartpromise.defer();
      console.log('Task1 started');
      setTimeout(() => {
        task1Counter++;
        console.log('Task1 executed');
        done.resolve();
      }, 5000);
      return done.promise;
    },
  });
  await task1.trigger();
  await task1.trigger();
  expect(task1Counter).toEqual(2);
});

tap.test('should execute setup function before the task function', async () => {
  const task2 = new taskbuffer.Task({
    name: 'Task 2',
    taskSetup: async () => {
      console.log('this is the setup function for task 2. It should only run once.')
      return {
        nice: 'yes',
      }
    },
    taskFunction: async (before, setupArg) => {
      expect(setupArg).toEqual({ nice: 'yes' });
      const done = smartpromise.defer();
      console.log('Task2 started');
      setTimeout(() => {
        console.log('Task2 executed');
        done.resolve();
      }, 5000);
      await done.promise;
    },
  });
  await task2.trigger();
});

tap.test('should not exceed bufferMax when task is buffered', async () => {
  let counter = 0;
  const bufferedTask = new taskbuffer.Task({
    taskFunction: async () => {
      counter++;
      await smartdelay.delayFor(2000);
      counter--;
    },
    buffered: true,
    bufferMax: 2,
  });
  bufferedTask.trigger();
  bufferedTask.trigger();
  bufferedTask.trigger();
  await smartdelay.delayFor(100);
  expect(counter <= bufferedTask.bufferMax).toBeTrue();
});

tap.start();