@deck.gl/test-utils 9.0.0-alpha.7 → 9.0.0-beta.10

package/dist/snapshot-test-runner.js

@@ -0,0 +1,101 @@
+// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+/* global window */
+import { TestRunner } from "./test-runner.js";
+import { getBoundingBoxInPage } from "./utils/dom.js";
+const DEFAULT_TEST_OPTIONS = {
+    imageDiffOptions: {}
+};
+const DEFAULT_TEST_CASE = {
+    name: 'Unnamed snapshot test',
+    props: {},
+    onBeforeRender: ({ deck, layers }) => {
+        // eslint-disable-line
+    },
+    onAfterRender: ({ deck, layers, done }) => {
+        if (layers.every(layer => layer.isLoaded)) {
+            done(); // eslint-disable-line
+        }
+    },
+    goldenImage: ''
+};
+export class SnapshotTestRunner extends TestRunner {
+    constructor(props) {
+        super(props, DEFAULT_TEST_OPTIONS);
+        this._isDiffing = false;
+        this._isDiffing = false;
+    }
+    get defaultTestCase() {
+        return DEFAULT_TEST_CASE;
+    }
+    initTestCase(testCase) {
+        super.initTestCase(testCase);
+        if (!testCase.goldenImage) {
+            throw new Error(`Test case ${testCase.name} does not have golden image`);
+        }
+    }
+    runTestCase(testCase) {
+        const deck = this.deck;
+        return new Promise(resolve => {
+            deck.setProps({
+                ...this.props,
+                ...testCase,
+                onBeforeRender: () => {
+                    testCase.onBeforeRender({
+                        deck,
+                        // @ts-expect-error Accessing protected layerManager
+                        layers: this.deck.layerManager.getLayers()
+                    });
+                },
+                onAfterRender: () => {
+                    testCase.onAfterRender({
+                        deck,
+                        // @ts-expect-error Accessing protected layerManager
+                        layers: this.deck.layerManager.getLayers(),
+                        done: resolve
+                    });
+                }
+            });
+        });
+    }
+    async assert(testCase) {
+        if (this._isDiffing) {
+            // already performing diffing
+            return;
+        }
+        this._isDiffing = true;
+        const diffOptions = {
+            ...this.testOptions.imageDiffOptions,
+            ...testCase.imageDiffOptions,
+            goldenImage: testCase.goldenImage,
+            region: getBoundingBoxInPage(this.deck.getCanvas())
+        };
+        // Take screenshot and compare
+        const result = await window.browserTestDriver_captureAndDiffScreen(diffOptions);
+        // invoke user callback
+        if (result.success) {
+            this.pass(result);
+        }
+        else {
+            this.fail(result);
+        }
+        this._isDiffing = false;
+    }
+}

package/dist/test-runner.d.ts

@@ -0,0 +1,56 @@
+import { Deck, DeckProps } from '@deck.gl/core';
+export type TestCase = {
+    name: string;
+    /** milliseconds to wait before aborting */
+    timeout?: number;
+};
+type TestOptions<TestCaseT extends TestCase, ResultT> = {
+    /** Called when a test case starts */
+    onTestStart: (testCase: TestCaseT) => void;
+    /** Called when a test case passes */
+    onTestPass: (testCase: TestCaseT, result: ResultT) => void;
+    /** Called when a test case fails */
+    onTestFail: (testCase: TestCaseT, result: ResultT | {
+        error: string;
+    }) => void;
+    /** milliseconds to wait for each test case before aborting */
+    timeout: number;
+};
+export declare abstract class TestRunner<TestCaseT extends TestCase, ResultT, ExtraOptions = {}> {
+    deck: Deck | null;
+    props: DeckProps;
+    isHeadless: boolean;
+    isRunning: boolean;
+    testOptions: TestOptions<TestCaseT, ResultT> & ExtraOptions;
+    gpuVendor?: string;
+    private _testCases;
+    private _currentTestCase;
+    private _testCaseData;
+    /**
+     * props
+     *   Deck props
+     */
+    constructor(props: DeckProps | undefined, options: ExtraOptions);
+    get defaultTestCase(): TestCaseT;
+    /**
+     * Add testCase(s)
+     */
+    add(testCases: TestCaseT[]): this;
+    /**
+     * Returns a promise that resolves when all the test cases are done
+     */
+    run(options?: Partial<TestOptions<TestCaseT, ResultT> & ExtraOptions>): Promise<void>;
+    initTestCase(testCase: TestCaseT): void;
+    /** Execute the test case. Fails if takes longer than options.timeout */
+    abstract runTestCase(testCase: TestCaseT): Promise<void>;
+    /** Check the result of the test case. Calls pass() or fail() */
+    abstract assert(testCase: TestCaseT): Promise<void>;
+    protected pass(result: ResultT): void;
+    protected fail(result: ResultT | {
+        error: string;
+    }): void;
+    private _onDeviceInitialized;
+    private _runTest;
+}
+export {};
+//# sourceMappingURL=test-runner.d.ts.map

package/dist/test-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner.d.ts","sourceRoot":"","sources":["../src/test-runner.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAC,IAAI,EAAE,SAAS,EAAU,MAAM,eAAe,CAAC;AAcvD,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,KAAK,WAAW,CAAC,SAAS,SAAS,QAAQ,EAAE,OAAO,IAAI;IACtD,qCAAqC;IACrC,WAAW,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,IAAI,CAAC;IAC3C,qCAAqC;IACrC,UAAU,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAC3D,oCAAoC;IACpC,UAAU,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,GAAG;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,KAAK,IAAI,CAAC;IAE7E,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAYF,8BAAsB,UAAU,CAAC,SAAS,SAAS,QAAQ,EAAE,OAAO,EAAE,YAAY,GAAG,EAAE;IACrF,IAAI,EAAE,IAAI,GAAG,IAAI,CAAQ;IACzB,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,OAAO,CAAS;IAC3B,WAAW,EAAE,WAAW,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,YAAY,CAAC;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,aAAa,CAAiB;IAEtC;;;OAGG;gBACS,KAAK,uBAAgB,EAAE,OAAO,EAAE,YAAY;IASxD,IAAI,eAAe,IAAI,SAAS,CAE/B;IAED;;OAEG;IACH,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,IAAI;IAUjC;;OAEG;IACH,GAAG,CAAC,OAAO,GAAE,OAAO,CAAC,WAAW,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,YAAY,CAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgCzF,YAAY,CAAC,QAAQ,EAAE,SAAS;IAShC,wEAAwE;IACxE,QAAQ,CAAC,WAAW,CAAC,QAAQ,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IACxD,gEAAgE;IAChE,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAInD,SAAS,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO;IAI9B,SAAS,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,GAAG;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IAMhD,OAAO,CAAC,oBAAoB;YAId,QAAQ;CAuBvB"}

package/dist/test-runner.js

@@ -0,0 +1,143 @@
+// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+/* global window, console, setTimeout */
+/* eslint-disable no-console */
+import { Deck, MapView } from '@deck.gl/core';
+const DEFAULT_DECK_PROPS = {
+    ...Deck.defaultProps,
+    id: 'deckgl-render-test',
+    width: 800,
+    height: 450,
+    style: { position: 'absolute', left: '0px', top: '0px' },
+    views: [new MapView({})],
+    useDevicePixels: false,
+    debug: true
+};
+const DEFAULT_TEST_OPTIONS = {
+    // test lifecycle callback
+    onTestStart: testCase => console.log(`# ${testCase.name}`),
+    onTestPass: testCase => console.log(`ok ${testCase.name} passed`),
+    onTestFail: testCase => console.log(`not ok ${testCase.name} failed`),
+    // milliseconds to wait for each test case before aborting
+    timeout: 2000
+};
+export class TestRunner {
+    /**
+     * props
+     *   Deck props
+     */
+    constructor(props = {}, options) {
+        this.deck = null;
+        this.isRunning = false;
+        this._testCases = [];
+        this._currentTestCase = null;
+        this._testCaseData = null;
+        this.props = { ...DEFAULT_DECK_PROPS, ...props };
+        // @ts-ignore browserTestDriver_isHeadless is injected by @probe.gl/test-utils if running in headless browser
+        this.isHeadless = Boolean(window.browserTestDriver_isHeadless);
+        this.testOptions = { ...DEFAULT_TEST_OPTIONS, ...options };
+    }
+    get defaultTestCase() {
+        throw new Error('Not implemented');
+    }
+    /**
+     * Add testCase(s)
+     */
+    add(testCases) {
+        if (!Array.isArray(testCases)) {
+            testCases = [testCases];
+        }
+        for (const testCase of testCases) {
+            this._testCases.push(testCase);
+        }
+        return this;
+    }
+    /**
+     * Returns a promise that resolves when all the test cases are done
+     */
+    run(options = {}) {
+        Object.assign(this.testOptions, options);
+        return new Promise((resolve, reject) => {
+            this.deck = new Deck({
+                ...this.props,
+                onDeviceInitialized: this._onDeviceInitialized.bind(this),
+                onLoad: resolve
+            });
+            this.isRunning = true;
+            this._currentTestCase = null;
+        })
+            .then(() => {
+            let promise = Promise.resolve();
+            // chain test case promises
+            this._testCases.forEach(testCase => {
+                promise = promise.then(() => this._runTest(testCase));
+            });
+            return promise;
+        })
+            .catch((error) => {
+            this.fail({ error: error.message });
+        })
+            .finally(() => {
+            this.deck.finalize();
+            this.deck = null;
+        });
+    }
+    /* Lifecycle methods for subclassing */
+    initTestCase(testCase) {
+        for (const key in this.defaultTestCase) {
+            if (!(key in testCase)) {
+                testCase[key] = this.defaultTestCase[key];
+            }
+        }
+        this.testOptions.onTestStart(testCase);
+    }
+    /* Utilities */
+    pass(result) {
+        this.testOptions.onTestPass(this._currentTestCase, result);
+    }
+    fail(result) {
+        this.testOptions.onTestFail(this._currentTestCase, result);
+    }
+    /* Private Methods */
+    _onDeviceInitialized(device) {
+        this.gpuVendor = device.info.vendor;
+    }
+    async _runTest(testCase) {
+        this._currentTestCase = testCase;
+        // normalize test case
+        this.initTestCase(testCase);
+        const timeout = testCase.timeout || this.testOptions.timeout;
+        const task = this.runTestCase(testCase);
+        const timeoutTask = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject('Timeout');
+            }, timeout);
+        });
+        try {
+            await Promise.race([task, timeoutTask]);
+            await this.assert(testCase);
+        }
+        catch (err) {
+            if (err === 'Timeout') {
+                this.fail({ error: 'Timeout' });
+            }
+        }
+    }
+}

package/dist/utils/dom.d.ts

@@ -0,0 +1,7 @@
+export declare function getBoundingBoxInPage(domElement: HTMLElement): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+//# sourceMappingURL=dom.d.ts.map

package/dist/utils/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../src/utils/dom.ts"],"names":[],"mappings":"AAEA,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,WAAW,GAAG;IAC7D,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAQA"}

package/dist/utils/dom.js

@@ -0,0 +1,11 @@
+/* global window */
+// Get the bounding box of a DOMElement relative to the page
+export function getBoundingBoxInPage(domElement) {
+    const bbox = domElement.getBoundingClientRect();
+    return {
+        x: window.scrollX + bbox.x,
+        y: window.scrollY + bbox.y,
+        width: bbox.width,
+        height: bbox.height
+    };
+}

package/dist/utils/precision.d.ts

@@ -0,0 +1,4 @@
+export declare function toLowPrecision(input: number, precision?: number): number;
+export declare function toLowPrecision(input: number[], precision?: number): number[];
+export declare function toLowPrecision(input: Record<string, number>, precision?: number): Record<string, number>;
+//# sourceMappingURL=precision.d.ts.map

package/dist/utils/precision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"precision.d.ts","sourceRoot":"","sources":["../../src/utils/precision.ts"],"names":[],"mappings":"AAAA,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;AAC1E,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAC9E,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC"}

package/dist/utils/precision.js

@@ -0,0 +1,19 @@
+/**
+ * Covert all numbers in a deep structure to a given precision, allowing
+ * reliable float comparisons. Converts data in-place.
+ */
+export function toLowPrecision(input, precision = 11) {
+    /* eslint-disable guard-for-in */
+    if (typeof input === 'number') {
+        return Number(input.toPrecision(precision));
+    }
+    if (Array.isArray(input)) {
+        return input.map(item => toLowPrecision(item, precision));
+    }
+    if (typeof input === 'object') {
+        for (const key in input) {
+            input[key] = toLowPrecision(input[key], precision);
+        }
+    }
+    return input;
+}

package/dist/utils/setup-gl.d.ts

@@ -0,0 +1,5 @@
+/** Test device */
+export declare const device: import("@luma.gl/webgl").WebGLDevice;
+/** Test context */
+export declare const gl: WebGL2RenderingContext | null;
+//# sourceMappingURL=setup-gl.d.ts.map

package/dist/utils/setup-gl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-gl.d.ts","sourceRoot":"","sources":["../../src/utils/setup-gl.ts"],"names":[],"mappings":"AAEA,kBAAkB;AAClB,eAAO,MAAM,MAAM,sCAAc,CAAC;AAElC,mBAAmB;AACnB,eAAO,MAAM,EAAE,+BAMb,CAAC"}

package/dist/utils/setup-gl.js

@@ -0,0 +1,15 @@
+import { createTestContext, webglDevice } from '@luma.gl/test-utils';
+/** Test device */
+export const device = webglDevice;
+/** Test context */
+export const gl = createTestContext({
+    width: 1,
+    height: 1,
+    debug: true
+    // throwOnFailure: false,
+    // throwOnError: false
+});
+//   // TODO - Seems to be an issue in luma.gl
+//   (createContext && createContext(100, 100, {}));
+// // console.log('Context', globalThis.glContext);
+globalThis.glContext = globalThis.glContext || gl;

package/package.json

@@ -2,7 +2,8 @@
   "name": "@deck.gl/test-utils",
   "description": "Test utilities for deck.gl layers",
   "license": "MIT",
-  "version": "9.0.0-alpha.7",
+  "type": "module",
+  "version": "9.0.0-beta.10",
   "publishConfig": {
     "access": "public"
   },
@@ -16,22 +17,30 @@
     "type": "git",
     "url": "https://github.com/visgl/deck.gl.git"
   },
-  "main": "dist/es5/index.js",
-  "module": "dist/esm/index.js",
+  "types": "dist/index.d.ts",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
   "files": [
     "dist",
     "src",
     "typed"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.0.0"
+    "@luma.gl/test-utils": "^9.0.4"
   },
   "peerDependencies": {
-    "@deck.gl/core": "^9.0.0-alpha",
-    "@luma.gl/test-utils": "9.0.0-alpha.53",
-    "@luma.gl/webgl": "9.0.0-alpha.53",
+    "@deck.gl/core": "^9.0.0-beta",
+    "@luma.gl/core": "^9.0.4",
+    "@luma.gl/engine": "^9.0.4",
     "@probe.gl/test-utils": "^4.0.0"
   },
   "scripts": {},
-  "gitHead": "de061268077ab74e163792162efbc07be95d10f5"
+  "gitHead": "6c44f602069374cd21268ff279c5bf818c905ff7"
 }

package/src/generate-layer-tests.ts

@@ -17,38 +17,60 @@
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
-import {_count as count} from '@deck.gl/core';
+import {_count as count, Layer} from '@deck.gl/core';
 
+import type {DefaultProps} from '@deck.gl/core';
+import type {LayerTestCase, LayerClass} from './lifecycle-test';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
 function noop() {}
 
-function defaultAssert(condition, comment) {
+function defaultAssert(condition: any, comment: string): void {
   if (!condition) {
     throw new Error(comment);
   }
 }
 
 // Automatically generate testLayer test cases
-export function generateLayerTests({
+export function generateLayerTests<LayerT extends Layer>({
   Layer,
   sampleProps = {},
   assert = defaultAssert,
   onBeforeUpdate = noop,
   onAfterUpdate = noop,
   runDefaultAsserts = true
-}) {
+}: {
+  Layer: LayerClass<LayerT>;
+  /**
+   * Override default props during the test
+   */
+  sampleProps?: Partial<LayerT['props']>;
+  assert?: (condition: any, comment: string) => void;
+  onBeforeUpdate?: LayerTestCase<LayerT>['onBeforeUpdate'];
+  onAfterUpdate?: LayerTestCase<LayerT>['onAfterUpdate'];
+
+  /**
+   * Test some typical assumptions after layer updates
+   * For primitive layers, assert that layer has model(s).
+   * For composite layers, assert that layer has sublayer(s).
+   * @default true
+   */
+  runDefaultAsserts?: boolean;
+}): LayerTestCase<LayerT>[] {
   assert(Layer.layerName, 'Layer should have display name');
 
-  function wrapTestCaseTitle(title) {
+  function wrapTestCaseTitle(title: string): string {
     return `${Layer.layerName}#${title}`;
   }
 
-  const testCases = [
+  const testCases: LayerTestCase<LayerT>[] = [
     {
       title: 'Empty props',
       props: {}
     },
     {
       title: 'Null data',
+      // @ts-expect-error null may not be an expected data type
       updateProps: {data: null}
     },
     {
@@ -61,14 +83,15 @@ export function generateLayerTests({
     // Calling constructor for the first time resolves default props
     // eslint-disable-next-line
     new Layer({});
-  } catch (error) {
-    assert(false, `Construct ${Layer.layerName} throws: ${error.message}`);
+  } catch (error: unknown) {
+    assert(false, `Construct ${Layer.layerName} throws: ${(error as Error).message}`);
   }
 
+  //  @ts-expect-error Access hidden properties
   const {_propTypes: propTypes, _mergedDefaultProps: defaultProps} = Layer;
 
   // Test alternative data formats
-  testCases.push(...makeAltDataTestCases(sampleProps, propTypes));
+  testCases.push(...makeAltDataTestCases<LayerT>(sampleProps, propTypes));
 
   for (const propName in Layer.defaultProps) {
     if (!(propName in sampleProps)) {
@@ -112,7 +135,19 @@ export function generateLayerTests({
   return testCases;
 }
 
-function makeAltPropTestCase({propName, propTypes, defaultProps, sampleProps, assert}) {
+function makeAltPropTestCase<LayerT extends Layer>({
+  propName,
+  propTypes,
+  defaultProps,
+  sampleProps,
+  assert
+}: {
+  propName: string;
+  propTypes: DefaultProps<LayerT['props']>;
+  defaultProps: LayerT['props'];
+  sampleProps: Partial<LayerT['props']>;
+  assert: (condition: any, comment: string) => void;
+}): LayerTestCase<LayerT>[] | null {
   const newProps = {...sampleProps};
   const propDef = propTypes[propName];
 
@@ -173,7 +208,7 @@ function makeAltPropTestCase({propName, propTypes, defaultProps, sampleProps, as
             updateTriggers: {
               [propName]: 'function+trigger'
             }
-          },
+          } as Partial<Layer['props']>,
           onBeforeUpdate,
           onAfterUpdate
         }
@@ -185,29 +220,34 @@ function makeAltPropTestCase({propName, propTypes, defaultProps, sampleProps, as
   }
 }
 
-function makeAltDataTestCases(props, propTypes) {
+function makeAltDataTestCases<LayerT extends Layer>(
+  props: Partial<LayerT['props']>,
+  propTypes: DefaultProps<LayerT['props']>
+): LayerTestCase<LayerT>[] {
   const originalData = props.data;
   if (!Array.isArray(originalData)) {
     return [];
   }
   // partial update
-  const partialUpdateProps = {
+  const partialUpdateProps: Partial<Layer['props']> = {
     data: originalData.slice(),
     _dataDiff: () => [{startRow: 0, endRow: 2}]
   };
   // data should support any iterable
-  const genIterableProps = {
+  const genIterableProps: Partial<Layer['props']> = {
     data: new Set(originalData),
     _dataDiff: null
   };
   // data in non-iterable form
-  const nonIterableProps = {
+  const nonIterableProps: Partial<Layer['props']> = {
     data: {
       length: originalData.length
     }
   };
   for (const propName in props) {
+    // @ts-ignore propName cannot be used as index
     if (propTypes[propName].type === 'accessor') {
+      // @ts-ignore propName cannot be used as index
       nonIterableProps[propName] = (_, info) => props[propName](originalData[info.index], info);
     }
   }

package/src/index.ts

@@ -11,9 +11,13 @@ export {
 export {generateLayerTests} from './generate-layer-tests';
 
 // Basic utility for rendering multiple scenes (could go into "deck.gl/core")
-export {default as TestRunner} from './test-runner';
+export {TestRunner} from './test-runner';
 
 // A utility that renders a list of scenes and compares against golden images
-export {default as SnapshotTestRunner} from './snapshot-test-runner';
+export {SnapshotTestRunner} from './snapshot-test-runner';
 // A utility that emulates input events
-export {default as InteractionTestRunner} from './interaction-test-runner';
+export {InteractionTestRunner} from './interaction-test-runner';
+
+export type {LayerTestCase} from './lifecycle-test';
+export type {SnapshotTestCase} from './snapshot-test-runner';
+export type {InteractionTestCase} from './interaction-test-runner';