@scoova/mgl 1.0.0

package/src/ui/map_tests/map_animation.test.ts

@@ -0,0 +1,61 @@
+import {createMap, beforeMapTest} from '../../util/test/util';
+import simulate from '../../../test/unit/lib/simulate_interaction';
+
+beforeEach(() => {
+    beforeMapTest();
+    global.fetch = null;
+});
+
+test('stops camera animation on touchstart when interactive', () => {
+    const map = createMap({interactive: true});
+    map.flyTo({center: [200, 0], duration: 100});
+
+    simulate.touchstart(map.getCanvasContainer(), {touches: [{target: map.getCanvas(), clientX: 0, clientY: 0}]});
+    expect(map.isEasing()).toBe(false);
+
+    map.remove();
+});
+
+test('continues camera animation on touchstart when non-interactive', () => {
+    const map = createMap({interactive: false});
+    map.flyTo({center: [200, 0], duration: 100});
+
+    simulate.touchstart(map.getCanvasContainer());
+    expect(map.isEasing()).toBe(true);
+
+    map.remove();
+});
+
+test('continues camera animation on resize', () => {
+    const map = createMap(),
+        container = map.getContainer();
+
+    map.flyTo({center: [200, 0], duration: 100});
+
+    Object.defineProperty(container, 'clientWidth', {value: 250});
+    Object.defineProperty(container, 'clientHeight', {value: 250});
+    map.resize();
+
+    expect(map.isMoving()).toBeTruthy();
+
+});
+
+test('stops camera animation on mousedown when interactive', () => {
+    const map = createMap({interactive: true});
+    map.flyTo({center: [200, 0], duration: 100});
+
+    simulate.mousedown(map.getCanvasContainer());
+    expect(map.isEasing()).toBe(false);
+
+    map.remove();
+});
+
+test('continues camera animation on mousedown when non-interactive', () => {
+    const map = createMap({interactive: false});
+    map.flyTo({center: [200, 0], duration: 100});
+
+    simulate.mousedown(map.getCanvasContainer());
+    expect(map.isEasing()).toBe(true);
+
+    map.remove();
+});

package/src/ui/map_tests/map_basic.test.ts

@@ -0,0 +1,223 @@
+import {Map, MapOptions} from '../map';
+import {createMap, beforeMapTest, createStyle, createStyleSource} from '../../util/test/util';
+import {Tile} from '../../source/tile';
+import {OverscaledTileID} from '../../source/tile_id';
+import {fixedLngLat} from '../../../test/unit/lib/fixed';
+import {RequestTransformFunction} from '../../util/request_manager';
+import {MapSourceDataEvent} from '../events';
+import {MessageType} from '../../util/actor_messages';
+
+beforeEach(() => {
+    beforeMapTest();
+    global.fetch = null;
+});
+
+describe('Map', () => {
+
+    test('version', () => {
+        const map = createMap({interactive: true, style: null});
+
+        expect(typeof map.version === 'string').toBeTruthy();
+
+        // Semver regex: https://gist.github.com/jhorsman/62eeea161a13b80e39f5249281e17c39
+        // Backslashes are doubled to escape them
+        const regexp = new RegExp('^([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?(?:\\+[0-9A-Za-z-]+)?$');
+        expect(regexp.test(map.version)).toBeTruthy();
+    });
+
+    test('constructor', () => {
+        const map = createMap({interactive: true, style: null});
+        expect(map.getContainer()).toBeTruthy();
+        expect(map.getStyle()).toBeUndefined();
+        expect(map.boxZoom.isEnabled()).toBeTruthy();
+        expect(map.doubleClickZoom.isEnabled()).toBeTruthy();
+        expect(map.dragPan.isEnabled()).toBeTruthy();
+        expect(map.dragRotate.isEnabled()).toBeTruthy();
+        expect(map.keyboard.isEnabled()).toBeTruthy();
+        expect(map.scrollZoom.isEnabled()).toBeTruthy();
+        expect(map.touchZoomRotate.isEnabled()).toBeTruthy();
+        expect(() => {
+            new Map({
+                container: 'anElementIdWhichDoesNotExistInTheDocument'
+            } as any as MapOptions);
+        }).toThrow(
+            new Error('Container \'anElementIdWhichDoesNotExistInTheDocument\' not found.')
+        );
+    });
+
+    test('bad map-specific token breaks map', () => {
+        const container = window.document.createElement('div');
+        Object.defineProperty(container, 'offsetWidth', {value: 512});
+        Object.defineProperty(container, 'offsetHeight', {value: 512});
+        createMap();
+        //t.error();
+    });
+
+    describe('#setTransformRequest', () => {
+        test('returns self', () => {
+            const transformRequest = (() => {}) as any as RequestTransformFunction;
+            const map = new Map({container: window.document.createElement('div')} as any as MapOptions);
+            expect(map.setTransformRequest(transformRequest)).toBe(map);
+            expect(map._requestManager._transformRequestFn).toBe(transformRequest);
+        });
+
+        test('can be called more than once', () => {
+            const map = createMap();
+
+            const transformRequest = (() => {}) as any as RequestTransformFunction;
+            map.setTransformRequest(transformRequest);
+            map.setTransformRequest(transformRequest);
+        });
+    });
+
+    describe('#is_Loaded', () => {
+
+        test('Map#isSourceLoaded', async () => {
+            const style = createStyle();
+            const map = createMap({style});
+
+            await map.once('load');
+            const promise = new Promise<void>((resolve) => {
+                map.on('data', (e) => {
+                    if (e.dataType === 'source' && e.sourceDataType === 'idle') {
+                        expect(map.isSourceLoaded('geojson')).toBe(true);
+                        resolve();
+                    }
+                });
+            });
+            map.addSource('geojson', createStyleSource());
+            expect(map.isSourceLoaded('geojson')).toBe(false);
+            await promise;
+        });
+
+        test('Map#isSourceLoaded (equivalent to event.isSourceLoaded)', async () => {
+            const style = createStyle();
+            const map = createMap({style});
+
+            await map.once('load');
+            const promise = new Promise<void>((resolve) => {
+                map.on('data', (e: MapSourceDataEvent) => {
+                    if (e.dataType === 'source' && 'source' in e) {
+                        expect(map.isSourceLoaded('geojson')).toBe(e.isSourceLoaded);
+                        if (e.sourceDataType === 'idle') {
+                            resolve();
+                        }
+                    }
+                });
+            });
+            map.addSource('geojson', createStyleSource());
+            expect(map.isSourceLoaded('geojson')).toBe(false);
+            await promise;
+        });
+
+        test('Map#isStyleLoaded', () => new Promise<void>(done => {
+            const style = createStyle();
+            const map = createMap({style});
+
+            expect(map.isStyleLoaded()).toBe(false);
+            map.on('load', () => {
+                expect(map.isStyleLoaded()).toBe(true);
+                done();
+            });
+        }));
+
+        test('Map#areTilesLoaded', () => new Promise<void>(done => {
+            const style = createStyle();
+            const map = createMap({style});
+            expect(map.areTilesLoaded()).toBe(true);
+            map.on('load', () => {
+                const fakeTileId = new OverscaledTileID(0, 0, 0, 0, 0);
+                map.addSource('geojson', createStyleSource());
+                map.style.sourceCaches.geojson._tiles[fakeTileId.key] = new Tile(fakeTileId, undefined);
+                expect(map.areTilesLoaded()).toBe(false);
+                map.style.sourceCaches.geojson._tiles[fakeTileId.key].state = 'loaded';
+                expect(map.areTilesLoaded()).toBe(true);
+                done();
+            });
+        }));
+    });
+
+    test('#remove', () => {
+        const map = createMap();
+        const spyWorkerPoolRelease = jest.spyOn(map.style.dispatcher.workerPool, 'release');
+        expect(map.getContainer().childNodes).toHaveLength(2);
+        map.remove();
+        expect(spyWorkerPoolRelease).toHaveBeenCalledTimes(1);
+        expect(map.getContainer().childNodes).toHaveLength(0);
+
+        // Cleanup
+        spyWorkerPoolRelease.mockClear();
+    });
+
+    test('#remove calls onRemove on added controls', () => {
+        const map = createMap();
+        const control = {
+            onRemove: jest.fn(),
+            onAdd(_) {
+                return window.document.createElement('div');
+            }
+        };
+        map.addControl(control);
+        map.remove();
+        expect(control.onRemove).toHaveBeenCalledTimes(1);
+    });
+
+    test('#remove calls onRemove on added controls before style is destroyed', () => new Promise<void>(done => {
+        const map = createMap();
+        let onRemoveCalled = 0;
+        let style;
+        const control = {
+            onRemove(map) {
+                onRemoveCalled++;
+                expect(map.getStyle()).toEqual(style);
+            },
+            onAdd(_) {
+                return window.document.createElement('div');
+            }
+        };
+
+        map.addControl(control);
+
+        map.on('style.load', () => {
+            style = map.getStyle();
+            map.remove();
+            expect(onRemoveCalled).toBe(1);
+            done();
+        });
+    }));
+
+    test('#remove broadcasts removeMap to worker', () => {
+        const map = createMap();
+        const _broadcastSpyOn = jest.spyOn(map.style.dispatcher, 'broadcast');
+        map.remove();
+        expect(_broadcastSpyOn).toHaveBeenCalledWith(MessageType.removeMap, undefined);
+    });
+
+    test('#project', () => {
+        const map = createMap();
+        expect(map.project([0, 0])).toEqual({x: 100, y: 100});
+    });
+
+    test('#unproject', () => {
+        const map = createMap();
+        expect(fixedLngLat(map.unproject([100, 100]))).toEqual({lng: 0, lat: 0});
+    });
+
+    describe('cooperativeGestures option', () => {
+        test('cooperativeGesture container element is hidden from a11y tree', () => {
+            const map = createMap({cooperativeGestures: true});
+            expect(map.getContainer().querySelector('.maplibregl-cooperative-gesture-screen').getAttribute('aria-hidden')).toBeTruthy();
+        });
+
+        test('cooperativeGesture container element is not available when cooperativeGestures not initialized', () => {
+            const map = createMap({cooperativeGestures: false});
+            expect(map.getContainer().querySelector('.maplibregl-cooperative-gesture-screen')).toBeFalsy();
+        });
+
+        test('cooperativeGesture container element is not available when cooperativeGestures disabled', () => {
+            const map = createMap({cooperativeGestures: true});
+            map.cooperativeGestures.disable();
+            expect(map.getContainer().querySelector('.maplibregl-cooperative-gesture-screen')).toBeFalsy();
+        });
+    });
+});

package/src/ui/map_tests/map_bounds.test.ts

@@ -0,0 +1,123 @@
+import {createMap, beforeMapTest} from '../../util/test/util';
+import {fixedLngLat, fixedNum} from '../../../test/unit/lib/fixed';
+import {LngLatBoundsLike} from '../../geo/lng_lat_bounds';
+
+beforeEach(() => {
+    beforeMapTest();
+    global.fetch = null;
+});
+
+test('initial bounds in constructor options', () => {
+    const container = window.document.createElement('div');
+    Object.defineProperty(container, 'offsetWidth', {value: 512});
+    Object.defineProperty(container, 'offsetHeight', {value: 512});
+
+    const bounds = [[-133, 16], [-68, 50]];
+    const map = createMap({container, bounds});
+
+    expect(fixedLngLat(map.getCenter(), 4)).toEqual({lng: -100.5, lat: 34.7171});
+    expect(fixedNum(map.getZoom(), 3)).toBe(2.113);
+});
+
+test('initial bounds options in constructor options', () => {
+    const bounds = [[-133, 16], [-68, 50]];
+
+    const map = (fitBoundsOptions) => {
+        const container = window.document.createElement('div');
+        Object.defineProperty(container, 'offsetWidth', {value: 512});
+        Object.defineProperty(container, 'offsetHeight', {value: 512});
+        return createMap({container, bounds, fitBoundsOptions});
+    };
+
+    const unpadded = map(undefined);
+    const padded = map({padding: 100});
+
+    expect(unpadded.getZoom() > padded.getZoom()).toBeTruthy();
+});
+
+describe('#getBounds', () => {
+
+    test('getBounds', () => {
+        const map = createMap({zoom: 0});
+        expect(parseFloat(map.getBounds().getCenter().lng.toFixed(10))).toBe(-0);
+        expect(parseFloat(map.getBounds().getCenter().lat.toFixed(10))).toBe(0);
+
+        expect(toFixed(map.getBounds().toArray())).toEqual(toFixed([
+            [-70.31249999999976, -57.326521225216965],
+            [70.31249999999977, 57.32652122521695]]));
+    });
+
+    test('rotated bounds', () => {
+        const map = createMap({zoom: 1, bearing: 45});
+        expect(
+            toFixed([[-49.718445552178764, -44.44541580601936], [49.7184455522, 44.445415806019355]])
+        ).toEqual(toFixed(map.getBounds().toArray()));
+
+        map.setBearing(135);
+        expect(
+            toFixed([[-49.718445552178764, -44.44541580601936], [49.7184455522, 44.445415806019355]])
+        ).toEqual(toFixed(map.getBounds().toArray()));
+
+    });
+
+    function toFixed(bounds) {
+        const n = 10;
+        return [
+            [normalizeFixed(bounds[0][0], n), normalizeFixed(bounds[0][1], n)],
+            [normalizeFixed(bounds[1][0], n), normalizeFixed(bounds[1][1], n)]
+        ];
+    }
+
+    function normalizeFixed(num, n) {
+        // workaround for "-0.0000000000" ≠ "0.0000000000"
+        return parseFloat(num.toFixed(n)).toFixed(n);
+    }
+});
+
+describe('#setMaxBounds', () => {
+    test('constrains map bounds', () => {
+        const map = createMap({zoom: 0});
+        map.setMaxBounds([[-130.4297, 50.0642], [-61.52344, 24.20688]]);
+        expect(
+            toFixed([[-130.4297000000, 7.0136641176], [-61.5234400000, 60.2398142283]])
+        ).toEqual(toFixed(map.getBounds().toArray()));
+    });
+
+    test('when no argument is passed, map bounds constraints are removed', () => {
+        const map = createMap({zoom: 0});
+        map.setMaxBounds([[-130.4297, 50.0642], [-61.52344, 24.20688]]);
+        expect(
+            toFixed([[-166.28906999999964, -27.6835270554], [-25.664070000000066, 73.8248206697]])
+        ).toEqual(toFixed(map.setMaxBounds(null).setZoom(0).getBounds().toArray()));
+    });
+
+    test('should not zoom out farther than bounds', () => {
+        const map = createMap();
+        map.setMaxBounds([[-130.4297, 50.0642], [-61.52344, 24.20688]]);
+        expect(map.setZoom(0).getZoom()).not.toBe(0);
+    });
+
+    function toFixed(bounds) {
+        const n = 9;
+        return [
+            [bounds[0][0].toFixed(n), bounds[0][1].toFixed(n)],
+            [bounds[1][0].toFixed(n), bounds[1][1].toFixed(n)]
+        ];
+    }
+
+});
+
+describe('#getMaxBounds', () => {
+    test('returns null when no bounds set', () => {
+        const map = createMap({zoom: 0});
+        expect(map.getMaxBounds()).toBeNull();
+    });
+
+    test('returns bounds', () => {
+        const map = createMap({zoom: 0});
+        const bounds = [[-130.4297, 50.0642], [-61.52344, 24.20688]] as LngLatBoundsLike;
+        map.setMaxBounds(bounds);
+        expect(map.getMaxBounds().toArray()).toEqual(bounds);
+    });
+
+});

package/src/ui/map_tests/map_calculate_camera_options.test.ts

@@ -0,0 +1,113 @@
+import {createMap, beforeMapTest} from '../../util/test/util';
+import {LngLat} from '../../geo/lng_lat';
+import {OverscaledTileID} from '../../source/tile_id';
+import {CameraOptions} from '../camera';
+import {Terrain} from '../../render/terrain';
+import {mercatorZfromAltitude} from '../../geo/mercator_coordinate';
+
+beforeEach(() => {
+    beforeMapTest();
+    global.fetch = null;
+});
+
+describe('#calculateCameraOptionsFromTo', () => {
+    // Choose initial zoom to avoid center being constrained by mercator latitude limits.
+    test('pitch 90 with terrain', () => {
+        const map = createMap();
+
+        const mockedGetElevation = jest.fn((_lngLat: LngLat, _zoom: number) => 111200);
+
+        const terrainStub = {} as Terrain;
+        terrainStub.getElevationForLngLatZoom = mockedGetElevation;
+        map.terrain = terrainStub;
+
+        // distance between lng x and lng x+1 is 111.2km at same lat
+        // altitude same as center elevation => 90° pitch
+        const cameraOptions: CameraOptions = map.calculateCameraOptionsFromTo(new LngLat(1, 0), 111200, new LngLat(0, 0));
+        expect(cameraOptions).toBeDefined();
+        expect(cameraOptions.pitch).toBeCloseTo(90);
+        expect(mockedGetElevation.mock.calls).toHaveLength(1);
+    });
+
+    test('pitch 153.435 with terrain', () => {
+        const map = createMap();
+
+        const mockedGetElevation = jest.fn((_lngLat: LngLat, _zoom: number) => 111200 * 3);
+
+        const terrainStub = {} as Terrain;
+        terrainStub.getElevationForLngLatZoom = mockedGetElevation;
+        map.terrain = terrainStub;
+        // distance between lng x and lng x+1 is 111.2km at same lat
+        // (elevation difference of cam and center) / 2 = grounddistance =>
+        // acos(111.2 / sqrt(111.2² + (111.2 * 2)²)) = acos(1/sqrt(5)) => 63.435 + 90 = 153.435
+        const cameraOptions: CameraOptions = map.calculateCameraOptionsFromTo(new LngLat(1, 0), 111200, new LngLat(0, 0));
+        expect(cameraOptions).toBeDefined();
+        expect(cameraOptions.pitch).toBeCloseTo(153.435);
+        expect(mockedGetElevation.mock.calls).toHaveLength(1);
+    });
+
+    test('pitch 63 with terrain', () => {
+        const map = createMap();
+
+        const mockedGetElevation = jest.fn((_lngLat: LngLat, _zoom: number) => 111200 / 2);
+
+        const terrainStub = {} as Terrain;
+        terrainStub.getElevationForLngLatZoom = mockedGetElevation;
+        map.terrain = terrainStub;
+
+        // distance between lng x and lng x+1 is 111.2km at same lat
+        // (elevation difference of cam and center) * 2 = grounddistance =>
+        // acos(111.2 / sqrt(111.2² + (111.2 * 0.5)²)) = acos(1/sqrt(1.25)) => 90 (looking down) - 26.565 = 63.435
+        const cameraOptions: CameraOptions = map.calculateCameraOptionsFromTo(new LngLat(0, 0), 111200, new LngLat(1, 0));
+        expect(cameraOptions).toBeDefined();
+        expect(cameraOptions.pitch).toBeCloseTo(63.435);
+        expect(mockedGetElevation.mock.calls).toHaveLength(1);
+    });
+
+    test('zoom distance 1000', () => {
+        const map = createMap();
+
+        const mockedGetElevation = jest.fn((_lngLat: LngLat, _zoom: number) => 1000);
+
+        const terrainStub = {} as Terrain;
+        terrainStub.getElevationForLngLatZoom = mockedGetElevation;
+        map.terrain = terrainStub;
+
+        const expectedZoom = Math.log2(map.transform.cameraToCenterDistance / mercatorZfromAltitude(1000, 0) / map.transform.tileSize);
+        const cameraOptions = map.calculateCameraOptionsFromTo(new LngLat(0, 0), 0, new LngLat(0, 0));
+
+        expect(cameraOptions).toBeDefined();
+        expect(cameraOptions.zoom).toBeCloseTo(expectedZoom);
+        expect(mockedGetElevation.mock.calls).toHaveLength(1);
+    });
+
+    test('don\'t call getElevation when altitude supplied', () => {
+        const map = createMap();
+
+        const mockedGetElevation = jest.fn((_tileID: OverscaledTileID, _x: number, _y: number, _extent?: number) => 0);
+
+        const terrainStub = {} as Terrain;
+        terrainStub.getElevation = mockedGetElevation;
+        map.terrain = terrainStub;
+
+        const cameraOptions = map.calculateCameraOptionsFromTo(new LngLat(0, 0), 0, new LngLat(0, 0), 1000);
+
+        expect(cameraOptions).toBeDefined();
+        expect(mockedGetElevation.mock.calls).toHaveLength(0);
+    });
+
+    test('don\'t call getElevation when altitude 0 supplied', () => {
+        const map = createMap();
+
+        const mockedGetElevation = jest.fn((_tileID: OverscaledTileID, _x: number, _y: number, _extent?: number) => 0);
+
+        const terrainStub = {} as Terrain;
+        terrainStub.getElevation = mockedGetElevation;
+        map.terrain = terrainStub;
+
+        const cameraOptions = map.calculateCameraOptionsFromTo(new LngLat(0, 0), 0, new LngLat(1, 0), 0);
+
+        expect(cameraOptions).toBeDefined();
+        expect(mockedGetElevation.mock.calls).toHaveLength(0);
+    });
+});

package/src/ui/map_tests/map_canvas.test.ts

@@ -0,0 +1,59 @@
+import {createMap, beforeMapTest} from '../../util/test/util';
+
+beforeEach(() => {
+    beforeMapTest();
+    global.fetch = null;
+});
+
+describe('Max Canvas Size option', () => {
+    test('maxCanvasSize width = height', () => {
+        const container = window.document.createElement('div');
+        Object.defineProperty(container, 'clientWidth', {value: 2048});
+        Object.defineProperty(container, 'clientHeight', {value: 2048});
+        jest.spyOn(WebGLRenderingContext.prototype, 'drawingBufferWidth', 'get').mockReturnValue(8192);
+        jest.spyOn(WebGLRenderingContext.prototype, 'drawingBufferHeight', 'get').mockReturnValue(8192);
+        const map = createMap({container, maxCanvasSize: [8192, 8192], pixelRatio: 5});
+        map.resize();
+        expect(map.getCanvas().width).toBe(8192);
+        expect(map.getCanvas().height).toBe(8192);
+    });
+
+    test('maxCanvasSize width != height', () => {
+        const container = window.document.createElement('div');
+        Object.defineProperty(container, 'clientWidth', {value: 1024});
+        Object.defineProperty(container, 'clientHeight', {value: 2048});
+        jest.spyOn(WebGLRenderingContext.prototype, 'drawingBufferWidth', 'get').mockReturnValue(8192);
+        jest.spyOn(WebGLRenderingContext.prototype, 'drawingBufferHeight', 'get').mockReturnValue(4096);
+        const map = createMap({container, maxCanvasSize: [8192, 4096], pixelRatio: 3});
+        map.resize();
+        expect(map.getCanvas().width).toBe(2048);
+        expect(map.getCanvas().height).toBe(4096);
+    });
+
+    test('maxCanvasSize below clientWidth and clientHeight', () => {
+        const container = window.document.createElement('div');
+        Object.defineProperty(container, 'clientWidth', {value: 12834});
+        Object.defineProperty(container, 'clientHeight', {value: 9000});
+        jest.spyOn(WebGLRenderingContext.prototype, 'drawingBufferWidth', 'get').mockReturnValue(4096);
+        jest.spyOn(WebGLRenderingContext.prototype, 'drawingBufferHeight', 'get').mockReturnValue(8192);
+        const map = createMap({container, maxCanvasSize: [4096, 8192], pixelRatio: 1});
+        map.resize();
+        expect(map.getCanvas().width).toBe(4096);
+        expect(map.getCanvas().height).toBe(2872);
+    });
+
+    test('maxCanvasSize with setPixelRatio', () => {
+        const container = window.document.createElement('div');
+        Object.defineProperty(container, 'clientWidth', {value: 2048});
+        Object.defineProperty(container, 'clientHeight', {value: 2048});
+        jest.spyOn(WebGLRenderingContext.prototype, 'drawingBufferWidth', 'get').mockReturnValue(3072);
+        jest.spyOn(WebGLRenderingContext.prototype, 'drawingBufferHeight', 'get').mockReturnValue(3072);
+        const map = createMap({container, maxCanvasSize: [3072, 3072], pixelRatio: 1.25});
+        map.resize();
+        expect(map.getCanvas().width).toBe(2560);
+        expect(map.getCanvas().height).toBe(2560);
+        map.setPixelRatio(2);
+        expect(map.getCanvas().width).toBe(3072);
+        expect(map.getCanvas().height).toBe(3072);
+    });
+});

package/src/ui/map_tests/map_control.test.ts

@@ -0,0 +1,61 @@
+import {createMap, beforeMapTest} from '../../util/test/util';
+import {IControl} from '../control/control';
+
+beforeEach(() => {
+    beforeMapTest();
+    global.fetch = null;
+});
+
+test('#addControl', () => {
+    const map = createMap();
+    const control = {
+        onAdd(_) {
+            expect(map).toBe(_);
+            return window.document.createElement('div');
+        }
+    } as any as IControl;
+    map.addControl(control);
+    expect(map._controls[0]).toBe(control);
+});
+
+test('#removeControl errors on invalid arguments', () => {
+    const map = createMap();
+    const control = {} as any as IControl;
+    const stub = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+    map.addControl(control);
+    map.removeControl(control);
+    expect(stub).toHaveBeenCalledTimes(2);
+
+});
+
+test('#removeControl', () => {
+    const map = createMap();
+    const control = {
+        onAdd() {
+            return window.document.createElement('div');
+        },
+        onRemove(_) {
+            expect(map).toBe(_);
+        }
+    };
+    map.addControl(control);
+    map.removeControl(control);
+    expect(map._controls).toHaveLength(0);
+
+});
+
+test('#hasControl', () => {
+    const map = createMap();
+    function Ctrl() {}
+    Ctrl.prototype = {
+        onAdd(_) {
+            return window.document.createElement('div');
+        }
+    };
+
+    const control = new Ctrl();
+    expect(map.hasControl(control)).toBe(false);
+    map.addControl(control);
+    expect(map.hasControl(control)).toBe(true);
+});

package/src/ui/map_tests/map_disable_handlers.test.ts

@@ -0,0 +1,38 @@
+import {createMap, beforeMapTest} from '../../util/test/util';
+
+beforeEach(() => {
+    beforeMapTest();
+    global.fetch = null;
+});
+
+test('disable all handlers', () => {
+    const map = createMap({interactive: false});
+
+    expect(map.boxZoom.isEnabled()).toBeFalsy();
+    expect(map.doubleClickZoom.isEnabled()).toBeFalsy();
+    expect(map.dragPan.isEnabled()).toBeFalsy();
+    expect(map.dragRotate.isEnabled()).toBeFalsy();
+    expect(map.keyboard.isEnabled()).toBeFalsy();
+    expect(map.scrollZoom.isEnabled()).toBeFalsy();
+    expect(map.touchZoomRotate.isEnabled()).toBeFalsy();
+});
+
+const handlerNames = [
+    'scrollZoom',
+    'boxZoom',
+    'dragRotate',
+    'dragPan',
+    'keyboard',
+    'doubleClickZoom',
+    'touchZoomRotate'
+];
+handlerNames.forEach((handlerName) => {
+    test(`disable "${handlerName}" handler`, () => {
+        const options = {};
+        options[handlerName] = false;
+        const map = createMap(options);
+
+        expect(map[handlerName].isEnabled()).toBeFalsy();
+
+    });
+});