feat(sketches): allow to generate a set of configurable models

Author: GregOnNet

src/sketch.ts

@@ -1,4 +1,5 @@
 import { OverwritableSketch, OverwriteFn } from './overwritable-sketch';
+import { Sketches } from './sketches';
 
 export declare type Constructable<T> = new () => T;
 export declare type ModelFactory<T> = T;
@@ -23,6 +24,14 @@ export class Sketch<T> implements OverwritableSketch<T> {
     }
   }
 
+  take(length: number): Sketches<T> {
+    const sketches = Array.from({ length }).map(
+      () => new Sketch(this._token, this._createModel())
+    );
+
+    return new Sketches(sketches);
+  }
+
   set(map: OverwriteFn<T>): OverwritableSketch<T> {
     const model = this._apply(map, this._createModel());
     return new Sketch(this._token, model);

src/sketches.ts

@@ -0,0 +1,34 @@
+import { OverwritableSketch } from './overwritable-sketch';
+
+export class Sketches<T> {
+  constructor(private _sketches: Array<OverwritableSketch<T>>) {}
+
+  all(): OverwritableSketch<T>[] {
+    return this._sketches;
+  }
+
+  models(generators?: { [key in keyof T]?: () => T[key] }): T[] {
+    if (generators) {
+      const overrides = this._resolve(generators);
+
+      return this._sketches.map(sketch => sketch.model(overrides));
+    }
+    return this._sketches.map(sketch => sketch.model());
+  }
+
+  private _resolve(
+    generators: { [key in keyof T]?: () => T[key] }
+  ): { [key in keyof T]?: T[key] } {
+    return Object.keys(generators)
+      .map(key => ({
+        [key]: (generators as any)[key]()
+      }))
+      .reduce(
+        (combinedOverrides, override) => ({
+          ...combinedOverrides,
+          ...override
+        }),
+        {}
+      ) as any;
+  }
+}

test/create-list-of-models.spec.ts

@@ -0,0 +1,37 @@
+import { Kentan, Sketch } from '../src/kentan';
+
+class Empty {
+  id: string;
+}
+
+class ForEmpty extends Sketch<Empty> {
+  constructor() {
+    super(Empty);
+  }
+}
+
+describe('When a list of test data is needed', () => {
+  it('should be possible to generate a list of sketches', () => {
+    const sketches = Kentan.sketch(ForEmpty).take(2);
+    expect(sketches.all().length).toBe(2);
+  });
+
+  it('should allow to get the models from the sketch list', () => {
+    const models = Kentan.sketch(ForEmpty)
+      .take(1)
+      .models();
+
+    expect(models[0]).toBeInstanceOf(Empty);
+  });
+
+  it('should be allowed to pass a factory for a property', () => {
+    const id = '12-34-56-78';
+    const models = Kentan.sketch(ForEmpty)
+      .take(1)
+      .models({
+        id: () => id
+      });
+
+    expect(models[0].id).toBe(id);
+  });
+});