@basemaps/lambda-tiler 6.39.0 → 6.41.0

package/src/__tests__/wmts.capability.test.ts

@@ -24,16 +24,17 @@ o.spec('WmtsCapabilities', () => {
   o('should output the requested formats', () => {
     const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
-      provider: Provider,
-      tileMatrix: [GoogleTms],
-      tileSet: TileSetAerial,
-      imagery: allImagery,
       apiKey,
-      formats: [ImageFormat.Avif],
-      isIndividualLayers: false,
-    }).toVNode();
+    });
+
+    wmts.addTileMatrix(GoogleTms);
+    for (const im of allImagery.values()) wmts.addImagery(im);
+    wmts.addFormats(ImageFormat.Avif);
+    wmts.addProvider(Provider);
+    wmts.addTileSet(TileSetAerial);
+    const wmtsCapability = wmts.toVNode();
 
-    const urls = tags(wmts, 'ResourceURL');
+    const urls = tags(wmtsCapability, 'ResourceURL');
     o(urls.length).equals(1);
     o(urls[0].attrs.format).equals('image/avif');
     o(urls[0].attrs.template).equals(
@@ -44,17 +45,18 @@ o.spec('WmtsCapabilities', () => {
   o('should include config location', () => {
     const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
-      provider: Provider,
-      tileMatrix: [GoogleTms],
-      tileSet: TileSetAerial,
-      imagery: allImagery,
       apiKey,
       config: 's3://linz-basemaps/config.json',
-      formats: [ImageFormat.Avif],
-      isIndividualLayers: false,
-    }).toVNode();
+    });
 
-    const urls = tags(wmts, 'ResourceURL');
+    wmts.addTileMatrix(GoogleTms);
+    for (const im of allImagery.values()) wmts.addImagery(im);
+    wmts.addFormats(ImageFormat.Avif);
+    wmts.addProvider(Provider);
+    wmts.addTileSet(TileSetAerial);
+    const wmtsCapability = wmts.toVNode();
+
+    const urls = tags(wmtsCapability, 'ResourceURL');
     o(urls.length).equals(1);
     o(urls[0].attrs.format).equals('image/avif');
     o(urls[0].attrs.template).equals(
@@ -62,17 +64,20 @@ o.spec('WmtsCapabilities', () => {
     );
   });
 
-  o('should be seting encoding to utf-8', () => {
-    const xml = new WmtsCapabilities({
+  o('should be adding encoding to utf-8', () => {
+    const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+      apiKey,
+    });
+
+    wmts.fromParams({
       provider: Provider,
       tileMatrix: [GoogleTms],
       tileSet: TileSetAerial,
       imagery: allImagery,
-      apiKey,
       formats: [ImageFormat.Avif],
-      isIndividualLayers: false,
-    }).toXml();
+    });
+    const xml = wmts.toXml();
 
     o(xml.split('\n')[0]).deepEquals('<?xml version="1.0" encoding="utf-8"?>');
   });
@@ -82,24 +87,26 @@ o.spec('WmtsCapabilities', () => {
     tileSet.name = '🦄_🌈_2022_0-5m';
     tileSet.title = '🦄 🌈 Imagery (2022)';
     tileSet.description = '🦄 🌈 Description';
+
     const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
-      provider: Provider,
-      tileMatrix: [GoogleTms],
-      tileSet,
-      imagery: allImagery,
       apiKey,
-      formats: [ImageFormat.Avif],
-      isIndividualLayers: false,
-    }).toVNode();
+    });
+
+    wmts.addTileMatrix(GoogleTms);
+    for (const im of allImagery.values()) wmts.addImagery(im);
+    wmts.addFormats(ImageFormat.Avif);
+    wmts.addProvider(Provider);
+    wmts.addTileSet(tileSet);
+    const wmtsCapability = wmts.toVNode();
 
-    const urls = tags(wmts, 'ResourceURL');
+    const urls = tags(wmtsCapability, 'ResourceURL');
     o(urls.length).equals(1);
     o(urls[0].attrs.template).equals(
       'https://basemaps.test/v1/tiles/🦄-🌈-2022-0.5m/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.avif?api=secret1234',
     );
 
-    const layer = tags(wmts, 'Layer')[0];
+    const layer = tags(wmtsCapability, 'Layer')[0];
 
     const title = layer.find('ows:Title')?.toString();
     o(title).equals('<ows:Title>🦄 🌈 Imagery (2022)</ows:Title>');
@@ -137,33 +144,36 @@ o.spec('WmtsCapabilities', () => {
 
     const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
-      provider: Provider,
-      tileMatrix: [GoogleTms],
-      tileSet,
-      imagery,
       apiKey,
-      isIndividualLayers: true,
-    }).toVNode();
+    });
 
-    const layers = tags(wmts, 'Layer').map((c) => c.find('ows:Title')?.textContent);
+    wmts.addTileMatrix(GoogleTms);
+    for (const im of imagery.values()) wmts.addImagery(im);
+    wmts.addProvider(Provider);
+    wmts.addTileSet(tileSet);
+    wmts.addLayers(tileSet.layers);
+    const wmtsCapability = wmts.toVNode();
+
+    const layers = tags(wmtsCapability, 'Layer').map((c) => c.find('ows:Title')?.textContent);
 
     // The base layer "Aerial Imagery" should always be first then all sub layers after
     o(layers).deepEquals(['Aerial Imagery', 'aaaa', 'bbbb', 'Ōtorohanga 0.1m Urban Aerial Photos (2021)']);
   });
 
-  o('should build capability xml for tileset and projection', () => {
+  o('should build capability xml for tileSet and projection', () => {
     const imagery = new Map();
     imagery.set(Imagery3857.id, Imagery3857);
+
     const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
-      provider: Provider,
-      tileMatrix: [GoogleTms],
-      tileSet: TileSetAerial,
-      imagery,
       apiKey,
-      isIndividualLayers: false,
     });
 
+    wmts.addTileMatrix(GoogleTms);
+    for (const im of imagery.values()) wmts.addImagery(im);
+    wmts.addProvider(Provider);
+    wmts.addTileSet(TileSetAerial);
+    wmts.addLayers(TileSetAerial.layers);
     const raw = wmts.toVNode();
     const serviceId = raw.find('ows:ServiceIdentification');
 
@@ -206,15 +216,17 @@ o.spec('WmtsCapabilities', () => {
   });
 
   o('should include output the correct TileMatrix', () => {
-    const raw = new WmtsCapabilities({
+    const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
-      provider: Provider,
-      tileMatrix: [GoogleTms],
-      tileSet: TileSetAerial,
-      imagery: allImagery,
       apiKey,
-      isIndividualLayers: false,
-    }).toVNode();
+    });
+
+    wmts.addTileMatrix(GoogleTms);
+    for (const im of allImagery.values()) wmts.addImagery(im);
+    wmts.addProvider(Provider);
+    wmts.addTileSet(TileSetAerial);
+    const raw = wmts.toVNode();
+
     const layer = raw.find('Contents', 'Layer');
 
     o(layer?.find('TileMatrixSetLink', 'TileMatrixSet')?.textContent).equals('WebMercatorQuad');
@@ -249,19 +261,25 @@ o.spec('WmtsCapabilities', () => {
     compareMatrix(tileMatrices[10], '10', 1024, 545978.773465544);
   });
 
-  o('should output individual imagery sets', () => {
+  o('should output individual imagery adds', () => {
     const imagery = new Map<string, ConfigImagery>();
     imagery.set(Imagery3857.id, Imagery3857);
     imagery.set(Imagery2193.id, Imagery2193);
-    const raw = new WmtsCapabilities({
+
+    const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+    });
+
+    wmts.fromParams({
       provider: Provider,
       tileMatrix: [GoogleTms],
       tileSet: TileSetAerial,
-      imagery: imagery,
+      imagery,
+      layers: TileSetAerial.layers,
       formats: [ImageFormat.Png],
-      isIndividualLayers: true,
-    }).toVNode();
+    });
+
+    const raw = wmts.toVNode();
 
     const tms = raw?.find('TileMatrixSet', 'ows:Identifier');
 
@@ -292,16 +310,20 @@ o.spec('WmtsCapabilities', () => {
     const imagery = new Map<string, ConfigImagery>();
     imagery.set(Imagery3857.id, Imagery3857);
     imagery.set(Imagery2193.id, Imagery2193);
-    const raw = new WmtsCapabilities({
+
+    const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+    });
+
+    wmts.fromParams({
       provider: Provider,
       tileMatrix: [GoogleTms, Nztm2000QuadTms],
       tileSet: TileSetAerial,
       imagery: imagery,
       formats: [ImageFormat.Png],
-      isIndividualLayers: false,
-    }).toVNode();
+    });
 
+    const raw = wmts.toVNode();
     const layers = tags(raw, 'Layer');
     o(layers.length).equals(1);
     const layer = layers[0];
@@ -328,11 +350,11 @@ o.spec('WmtsCapabilities', () => {
     );
     o(layer.find('ows:Identifier')?.textContent).equals('aerial');
 
-    const sets = tags(layer, 'TileMatrixSet');
+    const adds = tags(layer, 'TileMatrixSet');
 
-    o(sets.length).equals(2);
-    o(sets[0].toString()).equals('<TileMatrixSet>WebMercatorQuad</TileMatrixSet>');
-    o(sets[1].toString()).equals('<TileMatrixSet>NZTM2000Quad</TileMatrixSet>');
+    o(adds.length).equals(2);
+    o(adds[0].toString()).equals('<TileMatrixSet>WebMercatorQuad</TileMatrixSet>');
+    o(adds[1].toString()).equals('<TileMatrixSet>NZTM2000Quad</TileMatrixSet>');
 
     const boundingBoxes = tags(layer, 'ows:BoundingBox');
     o(boundingBoxes.length).equals(2);
@@ -354,37 +376,45 @@ o.spec('WmtsCapabilities', () => {
 
   o('should only output imagery if exists', () => {
     const imagery = new Map<string, ConfigImagery>();
-    const raw = new WmtsCapabilities({
+    const wmtsA = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+    });
+
+    wmtsA.fromParams({
       provider: Provider,
       tileMatrix: [Nztm2000QuadTms],
       tileSet: TileSetAerial,
       imagery: imagery,
       formats: [ImageFormat.Png],
-      isIndividualLayers: true,
-    }).toVNode();
+      layers: TileSetAerial.layers,
+    });
 
-    const layers = tags(raw, 'Layer');
+    const rawA = wmtsA.toVNode();
+
+    const layers = tags(rawA, 'Layer');
     o(layers.length).equals(1);
 
     imagery.set(Imagery3857.id, Imagery3857);
-    const rawB = new WmtsCapabilities({
+    const wmtsB = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+    });
+    wmtsB.fromParams({
       provider: Provider,
       tileMatrix: [Nztm2000QuadTms],
       tileSet: TileSetAerial,
       imagery: imagery,
       formats: [ImageFormat.Png],
-      isIndividualLayers: true,
-    }).toVNode();
+      layers: TileSetAerial.layers,
+    });
 
+    const rawB = wmtsB.toVNode();
     const layersB = tags(rawB, 'Layer');
     o(layersB.length).equals(1);
   });
 
   o('should cover the entire WebMercatorBounds', () => {
     const halfSize = GoogleTms.extent.width / 2;
-    // Create two fake imagery sets one covers tile z1 x0 y0 another covers tile z1 x1 y1
+    // Create two fake imagery adds one covers tile z1 x0 y0 another covers tile z1 x1 y1
     // so the entire bounding box should be tile z0 x0 y0 or the full extent
     const imagery = new Map();
     const imageTopLeft = { ...Imagery3857, id: 'im_top_left', name: 'top_left' };
@@ -397,19 +427,23 @@ o.spec('WmtsCapabilities', () => {
 
     const tileSet = { ...TileSetAerial };
     tileSet.layers = [
-      { 3857: imageTopLeft.id, name: 'a_top_left' },
-      { 3857: imageBottomRight.id, name: 'b_bottom_right' },
+      { 3857: imageTopLeft.id, name: 'a_top_left', title: 'A Top Left' },
+      { 3857: imageBottomRight.id, name: 'b_bottom_right', title: 'B Bottom Right' },
     ];
 
-    const raw = new WmtsCapabilities({
+    const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+    });
+    wmts.fromParams({
       provider: Provider,
       tileMatrix: [GoogleTms],
       tileSet,
       imagery,
       formats: [ImageFormat.Png],
-      isIndividualLayers: true,
-    }).toVNode();
+      layers: tileSet.layers,
+    });
+
+    const raw = wmts.toVNode();
 
     const boundingBox = tags(raw, 'ows:WGS84BoundingBox').map((c) =>
       c
@@ -438,17 +472,21 @@ o.spec('WmtsCapabilities', () => {
     imagery.set(imageBottomRight.id, imageBottomRight);
 
     const tileSet = { ...TileSetAerial };
-    tileSet.layers = [{ 3857: imageBottomRight.id, name: 'b_bottom_right' }];
+    tileSet.layers = [{ 3857: imageBottomRight.id, name: 'b_bottom_right', title: 'B Bottom Right' }];
 
-    const raw = new WmtsCapabilities({
+    const wmts = new WmtsCapabilities({
       httpBase: 'https://basemaps.test',
+    });
+    wmts.fromParams({
       provider: Provider,
       tileMatrix: [GoogleTms],
       tileSet,
       imagery,
       formats: [ImageFormat.Png],
-      isIndividualLayers: true,
-    }).toVNode();
+      layers: tileSet.layers,
+    });
+
+    const raw = wmts.toVNode();
 
     const boundingBox = tags(raw, 'ows:WGS84BoundingBox').map((c) =>
       roundNumbersInString(c.toString(), 4)

package/src/__tests__/xyz.util.ts

@@ -3,6 +3,8 @@ import { LambdaAlbRequest, LambdaHttpRequest, LambdaUrlRequest } from '@linzjs/l
 import { Context } from 'aws-lambda';
 
 export function mockRequest(path: string, method = 'get', headers: Record<string, string> = {}): LambdaHttpRequest {
+  const log = LogConfig.get();
+  log.level = 'silent';
   return new LambdaAlbRequest(
     {
       requestContext: null as any,
@@ -13,7 +15,7 @@ export function mockRequest(path: string, method = 'get', headers: Record<string
       isBase64Encoded: false,
     },
     {} as Context,
-    LogConfig.get(),
+    log,
   );
 }
 
@@ -23,6 +25,8 @@ export function mockUrlRequest(
   headers: Record<string, unknown> = {},
   method?: string,
 ): LambdaHttpRequest {
+  const log = LogConfig.get();
+  log.level = 'silent';
   return new LambdaUrlRequest(
     {
       requestContext: { http: { method: method ? method.toUpperCase() : 'GET' } },
@@ -32,7 +36,7 @@ export function mockUrlRequest(
       isBase64Encoded: false,
     } as any,
     {} as Context,
-    LogConfig.get(),
+    log,
   );
 }
 

package/src/cli/render.tile.ts

@@ -0,0 +1,41 @@
+import { ConfigProviderMemory } from '@basemaps/config';
+import { initConfigFromUrls } from '@basemaps/config/build/json/tiff.config.js';
+import { GoogleTms, ImageFormat } from '@basemaps/geo';
+import { LogConfig, setDefaultConfig } from '@basemaps/shared';
+import { fsa } from '@chunkd/fs';
+import { LambdaHttpRequest, LambdaUrlRequest, UrlEvent } from '@linzjs/lambda';
+import { Context } from 'aws-lambda';
+import { TileXyzRaster } from '../routes/tile.xyz.raster.js';
+import { pathToFileURL } from 'url';
+
+const target = pathToFileURL(`/home/blacha/tmp/basemaps/white-lines/nz-0.5m/`);
+const tile = { z: 10, x: 1013, y: 633 };
+const tileMatrix = GoogleTms;
+const imageFormat = ImageFormat.Webp;
+
+async function main(): Promise<void> {
+  const log = LogConfig.get();
+  const provider = new ConfigProviderMemory();
+  setDefaultConfig(provider);
+  const { tileSet, imagery } = await initConfigFromUrls(provider, [target]);
+
+  if (tileSet.layers.length === 0) throw new Error('No imagery found in path: ' + target);
+  log.info({ tileSet: tileSet.name, layers: tileSet.layers.length }, 'TileSet:Loaded');
+  for (const im of imagery) {
+    log.info({ url: im.uri, title: im.title, tileMatrix: im.tileMatrix, files: im.files.length }, 'Imagery:Loaded');
+  }
+  const request = new LambdaUrlRequest({ headers: {} } as UrlEvent, {} as Context, log) as LambdaHttpRequest;
+
+  tileSet.background = { r: 255, g: 255, b: 255, alpha: 1 };
+  const res = await TileXyzRaster.tile(request, tileSet, {
+    tile,
+    tileMatrix,
+    tileSet: tileSet.id,
+    tileType: imageFormat,
+  });
+
+  await fsa.write(`./${tile.z}_${tile.x}_${tile.y}.${imageFormat}`, Buffer.from(res.body, 'base64'));
+  log.info({ path: `./${tile.z}_${tile.x}_${tile.y}.${imageFormat}` }, 'Tile:Write');
+}
+
+main();

package/src/routes/__tests__/attribution.test.ts

@@ -1,7 +1,8 @@
 import { Attribution } from '@basemaps/attribution';
 import { ConfigProviderMemory } from '@basemaps/config';
-import { Nztm2000QuadTms } from '@basemaps/geo';
+import { GoogleTms, Nztm2000QuadTms, Projection } from '@basemaps/geo';
 import { LogConfig } from '@basemaps/shared';
+import { BBox } from '@linzjs/geojson';
 import { HttpHeader } from '@linzjs/lambda';
 import o from 'ospec';
 import sinon from 'sinon';
@@ -9,6 +10,7 @@ import { handler } from '../../index.js';
 import { ConfigLoader } from '../../util/config.loader.js';
 import { FakeData, Imagery2193, Imagery3857, Provider, TileSetAerial } from '../../__tests__/config.data.js';
 import { mockUrlRequest } from '../../__tests__/xyz.util.js';
+import { createCoordinates } from '../attribution.js';
 
 // const ExpectedJson = {
 //   id: 'aerial_WebMercatorQuad',
@@ -332,7 +334,7 @@ o.spec('/v1/attribution', () => {
   });
 
   o.spec('ImageryRules', () => {
-    const fakeLayer = { [2193]: Imagery2193.id, name: 'image', minZoom: 9, maxZoom: 16 };
+    const fakeLayer = { [2193]: Imagery2193.id, name: 'image', minZoom: 9, maxZoom: 16, title: 'Image' };
     const ts = FakeData.tileSetRaster('fake');
 
     o.beforeEach(() => {
@@ -387,4 +389,64 @@ o.spec('/v1/attribution', () => {
       o(output.collections[0].summaries['linz:zoom']).deepEquals({ min: 0, max: Nztm2000QuadTms.maxZoom });
     });
   });
+
+  o('should create valid coordinates', async () => {
+    //bbox: BBox, files: NamedBounds[], proj: Projection
+    const bbox = [174.79248047, -38.21228805, 175.25939941, -37.99616268] as BBox;
+    const proj = Projection.get(GoogleTms);
+    const coordinates = createCoordinates(bbox, Imagery3857.files, proj);
+    console.log(JSON.stringify(coordinates));
+    o(coordinates).deepEquals([
+      [
+        [
+          [174.79247149, -38.09998972],
+          [174.81446211, -38.09998972],
+          [174.81446211, -38.09134368],
+          [174.82544844, -38.09134368],
+          [174.82544844, -38.08485848],
+          [174.82819502, -38.08485848],
+          [174.82819502, -38.08269662],
+          [174.83643476, -38.08269662],
+          [174.83643476, -38.06539942],
+          [174.85840742, -38.06539942],
+          [174.85840742, -37.9961556],
+          [174.81446211, -37.9961556],
+          [174.81446211, -37.9961556],
+          [174.79247149, -37.9961556],
+          [174.79247149, -38.01348331],
+          [174.80345781, -38.01348331],
+          [174.80345781, -38.02213855],
+          [174.81444414, -38.02213855],
+          [174.81444414, -38.04808399],
+          [174.79247149, -38.04808399],
+          [174.79247149, -38.09998972],
+        ],
+      ],
+      [
+        [
+          [175.16600664, -38.20366238],
+          [175.1879793, -38.20366238],
+          [175.1879793, -38.21229511],
+          [175.20996992, -38.21229511],
+          [175.20996992, -38.20797887],
+          [175.21546308, -38.20797887],
+          [175.21546308, -38.20366238],
+          [175.25391523, -38.20366238],
+          [175.25391523, -38.18207606],
+          [175.2594084, -38.18207606],
+          [175.2594084, -38.17342562],
+          [175.25391523, -38.17342562],
+          [175.25391523, -38.13454951],
+          [175.20995195, -38.13454951],
+          [175.20995195, -38.16046922],
+          [175.19896563, -38.16046922],
+          [175.19896563, -38.16694771],
+          [175.19621904, -38.16694771],
+          [175.19621904, -38.16910707],
+          [175.16600664, -38.16910707],
+          [175.16600664, -38.20366238],
+        ],
+      ],
+    ]);
+  });
 });

package/src/routes/__tests__/wmts.test.ts

@@ -9,18 +9,11 @@ import { Api, mockUrlRequest } from '../../__tests__/xyz.util.js';
 o.spec('WMTSRouting', () => {
   const sandbox = createSandbox();
   const config = new ConfigProviderMemory();
+  const imagery = new Map();
 
-  o.before(() => {
+  o.beforeEach(() => {
     sandbox.stub(ConfigLoader, 'load').resolves(config);
-  });
 
-  o.afterEach(() => {
-    config.objects.clear();
-    sandbox.restore();
-  });
-
-  o('should default to the aerial layer', async () => {
-    const imagery = new Map();
     imagery.set(Imagery3857.id, Imagery3857);
     imagery.set(Imagery2193.id, Imagery2193);
 
@@ -28,7 +21,14 @@ o.spec('WMTSRouting', () => {
     config.put(Imagery2193);
     config.put(Imagery3857);
     config.put(Provider);
+  });
 
+  o.afterEach(() => {
+    config.objects.clear();
+    sandbox.restore();
+  });
+
+  o('should default to the aerial layer', async () => {
     const req = mockUrlRequest(
       '/v1/tiles/WMTSCapabilities.xml',
       `format=png&api=${Api.key}&config=s3://linz-basemaps/config.json`,
@@ -53,4 +53,65 @@ o.spec('WMTSRouting', () => {
       '<ResourceURL format="image/png" resourceType="tile" template="https://tiles.test/v1/tiles/ōtorohanga-urban-2021-0.1m/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.png?api=d01f7w7rnhdzg0p7fyrc9v9ard1&amp;config=Q5pC4UjWdtFLU1CYtLcRSmB49RekgDgMa5EGJnB2M" />',
     ]);
   });
+
+  o('should filter out date[after] by year', async () => {
+    const req = mockUrlRequest(
+      '/v1/tiles/WMTSCapabilities.xml',
+      `format=png&api=${Api.key}&config=s3://linz-basemaps/config.json&date[after]=2022`,
+    );
+    const res = await handler.router.handle(req);
+
+    o(res.status).equals(200);
+    const lines = Buffer.from(res.body, 'base64').toString().split('\n');
+    const titles = lines.filter((f) => f.startsWith('      <ows:Title>')).map((f) => f.trim());
+
+    o(titles).deepEquals([
+      '<ows:Title>Aerial Imagery</ows:Title>',
+      '<ows:Title>Google Maps Compatible for the World</ows:Title>',
+      '<ows:Title>LINZ NZTM2000 Map Tile Grid V2</ows:Title>',
+    ]);
+  });
+
+  o('should filter out date[before] by year', async () => {
+    const req = mockUrlRequest(
+      '/v1/tiles/WMTSCapabilities.xml',
+      `format=png&api=${Api.key}&config=s3://linz-basemaps/config.json&date[before]=2020`,
+    );
+    const res = await handler.router.handle(req);
+
+    o(res.status).equals(200);
+    const lines = Buffer.from(res.body, 'base64').toString().split('\n');
+    const titles = lines.filter((f) => f.startsWith('      <ows:Title>')).map((f) => f.trim());
+
+    o(titles).deepEquals([
+      '<ows:Title>Aerial Imagery</ows:Title>',
+      '<ows:Title>Google Maps Compatible for the World</ows:Title>',
+      '<ows:Title>LINZ NZTM2000 Map Tile Grid V2</ows:Title>',
+    ]);
+  });
+
+  o('should filter inclusive date[before] by year', async () => {
+    const req = mockUrlRequest(
+      '/v1/tiles/WMTSCapabilities.xml',
+      `format=png&api=${Api.key}&config=s3://linz-basemaps/config.json&date[before]=2021`,
+    );
+    const res = await handler.router.handle(req);
+
+    o(res.status).equals(200);
+    const lines = Buffer.from(res.body, 'base64').toString().split('\n');
+    const titles = lines.filter((f) => f.startsWith('      <ows:Title>')).map((f) => f.trim());
+
+    o(titles).deepEquals([
+      '<ows:Title>Aerial Imagery</ows:Title>',
+      '<ows:Title>Ōtorohanga 0.1m Urban Aerial Photos (2021)</ows:Title>',
+      '<ows:Title>Google Maps Compatible for the World</ows:Title>',
+      '<ows:Title>LINZ NZTM2000 Map Tile Grid V2</ows:Title>',
+    ]);
+
+    const resourceURLs = lines.filter((f) => f.includes('<ResourceURL')).map((f) => f.trim());
+    o(resourceURLs).deepEquals([
+      '<ResourceURL format="image/png" resourceType="tile" template="https://tiles.test/v1/tiles/aerial/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.png?api=d01f7w7rnhdzg0p7fyrc9v9ard1&amp;config=Q5pC4UjWdtFLU1CYtLcRSmB49RekgDgMa5EGJnB2M&amp;date%5Bbefore%5D=2021" />',
+      '<ResourceURL format="image/png" resourceType="tile" template="https://tiles.test/v1/tiles/ōtorohanga-urban-2021-0.1m/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.png?api=d01f7w7rnhdzg0p7fyrc9v9ard1&amp;config=Q5pC4UjWdtFLU1CYtLcRSmB49RekgDgMa5EGJnB2M" />',
+    ]);
+  });
 });