Interactive interface for browsing global, full-resolution satellite imagery
import mapLayerBuilder from './layerbuilder';
jest.mock('ol/tilegrid/WMTS', () => jest.fn().mockImplementation(() => ({})));
jest.mock('ol/source/WMTS', () => jest.fn().mockImplementation(() => ({})));
jest.mock('ol/source/TileWMS', () => jest.fn().mockImplementation(() => ({})));
jest.mock('ol/source/XYZ', () => jest.fn().mockImplementation(() => ({})));
jest.mock('ol/source/ImageTile', () => jest.fn().mockImplementation(() => ({})));
jest.mock('ol/layer/Group', () =>
jest.fn().mockImplementation(({ layers } = {}) => ({
wv: null,
layers,
getLayers: () => ({ getArray: () => layers || [] }),
getLayersArray: () => layers || [],
setOpacity: jest.fn(),
setVisible: jest.fn(),
})),
);
jest.mock('ol/layer/Tile', () =>
jest.fn().mockImplementation(() => ({
wv: null,
setOpacity: jest.fn(),
setVisible: jest.fn(),
setExtent: jest.fn(),
getLayersArray: () => [],
isWMS: false,
})),
);
jest.mock('ol/proj', () => ({
get: jest.fn().mockReturnValue({
getExtent: jest.fn().mockReturnValue([-180, -90, 180, 90]),
}),
}));
jest.mock('ol/tilegrid', () => ({
TileGrid: jest.fn().mockImplementation(() => ({})),
createXYZ: jest.fn().mockReturnValue({
getResolutions: jest.fn().mockReturnValue([1, 0.5]),
getTileSize: jest.fn().mockReturnValue([512, 512]),
}),
}));
jest.mock('ol/format/MVT', () => jest.fn().mockImplementation(() => ({})));
jest.mock('ol/format/GeoJSON', () =>
jest.fn().mockImplementation(() => ({
readFeatures: jest.fn().mockReturnValue([]),
})),
);
jest.mock('ol/source/VectorTile', () => jest.fn().mockImplementation(() => ({})));
jest.mock('ol/layer/Vector', () =>
jest.fn().mockImplementation(() => ({
wv: null,
setOpacity: jest.fn(),
setVisible: jest.fn(),
getLayersArray: () => [],
vectorData: null,
isVector: false,
})),
);
jest.mock('ol/source/Vector', () =>
jest.fn().mockImplementation(() => ({
getFormat: jest.fn().mockReturnValue({
readFeatures: jest.fn().mockReturnValue([]),
}),
addFeatures: jest.fn(),
})),
);
jest.mock('ol/layer/VectorTile', () =>
jest.fn().mockImplementation(() => ({
wv: null,
setOpacity: jest.fn(),
setVisible: jest.fn(),
getLayersArray: () => [],
})),
);
jest.mock('ol/style', () => ({
Circle: jest.fn().mockImplementation(() => ({})),
Fill: jest.fn().mockImplementation(() => ({})),
Stroke: jest.fn().mockImplementation(() => ({})),
Style: jest.fn().mockImplementation(() => ({})),
}));
jest.mock('ol/layer/Image', () =>
jest.fn().mockImplementation(() => ({
wv: null,
setOpacity: jest.fn(),
setVisible: jest.fn(),
getLayersArray: () => [],
})),
);
jest.mock('ol/source/ImageStatic', () => jest.fn().mockImplementation(() => ({})));
jest.mock('lodash/merge', () => jest.requireActual('lodash/merge'));
jest.mock('lodash/each', () => jest.requireActual('lodash/each'));
jest.mock('lodash/get', () => jest.requireActual('lodash/get'));
jest.mock('lodash/cloneDeep', () => jest.requireActual('lodash/cloneDeep'));
jest.mock('ol-mapbox-style', () => ({
applyBackground: jest.fn().mockResolvedValue(undefined),
applyStyle: jest.fn().mockResolvedValue(undefined),
}));
jest.mock('../util/util', () => ({
__esModule: true,
default: {
toISOStringSeconds: jest.fn((date) => (date ? date.toISOString() : '')),
roundTimeOneMinute: jest.fn((date) => date),
clearTimeUTC: jest.fn((date) => {
if (!date) return date;
const d = new Date(date);
d.setUTCHours(0, 0, 0, 0);
return d;
}),
dateAdd: jest.fn((date, unit, amount) => {
const d = new Date(date);
if (unit === 'day') d.setDate(d.getDate() + amount);
if (unit === 'month') d.setMonth(d.getMonth() + amount);
if (unit === 'year') d.setFullYear(d.getFullYear() + amount);
return d;
}),
},
}));
jest.mock('../util/cmr', () => ({
buildGranulesUrl: jest.fn().mockReturnValue('http://cmr.example.com/granules'),
cmrSearchAfterFetch: jest.fn().mockResolvedValue({ entries: [] }),
}));
jest.mock('../ol/lookupimagetile', () => jest.fn().mockReturnValue(jest.fn()));
jest.mock('./granule/granule-layer-builder', () =>
jest.fn().mockReturnValue({
getGranuleLayer: jest.fn().mockResolvedValue({
wv: null,
setOpacity: jest.fn(),
setVisible: jest.fn(),
getLayersArray: () => [],
}),
}),
);
jest.mock('./util', () => ({
createVectorUrl: jest.fn().mockReturnValue('?TIME=2021-01-01'),
getGeographicResolutionWMS: jest.fn().mockReturnValue([1, 0.5, 0.25]),
mergeBreakpointLayerAttributes: jest.fn((def) => def),
}));
jest.mock('../modules/layers/util', () => ({
datesInDateRanges: jest.fn().mockReturnValue([new Date('2021-01-01')]),
prevDateInDateRange: jest.fn().mockReturnValue({
next: new Date('2021-01-02'),
previous: new Date('2020-12-31'),
}),
nearestInterval: jest.fn().mockReturnValue(new Date('2021-01-01')),
fetchSubdailyDateRanges: jest.fn(),
}));
jest.mock('../modules/date/selectors', () => ({
getSelectedDate: jest.fn().mockReturnValue('2021-01-01T00:00:00.000Z'),
}));
jest.mock('../modules/palettes/selectors', () => ({
isActive: jest.fn().mockReturnValue(false),
getKey: jest.fn().mockReturnValue('palette-key'),
getLookup: jest.fn().mockReturnValue({}),
}));
jest.mock('../modules/vector-styles/selectors', () => ({
isActive: jest.fn().mockReturnValue(false),
getKey: jest.fn().mockReturnValue('vector-style-key'),
applyStyle: jest.fn(),
}));
jest.mock('../modules/map/constants', () => ({
LEFT_WING_EXTENT: [-250, -90, -180, 90],
RIGHT_WING_EXTENT: [180, -90, 250, 90],
LEFT_WING_ORIGIN: [-250, 90],
RIGHT_WING_ORIGIN: [180, 90],
CENTER_MAP_ORIGIN: [0, 90],
}));
const buildMockLayer = () => ({
wv: null,
setOpacity: jest.fn(),
setVisible: jest.fn(),
setExtent: jest.fn(),
getLayersArray: () => [],
});
const buildMockState = (overrides = {}) => ({
proj: {
id: 'geographic',
selected: {
id: 'geographic',
crs: 'EPSG:4326',
maxExtent: [-180, -90, 180, 90],
resolutions: [1, 0.5, 0.25],
},
},
date: {
selected: new Date('2021-01-01T00:00:00.000Z'),
selectedB: new Date('2021-01-02T00:00:00.000Z'),
appNow: new Date('2021-01-01T00:00:00.000Z'),
},
compare: {
activeString: 'active',
},
ui: {
isKioskModeActive: false,
displayStaticMap: false,
},
layers: {
active: { activeTab: 'layers' },
activeB: { activeTab: 'layers' },
},
animation: {
isPlaying: false,
},
palettes: {
custom: {},
rendered: {},
},
config: {
features: {
describeDomains: { url: 'https://gibs.earthdata.nasa.gov' },
cmr: { url: 'https://cmr.earthdata.nasa.gov' },
},
},
sidebar: {
activeTab: 'layers',
},
...overrides,
});
const buildConfig = (sourceOverrides = {}) => ({
sources: {
'test-source': {
url: 'https://gibs.example.com',
matrixSets: {
EPSG4326_250m: {
id: 'EPSG4326_250m',
resolutions: [0.5, 0.25],
tileSize: [512, 512],
tileMatrices: [
{ matrixWidth: 2, matrixHeight: 1 },
{ matrixWidth: 4, matrixHeight: 2 },
],
},
},
},
'EUMETSAT:wms': {
url: 'https://eumetsat.example.com',
matrixSets: {},
},
AERONET: {
url: 'https://aeronet.example.com',
matrixSets: {},
},
'test-xyz': {
url: 'https://xyz.example.com',
},
'test-esri': {
url: 'https://esri.example.com',
},
'test-vector': {
url: 'https://vector.example.com',
matrixSets: {
testMatrixSet: {
resolutions: [0.5, 0.25],
tileSize: [512, 512],
tileMatrices: [[2, 1], [4, 2]],
},
},
},
'test-indexed': {
url: 'https://indexed.example.com',
matrixSets: {
testMatrixSet: {
resolutions: [0.5, 0.25],
tileSize: [512, 512],
},
},
},
...sourceOverrides,
},
});
const buildCache = () => ({
getItem: jest.fn().mockReturnValue(null),
setItem: jest.fn(),
});
const buildStore = (stateOverrides = {}) => ({
getState: jest.fn().mockReturnValue(buildMockState(stateOverrides)),
});
const buildDef = (overrides = {}) => ({
id: 'test-layer',
type: 'wmts',
source: 'test-source',
matrixSet: 'EPSG4326_250m',
format: 'image/jpeg',
period: 'daily',
projections: {
geographic: {},
},
opacity: 1,
wrapadjacentdays: false,
wrapX: false,
...overrides,
});
const buildOptions = (overrides = {}) => ({
group: 'active',
date: new Date('2021-01-01T00:00:00.000Z'),
...overrides,
});
describe('mapLayerBuilder', () => {
let config;
let cache;
let store;
let builder;
beforeEach(() => {
jest.clearAllMocks();
config = buildConfig();
cache = buildCache();
store = buildStore();
builder = mapLayerBuilder(config, cache, store);
});
describe('createLayer - wmts type', () => {
it('returns a layer for a wmts def', async () => {
const layer = await builder.createLayer(buildDef(), buildOptions());
expect(layer).toBeDefined();
});
it('sets layer visibility to false after creation', async () => {
const layer = await builder.createLayer(buildDef(), buildOptions());
expect(layer.setVisible).toHaveBeenCalledWith(false);
});
it('sets item in cache after creation', async () => {
await builder.createLayer(buildDef(), buildOptions());
expect(cache.setItem).toHaveBeenCalled();
});
it('returns cached layer when available', async () => {
const cached = buildMockLayer();
cache.getItem.mockReturnValue(cached);
const layer = await builder.createLayer(buildDef(), buildOptions());
expect(layer).toBe(cached);
expect(cache.setItem).not.toHaveBeenCalled();
});
it('sets opacity from cached layer', async () => {
const cached = buildMockLayer();
cache.getItem.mockReturnValue(cached);
await builder.createLayer(buildDef({ opacity: 0.5 }), buildOptions());
expect(cached.setOpacity).toHaveBeenCalledWith(0.5);
});
it('defaults opacity to 1.0 when opacity is undefined', async () => {
const cached = buildMockLayer();
cache.getItem.mockReturnValue(cached);
await builder.createLayer(buildDef({ opacity: undefined }), buildOptions());
expect(cached.setOpacity).toHaveBeenCalledWith(1.0);
});
it('sets opacity on breakPointLayer sublayers when using cache', async () => {
const sublayer = buildMockLayer();
const cached = { ...buildMockLayer(), getLayersArray: () => [sublayer] };
cache.getItem.mockReturnValue(cached);
const def = buildDef({
opacity: 0.7,
breakPointLayer: { projections: { geographic: {} }, breakPointType: 'max' },
});
await builder.createLayer(def, buildOptions());
expect(sublayer.setOpacity).toHaveBeenCalledWith(0.7);
});
it('uses options.group activeB', async () => {
const layer = await builder.createLayer(buildDef(), buildOptions({ group: 'activeB' }));
expect(layer).toBeDefined();
});
it('falls back to activeString when options.group is not set', async () => {
const layer = await builder.createLayer(buildDef(), buildOptions({ group: undefined }));
expect(layer).toBeDefined();
});
it('creates wrapped layer group for geographic proj with wrapadjacentdays', async () => {
const OlLayerGroup = require('ol/layer/Group');
await builder.createLayer(buildDef({ wrapadjacentdays: true }), buildOptions());
expect(OlLayerGroup).toHaveBeenCalled();
});
it('does not wrap in non-geographic projection', async () => {
const OlLayerGroup = require('ol/layer/Group');
store = buildStore({
proj: {
id: 'arctic',
selected: { id: 'arctic', crs: 'EPSG:3413', maxExtent: [-4194304, -4194304, 4194304, 4194304], resolutions: [1, 0.5] },
},
layers: { active: { activeTab: 'layers' }, activeB: { activeTab: 'layers' } },
});
builder = mapLayerBuilder(config, cache, store);
OlLayerGroup.mockClear();
const def = buildDef({ wrapadjacentdays: true, projections: { arctic: {} } });
await builder.createLayer(def, buildOptions());
expect(OlLayerGroup).not.toHaveBeenCalled();
});
it('handles wrapX flag on def', async () => {
const layer = await builder.createLayer(buildDef({ wrapX: true }), buildOptions());
expect(layer).toBeDefined();
});
});
describe('createLayer - wms type', () => {
it('returns a layer for a wms def', async () => {
const layer = await builder.createLayer(
buildDef({ type: 'wms', format: 'image/png', tileSize: [512, 512] }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('throws error when wms source is invalid', async () => {
await expect(
builder.createLayer(buildDef({ type: 'wms', source: 'nonexistent-source' }), buildOptions()),
).rejects.toThrow('Invalid source');
});
it('handles geographic proj resolution override for WMS', async () => {
const { getGeographicResolutionWMS } = require('./util');
await builder.createLayer(
buildDef({ type: 'wms', format: 'image/png', tileSize: [512, 512] }),
buildOptions(),
);
expect(getGeographicResolutionWMS).toHaveBeenCalled();
});
it('handles EUMETSAT wms source with version 1.3.0', async () => {
const layer = await builder.createLayer(
buildDef({ type: 'wms', source: 'EUMETSAT:wms', format: 'image/png', tileSize: [512, 512] }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles wms with styles property', async () => {
const layer = await builder.createLayer(
buildDef({ type: 'wms', format: 'image/png', styles: 'my-style' }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles wms with wrapadjacentdays (covers day=1 and day=-1 branches)', async () => {
const OlLayerGroup = require('ol/layer/Group');
await builder.createLayer(
buildDef({ type: 'wms', format: 'image/png', wrapadjacentdays: true }),
buildOptions(),
);
expect(OlLayerGroup).toHaveBeenCalled();
});
it('handles wms with palette active', async () => {
const { isActive, getLookup } = require('../modules/palettes/selectors');
isActive.mockReturnValue(true);
getLookup.mockReturnValue({ 0: { r: 255, g: 0, b: 0 } });
const layer = await builder.createLayer(
buildDef({ type: 'wms', format: 'image/png' }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles wms with resolutionBreakPoint', async () => {
const layer = await builder.createLayer(
buildDef({
type: 'wms',
format: 'image/png',
breakPointLayer: { projections: { geographic: { resolutionBreakPoint: 500 } } },
}),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles non-geographic proj for WMS', async () => {
store = buildStore({
proj: {
id: 'arctic',
selected: { id: 'arctic', crs: 'EPSG:3413', maxExtent: [-4194304, -4194304, 4194304, 4194304], resolutions: [1, 0.5] },
},
layers: { active: { activeTab: 'layers' }, activeB: { activeTab: 'layers' } },
});
builder = mapLayerBuilder(config, cache, store);
const layer = await builder.createLayer(
buildDef({ type: 'wms', source: 'test-source', format: 'image/png', projections: { arctic: {} } }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles wms with subdaily period', async () => {
const layer = await builder.createLayer(
buildDef({ type: 'wms', format: 'image/png', period: 'subdaily' }),
buildOptions({ date: new Date('2021-01-01T12:00:00.000Z') }),
);
expect(layer).toBeDefined();
});
});
describe('createLayer - xyz type', () => {
it('returns a layer for xyz def with active group', async () => {
const layer = await builder.createLayer(
buildDef({ type: 'xyz', source: 'test-xyz', layerName: 'test-xyz-layer', maxZoom: 10 }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('returns a layer for xyz def with activeB group', async () => {
const layer = await builder.createLayer(
buildDef({ type: 'xyz', source: 'test-xyz', layerName: 'test-xyz-layer', maxZoom: 10 }),
buildOptions({ group: 'activeB' }),
);
expect(layer).toBeDefined();
});
});
describe('createLayer - esriMapServer type', () => {
it('returns a layer for esriMapServer def', async () => {
const layer = await builder.createLayer(
buildDef({ type: 'esriMapServer', source: 'test-esri' }),
buildOptions(),
);
expect(layer).toBeDefined();
});
});
describe('createLayer - vector type', () => {
it('returns a layer for vector def (non-AERONET)', async () => {
const layer = await builder.createLayer(
buildDef({ type: 'vector', source: 'test-vector', matrixSet: 'testMatrixSet', projections: { geographic: {} } }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('throws error for vector layer with invalid source', async () => {
await expect(
builder.createLayer(
buildDef({ type: 'vector', source: 'nonexistent', matrixSet: 'testMatrixSet', projections: { geographic: {} } }),
buildOptions(),
),
).rejects.toThrow('Invalid source');
});
it('throws error for vector layer with missing matrixSet', async () => {
await expect(
builder.createLayer(
buildDef({ type: 'vector', source: 'test-vector', matrixSet: 'missingMatrixSet', projections: { geographic: {} } }),
buildOptions(),
),
).rejects.toThrow('Undefined matrix set');
});
it('returns vector layer for AERONET source', async () => {
builder = mapLayerBuilder(
buildConfig({ AERONET: { url: 'https://aeronet.example.com', matrixSets: {} } }),
cache,
store,
);
const layer = await builder.createLayer(
buildDef({ type: 'vector', source: 'AERONET', projections: { geographic: {} } }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('disables wrapX on the AERONET source so points stay within the layer extent', async () => {
const OlSourceVector = require('ol/source/Vector');
builder = mapLayerBuilder(
buildConfig({ AERONET: { url: 'https://aeronet.example.com', matrixSets: {} } }),
cache,
store,
);
await builder.createLayer(
buildDef({ type: 'vector', source: 'AERONET', projections: { geographic: {} } }),
buildOptions(),
);
expect(OlSourceVector).toHaveBeenCalledWith(
expect.objectContaining({ wrapX: false }),
);
});
it('throws error for AERONET with missing source config', async () => {
const noAeronetConfig = buildConfig();
delete noAeronetConfig.sources.AERONET;
builder = mapLayerBuilder(noAeronetConfig, cache, store);
await expect(
builder.createLayer(
buildDef({ type: 'vector', source: 'AERONET', projections: { geographic: {} } }),
buildOptions(),
),
).rejects.toThrow('Invalid source');
});
it('handles vector layer with def.matrixIds explicitly defined', async () => {
const layer = await builder.createLayer(
buildDef({ type: 'vector', source: 'test-vector', matrixSet: 'testMatrixSet', matrixIds: [0, 1], projections: { geographic: {} } }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles vector layer with wrapadjacentdays', async () => {
const layer = await builder.createLayer(
buildDef({ type: 'vector', source: 'test-vector', matrixSet: 'testMatrixSet', wrapadjacentdays: true, projections: { geographic: {} } }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles vector layer with max breakPointLayer and animation not playing', async () => {
const layer = await builder.createLayer(
buildDef({
type: 'vector',
source: 'test-vector',
matrixSet: 'testMatrixSet',
projections: { geographic: {} },
breakPointLayer: { projections: { geographic: { resolutionBreakPoint: 1000 } }, breakPointType: 'max' },
}),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles vector layer with min breakPointLayer', async () => {
const layer = await builder.createLayer(
buildDef({
type: 'vector',
source: 'test-vector',
matrixSet: 'testMatrixSet',
projections: { geographic: {} },
breakPointLayer: { projections: { geographic: { resolutionBreakPoint: 1000 } }, breakPointType: 'min' },
}),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles vector layer with breakPointLayer and animation playing', async () => {
store = buildStore({
animation: { isPlaying: true },
layers: { active: { activeTab: 'layers' }, activeB: { activeTab: 'layers' } },
});
builder = mapLayerBuilder(config, cache, store);
const layer = await builder.createLayer(
buildDef({
type: 'vector',
source: 'test-vector',
matrixSet: 'testMatrixSet',
projections: { geographic: {} },
breakPointLayer: { projections: { geographic: { resolutionBreakPoint: 1000 } }, breakPointType: 'max' },
}),
buildOptions(),
);
expect(layer).toBeDefined();
});
});
describe('createLayer - indexedVector type', () => {
const baseIndexedDef = () =>
buildDef({
type: 'indexedVector',
source: 'test-indexed',
layerName: 'test-indexed-layer',
serviceName: 'testService',
tiles: ['tile1'],
vectorStyle: {},
matrixSet: 'testMatrixSet',
matrixSetLimits: null,
projections: { geographic: {} },
});
it('returns a layer for indexedVector def without vectorStyle.url', async () => {
const layer = await builder.createLayer(baseIndexedDef(), buildOptions());
expect(layer).toBeDefined();
});
it('returns a layer for indexedVector def with vectorStyle.url', async () => {
const { applyStyle: olmsApplyStyle, applyBackground } = require('ol-mapbox-style');
const def = { ...baseIndexedDef(), vectorStyle: { url: 'https://style.example.com/style.json' } };
await builder.createLayer(def, buildOptions());
expect(olmsApplyStyle).toHaveBeenCalled();
expect(applyBackground).toHaveBeenCalled();
});
it('uses configMatrixSet fallback when matrixSet missing from source', async () => {
const def = { ...baseIndexedDef(), matrixSet: 'nonexistentMatrixSet' };
const layer = await builder.createLayer(def, buildOptions());
expect(layer).toBeDefined();
});
it('handles shifted option for indexedVector', async () => {
const layer = await builder.createLayer(baseIndexedDef(), buildOptions({ shifted: true }));
expect(layer).toBeDefined();
});
it('handles transformRequest with Source type returning modified Request', async () => {
const { applyStyle: olmsApplyStyle } = require('ol-mapbox-style');
let capturedTransformRequest;
olmsApplyStyle.mockImplementationOnce((layer, url, opts) => {
capturedTransformRequest = opts.transformRequest;
return Promise.resolve();
});
const def = { ...baseIndexedDef(), vectorStyle: { url: 'https://style.example.com/style.json' } };
await builder.createLayer(def, buildOptions());
expect(capturedTransformRequest).toBeDefined();
const result = capturedTransformRequest('https://example.com/VectorTileServer/layer', 'Source');
expect(result).toBeDefined();
});
it('handles transformRequest with non-Source type returning undefined', async () => {
const { applyStyle: olmsApplyStyle } = require('ol-mapbox-style');
let capturedTransformRequest;
olmsApplyStyle.mockImplementationOnce((layer, url, opts) => {
capturedTransformRequest = opts.transformRequest;
return Promise.resolve();
});
const def = { ...baseIndexedDef(), vectorStyle: { url: 'https://style.example.com/style.json' } };
await builder.createLayer(def, buildOptions());
const result = capturedTransformRequest('https://example.com/something', 'Tiles');
expect(result).toBeUndefined();
});
});
describe('createLayer - composite:wmts type', () => {
it('returns a layer for composite:wmts with matching date', async () => {
const def = buildDef({
type: 'composite:wmts',
source: 'test-source',
matrixSet: 'EPSG4326_250m',
format: 'image/jpeg',
matrixSetLimits: null,
layers: ['layer_20210101', 'layer_20210102'],
projections: { geographic: {} },
});
const layer = await builder.createLayer(def, buildOptions({ date: new Date('2021-01-01T00:00:00.000Z') }));
expect(layer).toBeDefined();
});
it('handles composite wmts where no layers match date', async () => {
const def = buildDef({
type: 'composite:wmts',
source: 'test-source',
matrixSet: 'EPSG4326_250m',
format: 'image/jpeg',
matrixSetLimits: null,
layers: ['layer_20210102'],
projections: { geographic: {} },
});
const layer = await builder.createLayer(def, buildOptions({ date: new Date('2021-01-01T00:00:00.000Z') }));
expect(layer).toBeDefined();
});
it('handles composite wmts with MAXAR source', async () => {
const maxarConfig = buildConfig({
'MAXAR:wmts': {
url: 'https://maxar.example.com',
matrixSets: {
EPSG4326_250m: {
id: 'EPSG4326_250m',
resolutions: [0.5, 0.25],
tileSize: [512, 512],
tileMatrices: [],
},
},
},
});
builder = mapLayerBuilder(maxarConfig, cache, store);
const def = buildDef({
type: 'composite:wmts',
source: 'MAXAR:wmts',
matrixSet: 'EPSG4326_250m',
format: 'image/jpeg',
matrixSetLimits: null,
layers: ['layer_20210101'],
projections: { geographic: {} },
});
const layer = await builder.createLayer(def, buildOptions({ date: new Date('2021-01-01T00:00:00.000Z') }));
expect(layer).toBeDefined();
});
it('uses getSelectedDate when options.date is not available for composite', async () => {
const def = buildDef({
type: 'composite:wmts',
source: 'test-source',
matrixSet: 'EPSG4326_250m',
format: 'image/jpeg',
matrixSetLimits: null,
layers: ['layer_20210101'],
projections: { geographic: {} },
});
const layer = await builder.createLayer(def, buildOptions({ date: undefined }));
expect(layer).toBeDefined();
});
});
describe('createLayer - granule type', () => {
it('returns a layer for granule def', async () => {
const layer = await builder.createLayer(
buildDef({ type: 'granule', projections: { geographic: {} } }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('does not call cache.setItem for granule type', async () => {
await builder.createLayer(
buildDef({ type: 'granule', projections: { geographic: {} } }),
buildOptions(),
);
expect(cache.setItem).not.toHaveBeenCalled();
});
});
describe('createLayer - titiler type', () => {
const baseTitilerDef = () =>
buildDef({
type: 'titiler',
source: 'test-source',
bandCombo: {
r: 'B4',
g: 'B3',
b: 'B2',
assets: [],
expression: 'B4/B3',
rescale: '0,1',
colormap_name: 'viridis',
asset_as_band: true,
bands_regex: '.*',
color_formula: null,
},
collectionConceptID: 'C1234-PODAAC',
minZoom: 3,
projections: { geographic: {} },
});
it('returns a layer group for titiler def with active group', async () => {
const layer = await builder.createLayer(baseTitilerDef(), buildOptions());
expect(layer).toBeDefined();
});
it('does not call setVisible for titiler layer', async () => {
const layer = await builder.createLayer(baseTitilerDef(), buildOptions());
expect(layer.setVisible).not.toHaveBeenCalled();
});
it('returns a layer for titiler def with activeB group', async () => {
const layer = await builder.createLayer(baseTitilerDef(), buildOptions({ group: 'activeB' }));
expect(layer).toBeDefined();
});
it('uses conceptIds array when collectionConceptID is not set', async () => {
const def = { ...baseTitilerDef(), collectionConceptID: undefined, conceptIds: [{ value: 'C9999-NSIDC' }] };
const layer = await builder.createLayer(def, buildOptions());
expect(layer).toBeDefined();
});
});
describe('createLayer - unknown type', () => {
it('throws for unknown layer type', async () => {
await expect(
builder.createLayer(buildDef({ type: 'unknown-type', projections: { geographic: {} } }), buildOptions()),
).rejects.toThrow('Unknown layer type');
});
});
describe('createLayer - static image (kiosk mode)', () => {
it('returns a static image layer in kiosk mode', async () => {
store = buildStore({ ui: { isKioskModeActive: true, displayStaticMap: true } });
builder = mapLayerBuilder(config, cache, store);
const layer = await builder.createLayer(buildDef(), buildOptions());
expect(layer).toBeDefined();
});
});
describe('createLayer - TEMPO layer handling', () => {
let mockWorker;
beforeEach(() => {
mockWorker = { postMessage: jest.fn(), terminate: jest.fn(), onmessage: null, onerror: null };
global.Worker = jest.fn().mockImplementation(() => mockWorker);
global.DOMParser = jest.fn().mockImplementation(() => ({
parseFromString: jest.fn().mockReturnValue({
querySelector: jest.fn().mockReturnValue(null),
}),
}));
});
it('calls tempoCallback immediately for TEMPO layers without tempoDateRanges', () => {
const tempoCallback = jest.fn();
const def = buildDef({ id: 'TEMPO_NO2_Hourly', projections: { geographic: {} } });
builder.createLayer(def, buildOptions({ tempoCallback }));
expect(tempoCallback).toHaveBeenCalledWith(def, [], 'active');
});
it('does not call tempoCallback when tempoDateRanges is already set', async () => {
const tempoCallback = jest.fn();
const def = buildDef({
id: 'TEMPO_NO2_Hourly',
tempoDateRanges: [{ startDate: '2021-01-01', endDate: '2021-01-02', dateInterval: '60' }],
projections: { geographic: {} },
});
await builder.createLayer(def, buildOptions({ tempoCallback }));
expect(tempoCallback).not.toHaveBeenCalled();
});
it('does not call tempoCallback when not a TEMPO layer', async () => {
const tempoCallback = jest.fn();
await builder.createLayer(buildDef({ id: 'regular-layer' }), buildOptions({ tempoCallback }));
expect(tempoCallback).not.toHaveBeenCalled();
});
it('does not call tempoCallback when tempoCallback is not provided', async () => {
const def = buildDef({ id: 'TEMPO_NO2_Hourly', projections: { geographic: {} } });
const layer = await builder.createLayer(def, buildOptions({ tempoCallback: undefined }));
expect(layer).toBeDefined();
});
});
describe('getRequestDates', () => {
it('uses options.date when provided', async () => {
const layer = await builder.createLayer(buildDef(), buildOptions({ date: new Date('2020-06-15T00:00:00.000Z') }));
expect(layer).toBeDefined();
});
it('falls back to stateCurrentDate when options.date is not set', async () => {
const layer = await builder.createLayer(buildDef(), buildOptions({ date: undefined }));
expect(layer).toBeDefined();
});
it('uses cached previousDate/nextDate range when current date is within it', async () => {
const now = new Date('2021-01-01T12:00:00.000Z');
const prev = new Date('2021-01-01T00:00:00.000Z');
const next = new Date('2021-01-02T00:00:00.000Z');
const layer = await builder.createLayer(
buildDef(),
buildOptions({ date: now, previousLayer: { previousDate: prev, nextDate: next } }),
);
expect(layer).toBeDefined();
});
it('handles ongoing daily period with multiple dateRange intervals', async () => {
const layer = await builder.createLayer(
buildDef({
ongoing: true,
period: 'daily',
dateRanges: [
{ startDate: '2020-01-01', endDate: '2020-06-01', dateInterval: '1' },
{ startDate: '2020-06-01', endDate: '2021-01-01', dateInterval: '3' },
],
}),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles ongoing monthly period', async () => {
const layer = await builder.createLayer(
buildDef({ ongoing: true, period: 'monthly', dateRanges: [] }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles ongoing yearly period', async () => {
const layer = await builder.createLayer(
buildDef({ ongoing: true, period: 'yearly', dateRanges: [] }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles ongoing subdaily period (else branch)', async () => {
const layer = await builder.createLayer(
buildDef({ ongoing: true, period: 'subdaily', dateRanges: [] }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles non-ongoing with no dateRanges', async () => {
const layer = await builder.createLayer(
buildDef({ ongoing: false, period: 'daily' }),
buildOptions(),
);
expect(layer).toBeDefined();
});
});
describe('layerKey', () => {
it('cache key is a string for periodic layers', async () => {
await builder.createLayer(buildDef({ period: 'daily' }), buildOptions());
expect(typeof cache.setItem.mock.calls[0][0]).toBe('string');
});
it('does not include date in key for static layers (no period)', async () => {
const layer = await builder.createLayer(buildDef({ period: undefined }), buildOptions());
expect(layer).toBeDefined();
});
it('includes palette key when palette is active', async () => {
const { isActive } = require('../modules/palettes/selectors');
isActive.mockReturnValue(true);
const layer = await builder.createLayer(buildDef(), buildOptions());
expect(layer).toBeDefined();
});
it('includes vector style key when vector style is active', async () => {
const { isActive } = require('../modules/vector-styles/selectors');
isActive.mockReturnValue(true);
const layer = await builder.createLayer(buildDef(), buildOptions());
expect(layer).toBeDefined();
});
it('uses subdaily date format in key for subdaily period', async () => {
await builder.createLayer(buildDef({ period: 'subdaily' }), buildOptions());
expect(cache.setItem).toHaveBeenCalled();
});
});
describe('getCacheOptions', () => {
it('returns empty object for non-subdaily period', async () => {
await builder.createLayer(buildDef({ period: 'daily' }), buildOptions());
expect(cache.setItem.mock.calls[0][2]).toEqual({});
});
it('returns empty object for subdaily layer older than 30 minutes', async () => {
await builder.createLayer(
buildDef({ period: 'subdaily' }),
buildOptions({ date: new Date('2000-01-01T00:00:00.000Z') }),
);
expect(cache.setItem.mock.calls[0][2]).toEqual({});
});
});
describe('createLayerWMTS - internal branches', () => {
it('handles palette active (tileClass lookup)', async () => {
const { isActive, getLookup } = require('../modules/palettes/selectors');
const lookupFactory = require('../ol/lookupimagetile');
isActive.mockReturnValue(true);
getLookup.mockReturnValue({ 0: { r: 255, g: 0, b: 0 } });
await builder.createLayer(buildDef(), buildOptions());
expect(lookupFactory).toHaveBeenCalled();
});
it('handles subdaily wmts layer', async () => {
const layer = await builder.createLayer(
buildDef({ period: 'subdaily' }),
buildOptions({ date: new Date('2021-01-01T10:00:00.000Z') }),
);
expect(layer).toBeDefined();
});
it('handles subdaily wmts with null date', async () => {
const layer = await builder.createLayer(
buildDef({ period: 'subdaily' }),
buildOptions({ date: null }),
);
expect(layer).toBeDefined();
});
it('uses sourceOverride url for wmts layer', async () => {
const layer = await builder.createLayer(
buildDef({ sourceOverride: 'https://override.example.com' }),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles matching matrixSetLimits length (calcExtentsFromLimits full path)', async () => {
const configWithLimits = buildConfig({
'test-source': {
url: 'https://gibs.example.com',
matrixSets: {
EPSG4326_250m: {
id: 'EPSG4326_250m',
resolutions: [0.5, 0.25],
tileSize: [512, 512],
tileMatrices: [{
matrixWidth: 2,
matrixHeight: 1,
}, { matrixWidth: 4, matrixHeight: 2 }],
origin: [-180, 90],
extent: [-180, -90, 180, 90],
},
},
},
});
builder = mapLayerBuilder(configWithLimits, cache, store);
const layer = await builder.createLayer(
buildDef({
matrixSetLimits: [
{ minTileCol: 0, maxTileCol: 1, minTileRow: 0, maxTileRow: 0 },
{ minTileCol: 0, maxTileCol: 3, minTileRow: 0, maxTileRow: 1 },
],
}),
buildOptions(),
);
expect(layer).toBeDefined();
});
it('handles wmts with explicit style defined', async () => {
const layer = await builder.createLayer(buildDef({ style: 'my-style' }), buildOptions());
expect(layer).toBeDefined();
});
it('throws error when wmts matrixSet is invalid', async () => {
await expect(
builder.createLayer(buildDef({ matrixSet: 'nonexistentMatrixSet' }), buildOptions()),
).rejects.toThrow('Undefined matrix set');
});
it('handles shifted option using RIGHT_WING_ORIGIN and RIGHT_WING_EXTENT', async () => {
const layer = await builder.createLayer(buildDef(), buildOptions({ shifted: true }));
expect(layer).toBeDefined();
});
it('handles tileMatrices undefined (produces empty sizes array)', async () => {
const configNoMatrices = buildConfig({
'test-source': {
url: 'https://gibs.example.com',
matrixSets: {
EPSG4326_250m: {
id: 'EPSG4326_250m',
resolutions: [0.5, 0.25],
tileSize: [512, 512],
tileMatrices: undefined,
},
},
},
});
builder = mapLayerBuilder(configNoMatrices, cache, store);
const layer = await builder.createLayer(buildDef(), buildOptions());
expect(layer).toBeDefined();
});
});
describe('createLayerVectorAeronet - internal branches', () => {
it('handles subdaily AERONET with null date (uses getRequestDates)', async () => {
builder = mapLayerBuilder(
buildConfig({ AERONET: { url: 'https://aeronet.example.com', matrixSets: {} } }),
cache,
store,
);
const layer = await builder.createLayer(
buildDef({ type: 'vector', source: 'AERONET', period: 'subdaily', projections: { geographic: {} } }),
buildOptions({ date: null }),
);
expect(layer).toBeDefined();
});
});
describe('cmrRebuildAttempts attribute spread', () => {
it('includes cmrRebuildAttempts in attributes when provided as non-null', async () => {
await builder.createLayer(buildDef(), buildOptions({ cmrRebuildAttempts: 3 }));
expect(cache.setItem).toHaveBeenCalled();
});
it('excludes cmrRebuildAttempts from attributes when null', async () => {
await builder.createLayer(buildDef(), buildOptions({ cmrRebuildAttempts: null }));
expect(cache.setItem).toHaveBeenCalled();
});
});
describe('getUpdatedDateRanges worker messaging', () => {
let mockWorker;
beforeEach(() => {
mockWorker = { postMessage: jest.fn(), terminate: jest.fn(), onmessage: null, onerror: null };
global.Worker = jest.fn().mockImplementation(() => mockWorker);
global.DOMParser = jest.fn().mockImplementation(() => ({
parseFromString: jest.fn().mockReturnValue({
querySelector: jest.fn().mockReturnValue(null),
}),
}));
});
it('handles worker onmessage with final array data format', async () => {
const tempoCallback = jest.fn();
const def = buildDef({
id: 'TEMPO_NO2_Hourly',
projections: { geographic: {} },
dateRanges: [{ startDate: '2021-01-01', endDate: '2021-01-02', dateInterval: '60' }],
});
await builder.createLayer(def, buildOptions({ tempoCallback }));
mockWorker.onmessage({ data: [['2021-01-01T00:00:00Z', '2021-01-02T00:00:00Z', '60']] });
expect(mockWorker.terminate).toHaveBeenCalled();
expect(tempoCallback).toHaveBeenCalledTimes(2);
});
it('handles worker onmessage with xml string and valid Domain element', async () => {
global.DOMParser = jest.fn().mockImplementation(() => ({
parseFromString: jest.fn().mockReturnValue({
querySelector: jest.fn().mockReturnValue({ textContent: 'domain1 domain2' }),
}),
}));
const tempoCallback = jest.fn();
await builder.createLayer(
buildDef({ id: 'TEMPO_NO2_Hourly', projections: { geographic: {} } }),
buildOptions({ tempoCallback }),
);
mockWorker.onmessage({ data: '<xml>some xml</xml>' });
expect(mockWorker.postMessage).toHaveBeenCalledTimes(2);
});
it('handles worker onmessage with xml string and null Domain element', async () => {
global.DOMParser = jest.fn().mockImplementation(() => ({
parseFromString: jest.fn().mockReturnValue({
querySelector: jest.fn().mockReturnValue(null),
}),
}));
const tempoCallback = jest.fn();
await builder.createLayer(
buildDef({ id: 'TEMPO_NO2_Hourly', projections: { geographic: {} } }),
buildOptions({ tempoCallback }),
);
mockWorker.onmessage({ data: '<xml>empty</xml>' });
expect(mockWorker.terminate).toHaveBeenCalled();
expect(tempoCallback).toHaveBeenCalledTimes(2);
});
it('handles worker onerror by terminating and calling callback', async () => {
const tempoCallback = jest.fn();
await builder.createLayer(
buildDef({ id: 'TEMPO_NO2_Hourly', projections: { geographic: {} } }),
buildOptions({ tempoCallback }),
);
mockWorker.onerror();
expect(mockWorker.terminate).toHaveBeenCalled();
expect(tempoCallback).toHaveBeenCalledTimes(2);
});
it('formats existing dateRanges where startDate equals endDate', async () => {
const tempoCallback = jest.fn();
const sameDate = '2021-01-01T00:00:00.000Z';
const def = buildDef({
id: 'TEMPO_NO2_Hourly',
projections: { geographic: {} },
dateRanges: [{ startDate: sameDate, endDate: sameDate, dateInterval: '60' }],
});
await builder.createLayer(def, buildOptions({ tempoCallback }));
mockWorker.onmessage({ data: [['2021-01-01T00:00:00Z', '2021-01-02T00:00:00Z', '60']] });
expect(tempoCallback).toHaveBeenCalledTimes(2);
});
});
});