iterational-cjs.test.js

import { describe, it, expect, vi } from 'vitest';
const { sync, seq, parallel } = require('../gen/index.cjs');

describe('Iterational Tests', () => {
    describe('sync()', () => {
        it('should execute the callback for each item in order', () => {
            const mockCallback = vi.fn();
            const items = [1, 2, 3];

            sync(items, mockCallback);

            expect(mockCallback).toHaveBeenCalledTimes(items.length);
            expect(mockCallback.mock.calls).toEqual([[1], [2], [3]]);
        });

        it('should handle an empty array without errors', () => {
            const mockCallback = vi.fn();
            sync([], mockCallback);

            expect(mockCallback).not.toHaveBeenCalled();
        });
    });

    describe('seq()', () => {
        it('should execute the callback sequentially for each item', async () => {
            const callOrder = [];
            const mockCallback = vi.fn(async (item) => {
                callOrder.push(item);
            });

            const items = [1, 2, 3];
            await seq(items, mockCallback);

            expect(mockCallback).toHaveBeenCalledTimes(items.length);
            expect(callOrder).toEqual(items);
        });

        it('should handle an empty array without errors', async () => {
            const mockCallback = vi.fn();
            await seq([], mockCallback);

            expect(mockCallback).not.toHaveBeenCalled();
        });

        it('should await async operations in order', async () => {
            const results = [];
            const mockCallback = vi.fn(async (item) => {
                await new Promise((resolve) => setTimeout(resolve, 50));
                results.push(item);
            });

            const items = [1, 2, 3];
            await seq(items, mockCallback);

            expect(results).toEqual(items);
        });
    });

    describe('parallel()', () => {
        it('should execute the callback for each item in parallel', async () => {
            const mockCallback = vi.fn(async (item) => {
                await new Promise((resolve) => setTimeout(resolve, 50));
                return item * 2;
            });

            const items = [1, 2, 3];
            const results = await parallel(items, mockCallback);

            expect(mockCallback).toHaveBeenCalledTimes(items.length);
            expect(results).toEqual([2, 4, 6]);
        });

        it('should handle an empty array without errors', async () => {
            const mockCallback = vi.fn();
            const results = await parallel([], mockCallback);

            expect(mockCallback).not.toHaveBeenCalled();
            expect(results).toEqual([]);
        });

        it('should execute all callbacks concurrently', async () => {
            const startTime = Date.now();
            const delay = (ms) =>
                new Promise((resolve) => setTimeout(resolve, ms));

            const mockCallback = vi.fn(async (item) => {
                await delay(100);
                return item;
            });

            const items = [1, 2, 3];
            await parallel(items, mockCallback);

            const endTime = Date.now();
            const duration = endTime - startTime;

            // Since all async tasks run in parallel, duration should be close to 100ms (not 300ms)
            expect(duration).toBeLessThan(150);
        });
    });
});