fix: 🐞 toCollection returns an array

BREAKING CHANGE: 🧨 toCollection now always returns an array

✅ Closes: #366

Author: NetanelBasal

packages/falso/src/lib/collection.ts

@@ -5,28 +5,21 @@ import { FakeOptions, fake } from './core/core';
  *
  * @category util
  *
- * @example
- *
- * toCollection(() => {
- *   return { data: randNumber(); }
- * })
  *
  * @example
  *
  * toCollection(() => {
  *   return { data: randNumber(); }
- * }, { length: 10 }) // default is no length.
+ * }, { length: 10 })
  *
  */
-export function toCollection<
-  Collection = never,
-  Options extends FakeOptions = never
->(
-  generateCollection: (options?: Options) => Collection,
-  options?: Options
-): Collection | Collection[] {
-  return fake<Collection, Options>(
-    () => generateCollection(options),
-    options
-  ) as Collection | Collection[];
+
+export function toCollection<Collection, Options extends FakeOptions = never>(
+  generator: () => Collection,
+  options: Options
+): Collection[] {
+  return fake<Collection, Options>(() => generator(), {
+    length: 5,
+    ...options,
+  }) as Collection[];
 }

packages/falso/src/tests/collection.spec.ts

@@ -1,86 +1,45 @@
 import { toCollection } from '../lib/collection';
-import { randNumber, random, seed } from '@ngneat/falso';
-import * as numberFunctions from '../lib/number';
-import Mock = jest.Mock;
-
-interface fakeData {
-  data: number;
-}
-
-describe('randCollection', () => {
-  it('should create', () => {
-    expect(toCollection).toBeTruthy();
+import { randNumber } from '../lib/number';
+
+describe('toCollection', () => {
+  it('should return an array of 5 items by default', () => {
+    const result = toCollection(() => ({ data: 1 }), {});
+    expect(Array.isArray(result)).toBe(true);
+    expect(result).toHaveLength(5);
+    result.forEach((item) => expect(item).toEqual({ data: 1 }));
   });
 
-  it('should return one collection if length is not specified', () => {
-    const expectedData: fakeData = { data: 1 };
-    expect(toCollection<fakeData>(() => expectedData)).toEqual(expectedData);
+  it('should return an array of custom length', () => {
+    const result = toCollection(() => ({ data: 2 }), { length: 3 });
+    expect(result).toHaveLength(3);
+    result.forEach((item) => expect(item).toEqual({ data: 2 }));
   });
 
-  it('should return an array of one collection if length is specified to 1', () => {
-    const expectedData: fakeData = { data: 1 };
-    expect(toCollection<fakeData>(() => expectedData)).toEqual(expectedData);
-    expect(
-      toCollection(() => expectedData, {
-        length: 1,
-      })
-    ).toEqual([expectedData]);
+  it('should call the generator function for each item and allow randomness', () => {
+    let callCount = 0;
+    const result = toCollection(
+      () => {
+        callCount++;
+        return { data: randNumber({ min: 1, max: 1000 }) };
+      },
+      { length: 4 }
+    );
+    expect(result).toHaveLength(4);
+    expect(callCount).toBe(4);
+    // Check that at least two items are different (high probability)
+    const unique = new Set(result.map((r) => r.data));
+    expect(unique.size).toBeGreaterThan(1);
   });
 
-  it('should return a collection of 2 elements if length=2 specified', () => {
-    const expectedData: fakeData = { data: 1 };
-    expect(
-      toCollection(() => expectedData, {
-        length: 2,
-      })
-    ).toEqual([expectedData, expectedData]);
+  it('should return an empty array if length is 0', () => {
+    const result = toCollection(() => ({ data: 3 }), { length: 0 });
+    expect(result).toEqual([]);
   });
 
-  describe('should call generators functions', () => {
-    let generatorFunction: Mock;
-
-    beforeAll(() => {
-      generatorFunction = jest.fn();
-      generatorFunction.mockReturnValue({ data: 1 });
-    });
-
-    afterEach(() => {
-      jest.clearAllMocks();
-    });
-
-    it('should return a collection of 2 elements that call another function', () => {
-      const expectedData: fakeData = { data: 1 };
-      expect(
-        toCollection(generatorFunction, {
-          length: 2,
-        })
-      ).toEqual([{ data: 1 }, { data: 1 }]);
-      expect(generatorFunction).toHaveBeenCalledTimes(2);
-      expect(generatorFunction).toHaveBeenCalledWith({ length: 2 });
-    });
-  });
-  describe('with call external random function', () => {
-    let randNumberSpy: jest.SpyInstance;
-
-    beforeAll(() => {
-      randNumberSpy = jest.spyOn(numberFunctions, 'randNumber');
-    });
-
-    afterEach(() => {
-      jest.clearAllMocks();
-    });
-
-    it('should return a collection of 2 elements that call another function', () => {
-      const expectedData: fakeData = { data: 1 };
-      randNumberSpy.mockReturnValueOnce(1).mockReturnValueOnce(2);
-      expect(
-        toCollection(
-          () => {
-            return { data: randNumber() };
-          },
-          { length: 2 }
-        )
-      ).toEqual([{ data: 1 }, { data: 2 }]);
-    });
+  it('should call the generator function the correct number of times', () => {
+    const mockGen = jest.fn().mockReturnValue({ data: 4 });
+    const result = toCollection(mockGen, { length: 7 });
+    expect(result).toHaveLength(7);
+    expect(mockGen).toHaveBeenCalledTimes(7);
   });
 });