Skip to content

Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.

[chore] raster tile layer tests (#3152)

Igor Dykhta1a93a2b99394
diff --git a/test/browser/layer-tests/index.js b/test/browser/layer-tests/index.js
index 9328da95b..94d6e64aa 100644
--- a/test/browser/layer-tests/index.js
+++ b/test/browser/layer-tests/index.js
@@ -12,6 +12,7 @@ import './hexagon-layer-specs';
import './icon-layer-specs';
import './line-layer-specs';
import './point-layer-specs';
+import './raster-tile-layer-specs';
import './scenegraph-layer-specs';
import './trip-layer-specs';
import './s2-geometry-layer-specs';
diff --git a/test/browser/layer-tests/raster-tile-layer-specs.js b/test/browser/layer-tests/raster-tile-layer-specs.js
new file mode 100644
index 000000000..5a83f65d8
--- /dev/null
+++ b/test/browser/layer-tests/raster-tile-layer-specs.js
@@ -0,0 +1,326 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import test from 'tape';
+import {KeplerGlLayers} from '@kepler.gl/layers';
+import {testCreateCases} from 'test/helpers/layer-utils';
+
+const {RasterTileLayer} = KeplerGlLayers;
+
+// Mock data for raster tests
+const MOCK_STAC_METADATA = {
+ type: 'Feature',
+ stac_version: '1.0.0',
+ stac_extensions: ['https://stac-extensions.github.io/eo/v1.0.0/schema.json'],
+ assets: {
+ red: {
+ href: 'https://example.com/red.tif',
+ type: 'image/tiff',
+ 'eo:bands': [{name: 'red', common_name: 'red'}]
+ },
+ green: {
+ href: 'https://example.com/green.tif',
+ type: 'image/tiff',
+ 'eo:bands': [{name: 'green', common_name: 'green'}]
+ },
+ blue: {
+ href: 'https://example.com/blue.tif',
+ type: 'image/tiff',
+ 'eo:bands': [{name: 'blue', common_name: 'blue'}]
+ }
+ },
+ bounds: [-122.5, 37.5, -122.0, 38.0],
+ properties: {
+ datetime: '2023-01-01T00:00:00Z'
+ }
+};
+
+const MOCK_PMTILES_METADATA = {
+ metadataUrl: 'https://example.com/raster.pmtiles',
+ pmtilesType: 'raster',
+ minZoom: 0,
+ maxZoom: 18,
+ bounds: [-122.5, 37.5, -122.0, 38.0]
+};
+
+const MOCK_STAC_DATASET = {
+ type: 'raster-tile',
+ metadata: MOCK_STAC_METADATA,
+ label: 'Test STAC Dataset'
+};
+
+const MOCK_PMTILES_DATASET = {
+ type: 'raster-tile',
+ metadata: MOCK_PMTILES_METADATA,
+ label: 'Test PMTiles Dataset'
+};
+
+// Shared render options for tests
+const createRenderOpts = (dataset, mapState = {dragRotate: false, bearing: 0, pitch: 0}) => ({
+ data: {
+ dataset,
+ tileSource: dataset.metadata.pmtilesType ? {getTileData: () => Promise.resolve(null)} : null
+ },
+ mapState,
+ interactionConfig: {tooltip: {enabled: true}}
+});
+
+test('#RasterTileLayer -> constructor and basic properties', t => {
+ const TEST_CASES = {
+ CREATE: [
+ {
+ props: {
+ dataId: 'raster-test-data',
+ isVisible: true,
+ label: 'test raster layer'
+ },
+ test: layer => {
+ t.equal(layer.config.dataId, 'raster-test-data', 'dataId should be correct');
+ t.equal(layer.type, 'rasterTile', 'type should be rasterTile');
+ t.equal(layer.isAggregated, false, 'should not be aggregated');
+ t.equal(layer.config.label, 'test raster layer', 'label should be correct');
+ t.equal(layer.config.isVisible, true, 'should be visible');
+ t.equal(layer.config.visConfig.opacity, 1, 'should have default opacity');
+ t.equal(
+ layer.config.visConfig.enableTerrain,
+ true,
+ 'should have terrain enabled by default'
+ );
+ t.equal(
+ layer.config.visConfig.enableTerrainTopView,
+ false,
+ 'should have terrain top view disabled'
+ );
+ t.equal(layer.requireData, true, 'should require data');
+ t.deepEqual(
+ layer.supportedDatasetTypes,
+ ['raster-tile'],
+ 'should support raster-tile dataset type'
+ );
+ t.equal(layer.name, 'Raster Tile', 'should have correct layer name');
+ t.ok(typeof layer.layerIcon === 'function', 'should have layerIcon function');
+ t.ok(layer.isValidToSave(), 'should be valid to save');
+ }
+ }
+ ]
+ };
+
+ testCreateCases(t, RasterTileLayer, TEST_CASES.CREATE);
+ t.end();
+});
+
+test('#RasterTileLayer -> data formatting and rendering', t => {
+ const stacLayer = new RasterTileLayer({id: 'stac-layer', dataId: 'stac-data'});
+ const pmtilesLayer = new RasterTileLayer({id: 'pmtiles-layer', dataId: 'pmtiles-data'});
+
+ // Test STAC data formatting
+ const stacLayerData = stacLayer.formatLayerData({'stac-data': MOCK_STAC_DATASET});
+ t.ok(stacLayerData, 'should return STAC layer data');
+ t.equal(stacLayerData.dataset, MOCK_STAC_DATASET, 'should have correct STAC dataset');
+ t.equal(stacLayerData.tileSource, null, 'should have null tileSource for STAC');
+
+ // Test PMTiles data formatting
+ const pmtilesLayerData = pmtilesLayer.formatLayerData({'pmtiles-data': MOCK_PMTILES_DATASET});
+ t.ok(pmtilesLayerData, 'should return PMTiles layer data');
+ t.equal(pmtilesLayerData.dataset, MOCK_PMTILES_DATASET, 'should have correct PMTiles dataset');
+ t.ok(pmtilesLayerData.tileSource, 'should create tileSource for PMTiles');
+
+ // Test rendering
+ const stacLayers = stacLayer.renderLayer(createRenderOpts(MOCK_STAC_DATASET));
+ const pmtilesLayers = pmtilesLayer.renderLayer(createRenderOpts(MOCK_PMTILES_DATASET));
+
+ t.ok(Array.isArray(stacLayers), 'should return array for STAC');
+ t.ok(Array.isArray(pmtilesLayers), 'should return array for PMTiles');
+ t.equal(pmtilesLayers.length, 1, 'should render one deck layer for PMTiles');
+
+ t.end();
+});
+
+test('#RasterTileLayer -> configuration and visual settings', t => {
+ const layer = new RasterTileLayer({id: 'test-layer', dataId: 'stac-data'});
+
+ // Test layer config updates
+ layer.updateLayerConfig({isVisible: false, label: 'Updated Layer'});
+ t.equal(layer.config.isVisible, false, 'should update visibility');
+ t.equal(layer.config.label, 'Updated Layer', 'should update label');
+
+ // Test visual config updates
+ layer.updateLayerVisConfig({
+ opacity: 0.7,
+ enableTerrain: false,
+ enableTerrainTopView: true
+ });
+ t.equal(layer.config.visConfig.opacity, 0.7, 'should update opacity');
+ t.equal(layer.config.visConfig.enableTerrain, false, 'should update terrain');
+ t.equal(layer.config.visConfig.enableTerrainTopView, true, 'should update terrain top view');
+
+ // Test shouldRenderLayer
+ t.notOk(layer.shouldRenderLayer(), 'should not render when not visible');
+ layer.updateLayerConfig({isVisible: true});
+ t.ok(layer.shouldRenderLayer(), 'should render when visible');
+
+ t.end();
+});
+
+test('#RasterTileLayer -> metadata handling', t => {
+ const layer = new RasterTileLayer({id: 'test-layer', dataId: 'stac-data'});
+
+ // Test with non-raster dataset (should not throw)
+ t.doesNotThrow(() => {
+ layer.updateLayerMeta({type: 'csv'});
+ }, 'should handle non-raster dataset');
+
+ // Test with STAC and PMTiles datasets (should not throw)
+ t.doesNotThrow(() => {
+ layer.updateLayerMeta(MOCK_STAC_DATASET);
+ layer.updateLayerMeta(MOCK_PMTILES_DATASET);
+ }, 'should handle STAC and PMTiles datasets');
+
+ t.end();
+});
+
+test('#RasterTileLayer -> pixel value tracking', t => {
+ const layer = new RasterTileLayer({id: 'test-layer', dataId: 'stac-data'});
+
+ // Test initial state
+ t.equal(layer.minViewportPixelValue, Infinity, 'should have Infinity as initial min');
+ t.equal(layer.maxViewportPixelValue, -Infinity, 'should have -Infinity as initial max');
+
+ // Test with valid tiles
+ const mockTiles = [
+ {data: {minPixelValue: 25, maxPixelValue: 100}},
+ {data: {minPixelValue: 10, maxPixelValue: 150}}
+ ];
+ layer.updateMinMaxPixelValue(mockTiles);
+ t.equal(layer.minViewportPixelValue, 10, 'should set correct min pixel value');
+ t.equal(layer.maxViewportPixelValue, 150, 'should set correct max pixel value');
+
+ // Test with empty tiles
+ layer.updateMinMaxPixelValue([]);
+ t.equal(layer.minViewportPixelValue, Infinity, 'should reset to Infinity for empty tiles');
+ t.equal(layer.maxViewportPixelValue, -Infinity, 'should reset to -Infinity for empty tiles');
+
+ // Test with null data
+ layer.updateMinMaxPixelValue([
+ {data: null},
+ {data: {minPixelValue: 30, maxPixelValue: 120}},
+ null
+ ]);
+ t.equal(layer.minViewportPixelValue, 30, 'should handle null data gracefully');
+ t.equal(layer.maxViewportPixelValue, 120, 'should handle null data gracefully');
+
+ t.end();
+});
+
+test('#RasterTileLayer -> findDefaultLayerProps', t => {
+ // Test with raster dataset
+ const result = RasterTileLayer.findDefaultLayerProps(MOCK_STAC_DATASET);
+ t.ok(result.props, 'should return props object');
+ t.equal(result.props.length, 1, 'should return one layer prop');
+ t.equal(result.props[0].label, 'Test STAC Dataset', 'should use dataset label');
+ t.equal(result.props[0].isVisible, true, 'should be visible by default');
+
+ // Test with non-raster dataset
+ const nonRasterResult = RasterTileLayer.findDefaultLayerProps({type: 'csv'});
+ t.deepEqual(nonRasterResult.props, [], 'should return empty props for non-raster dataset');
+
+ t.end();
+});
+
+test('#RasterTileLayer -> edge cases and error handling', t => {
+ const layer = new RasterTileLayer({id: 'test-layer', dataId: 'stac-data'});
+
+ // Test formatLayerData with missing dataset
+ t.throws(() => {
+ layer.formatLayerData({});
+ }, 'should throw error when dataset missing');
+
+ // Test layer without dataId
+ const layerWithoutDataId = new RasterTileLayer({id: 'test-layer'});
+ layerWithoutDataId.config.dataId = undefined;
+ const layerData = layerWithoutDataId.formatLayerData({});
+ t.deepEqual(layerData, {}, 'should return empty object when no dataId');
+
+ // Test rendering with invalid/missing data
+ const invalidLayers = layer.renderLayer(createRenderOpts({metadata: {type: 'Feature'}}));
+ t.deepEqual(invalidLayers, [], 'should return empty array for invalid STAC data');
+
+ const noDataLayers = layer.renderLayer({...createRenderOpts(MOCK_STAC_DATASET), data: null});
+ t.deepEqual(noDataLayers, [], 'should return empty array when no data');
+
+ // Test malformed metadata (should not throw)
+ t.doesNotThrow(() => {
+ layer.updateLayerMeta({type: 'raster-tile', metadata: {type: 'Feature'}});
+ layer.updateLayerMeta({type: 'raster-tile', metadata: {pmtilesType: 'raster'}});
+ }, 'should handle malformed metadata gracefully');
+
+ t.end();
+});
+
+test('#RasterTileLayer -> data type variations', t => {
+ const layer = new RasterTileLayer({id: 'test-layer', dataId: 'stac-data'});
+
+ // Test multi-asset STAC
+ const multiAssetStac = {
+ type: 'raster-tile',
+ metadata: {
+ ...MOCK_STAC_METADATA,
+ assets: {
+ ...MOCK_STAC_METADATA.assets,
+ nir: {
+ href: 'https://example.com/nir.tif',
+ type: 'image/tiff',
+ 'eo:bands': [{name: 'nir', common_name: 'nir'}]
+ }
+ }
+ }
+ };
+ const multiAssetData = layer.formatLayerData({'stac-data': multiAssetStac});
+ t.ok(multiAssetData, 'should handle multi-asset STAC data');
+
+ // Test single asset STAC
+ const singleAssetStac = {
+ type: 'raster-tile',
+ metadata: {
+ type: 'Feature',
+ stac_version: '1.0.0',
+ assets: {
+ visual: {href: 'https://example.com/visual.tif', type: 'image/tiff'}
+ },
+ bounds: [-122.5, 37.5, -122.0, 38.0]
+ }
+ };
+ const singleAssetData = layer.formatLayerData({'stac-data': singleAssetStac});
+ t.ok(singleAssetData, 'should handle single-asset STAC data');
+
+ t.end();
+});
+
+test('#RasterTileLayer -> layer serialization', t => {
+ const layer = new RasterTileLayer({
+ id: 'test-layer',
+ dataId: 'stac-data',
+ label: 'Test Raster Layer'
+ });
+
+ // Configure layer
+ layer.updateLayerVisConfig({
+ opacity: 0.8,
+ enableTerrain: false,
+ colorRange: {
+ colors: ['#FF0000', '#00FF00'],
+ colorLegends: {water: [0, 0, 255]}
+ }
+ });
+
+ // Test layer properties
+ const config = layer.config;
+ t.ok(layer.id, 'should have id on layer');
+ t.ok(config.dataId, 'should have dataId in config');
+ t.ok(config.label, 'should have label in config');
+ t.equal(config.visConfig.opacity, 0.8, 'should preserve opacity');
+ t.equal(config.visConfig.enableTerrain, false, 'should preserve terrain setting');
+ t.ok(layer.isValidToSave(), 'should be valid to save');
+
+ t.end();
+});