@basemaps/lambda-tiler 6.15.0

package/src/__test__/index.test.ts

@@ -0,0 +1,57 @@
+import { LogConfig } from '@basemaps/shared';
+import { LambdaAlbRequest, LambdaHttpRequest } from '@linzjs/lambda';
+import { Context } from 'aws-lambda';
+import o from 'ospec';
+import { handleRequest } from '../index.js';
+
+o.spec('LambdaXyz index', () => {
+  function req(path: string, method = 'get'): LambdaHttpRequest {
+    return new LambdaAlbRequest(
+      {
+        requestContext: null as any,
+        httpMethod: method.toUpperCase(),
+        path,
+        body: null,
+        isBase64Encoded: false,
+      },
+      {} as Context,
+      LogConfig.get(),
+    );
+  }
+
+  o('should export handler', async () => {
+    const foo = await import('../index.js');
+    o(typeof foo.handler).equals('function');
+  });
+
+  o.spec('version', () => {
+    const origVersion: any = process.env.GIT_VERSION;
+    const origHash: any = process.env.GIT_HASH;
+    o.after(() => {
+      process.env.GIT_VERSION = origVersion;
+      process.env.GIT_HASH = origHash;
+    });
+
+    o('should return version', async () => {
+      process.env.GIT_VERSION = '1.2.3';
+      process.env.GIT_HASH = 'abc456';
+
+      const response = await handleRequest(req('/version'));
+
+      o(response.status).equals(200);
+      o(response.statusDescription).equals('ok');
+      o(response.header('cache-control')).equals('no-store');
+      o(JSON.parse(response.body as string)).deepEquals({
+        version: '1.2.3',
+        hash: 'abc456',
+      });
+    });
+  });
+
+  o('should respond to /ping', async () => {
+    const res = await handleRequest(req('/ping'));
+    o(res.status).equals(200);
+    o(res.statusDescription).equals('ok');
+    o(res.header('cache-control')).equals('no-store');
+  });
+});

package/src/__test__/tiff.cache.test.ts

@@ -0,0 +1,73 @@
+import { SourceMemory } from '@chunkd/core';
+import { CogTiff } from '@cogeotiff/core';
+import o from 'ospec';
+import { TiffCache } from '../tiff.cache.js';
+
+/** convert number to megabytes */
+const MegaBytes = (num: number): number => num * 1024 * 1024;
+
+o.spec('TiffCache', () => {
+  o.beforeEach(() => TiffCache.clear());
+
+  o('should cache items', () => {
+    const source = new SourceMemory('fake', Buffer.from('foo'));
+    const tiff = new CogTiff(source);
+
+    o(TiffCache.get('fake')).equals(null);
+    TiffCache.set('fake', tiff);
+    o(TiffCache.get('fake')?.source.uri).equals(tiff.source.uri);
+
+    TiffCache.check();
+    o(TiffCache.get('fake')?.source.uri).equals(tiff.source.uri);
+  });
+
+  o('should expire cached object if size gets too large', () => {
+    const source = new SourceMemory('fake', Buffer.from('foo'));
+    const sourceB = new SourceMemory('fakeB', Buffer.from('foo'));
+
+    // Override chunk size to say there is 500 mb of items
+    source.chunkSize = MegaBytes(257);
+    sourceB.chunkSize = MegaBytes(257);
+
+    const tiff = new CogTiff(source);
+    const tiffB = new CogTiff(sourceB);
+
+    o(TiffCache.get('fake')).equals(null);
+
+    TiffCache.set('fake', tiff);
+    o(TiffCache.get('fake')?.source.uri).equals(tiff.source.uri);
+
+    TiffCache.check();
+    o(TiffCache.cacheA.get('fake')?.source.uri).equals(undefined);
+    o(TiffCache.cacheB.get('fake')?.source.uri).equals(tiff.source.uri);
+
+    // Should evict the cache
+    TiffCache.set('fakeB', tiffB);
+    TiffCache.check();
+
+    o(TiffCache.cacheA.get('fake')?.source.uri).equals(undefined);
+    o(TiffCache.cacheB.get('fake')?.source.uri).equals(undefined);
+  });
+
+  o('should allow multiple items in the cache', () => {
+    const source = new SourceMemory('fake', Buffer.from('foo'));
+    const tiff = new CogTiff(source);
+
+    TiffCache.set('fake', tiff);
+    const oneMb = MegaBytes(1);
+    source.chunkSize = oneMb;
+
+    for (let i = 1; i < 256; i++) {
+      o(TiffCache.currentSize).equals(i * oneMb);
+      source.chunks.set(i, source.chunks.get(0)!);
+    }
+    // should not have overflown
+    TiffCache.check();
+    o(TiffCache.cacheA.size).equals(1);
+    // Overflow the cache
+    source.chunks.set(257, source.chunks.get(0)!);
+
+    TiffCache.check();
+    o(TiffCache.cacheA.size).equals(0);
+  });
+});

package/src/__test__/tile.cache.key.test.ts

@@ -0,0 +1,56 @@
+import { GoogleTms, Nztm2000Tms } from '@basemaps/geo';
+import { TileDataXyz, TileType } from '@basemaps/shared';
+import { TestTiff } from '@basemaps/test';
+import { Composition, ImageFormat } from '@basemaps/tiler';
+import o from 'ospec';
+import { TileEtag } from '../routes/tile.etag.js';
+
+o.spec('TileCacheKey', () => {
+  const oldRenderId = TileEtag.RenderId;
+
+  const xyzData: TileDataXyz = {
+    x: 0,
+    y: 0,
+    z: 0,
+    tileMatrix: GoogleTms,
+    name: 'foo',
+    ext: ImageFormat.PNG,
+    type: TileType.Tile,
+  };
+
+  o.afterEach(() => {
+    TileEtag.RenderId = oldRenderId;
+  });
+
+  o('should generate a cachekey', async () => {
+    const tiff = await TestTiff.Google.init();
+    const comp: Composition = {
+      tiff,
+      source: {
+        x: 0,
+        y: 0,
+        imageId: 0,
+        width: 512,
+        height: 512,
+      },
+      x: 5,
+      y: 5,
+    };
+    const firstKey = TileEtag.generate([comp], xyzData);
+    o(firstKey).equals('8eJ7XnUeEGBI2d7mfAaK5o8KbUc0+CVaIoPzqCvkoDk=');
+
+    // Different layers should generate different keys
+    o(TileEtag.generate([comp, comp], xyzData)).notEquals(firstKey);
+
+    // Different projections should generate different keys
+    xyzData.tileMatrix = Nztm2000Tms;
+    o(TileEtag.generate([comp], xyzData)).notEquals(firstKey);
+  });
+
+  o('should change if the renderId changes', () => {
+    const keyA = TileEtag.generate([], { tileMatrix: {} } as any);
+    TileEtag.RenderId = 2;
+    const KeyB = TileEtag.generate([], { tileMatrix: {} } as any);
+    o(keyA).notEquals(KeyB);
+  });
+});

package/src/__test__/tile.set.cache.test.ts

@@ -0,0 +1,143 @@
+import { ConfigImagery, ConfigTileSetRaster } from '@basemaps/config';
+import { Epsg, GoogleTms, Nztm2000Tms } from '@basemaps/geo';
+import { Config, TileSetName } from '@basemaps/shared';
+import o from 'ospec';
+import sinon from 'sinon';
+import { TileSets } from '../tile.set.cache.js';
+import { TileSetRaster } from '../tile.set.raster.js';
+const sandbox = sinon.createSandbox();
+o.spec('TileSetCache', () => {
+  const imageOne = {
+    id: 'im_id1',
+    name: 'tasman_rural_2018-19_0-3m',
+    bounds: { x: 123, y: 456, width: 200, height: 300 },
+    files: [{ name: 'foo', x: 123, y: 456, width: 200, height: 300 }],
+    uri: 's3://foo/bar',
+  } as ConfigImagery;
+
+  const imageTwo = {
+    id: 'im_id2',
+    name: 'wellington_urban_2018-19_0-3m',
+    bounds: { x: 123, y: 456, width: 200, height: 300 },
+    files: [{ name: 'foo', x: 123, y: 456, width: 200, height: 300 }],
+    uri: 's3://foo/bar',
+  } as ConfigImagery;
+
+  const imgMap = new Map<string, ConfigImagery>();
+  imgMap.set(imageOne.id, imageOne);
+
+  o.beforeEach(() => {
+    sandbox.stub(Config, 'getTileSetImagery').callsFake(async () => {
+      const imgMap = new Map<string, ConfigImagery>();
+      imgMap.set(imageOne.id, imageOne);
+      return imgMap;
+    });
+  });
+
+  o.afterEach(() => {
+    TileSets.cache.clear();
+    sandbox.restore();
+  });
+
+  o.spec('loadTileSet', () => {
+    o('load individual set', async () => {
+      TileSets.add(new TileSetRaster('aerial@head', GoogleTms));
+
+      const parentTileSet = await TileSets.get('aerial@head', GoogleTms);
+      if (parentTileSet == null || parentTileSet.isVector()) throw new Error('null parentTileSet');
+      parentTileSet.imagery = imgMap;
+      parentTileSet.tileSet = {
+        name: 'parent',
+        title: 'parent aerial title',
+        background: { r: 200, g: 50, b: 100, alpha: 0.5 },
+      } as ConfigTileSetRaster;
+
+      const subTileSet = await TileSets.get('aerial@head:tasman_rural_2018-19_0-3m', GoogleTms);
+      if (subTileSet == null || subTileSet.isVector()) throw new Error('null subTileSet');
+
+      o(subTileSet.title).equals('parent aerial title Tasman rural 2018-19 0.3m');
+      o(subTileSet.fullName).equals('aerial@head:tasman_rural_2018-19_0-3m');
+      o([...subTileSet.imagery.values()]).deepEquals([imageOne]);
+      const [firstLayer] = subTileSet.tileSet.layers;
+      o(firstLayer).deepEquals({
+        name: firstLayer.name,
+        [3857]: 'im_id1',
+        minZoom: 0,
+        maxZoom: 100,
+      });
+      o(subTileSet.tileSet.background).equals(undefined);
+
+      o(parentTileSet.tileSet.background).deepEquals({ r: 200, g: 50, b: 100, alpha: 0.5 });
+
+      const noTiffs = subTileSet.getTiffsForTile({ x: 0, y: 0, z: 1 });
+      o(noTiffs).deepEquals([]);
+
+      const aTiff = subTileSet.getTiffsForTile({ x: 0, y: 0, z: 0 });
+      o(aTiff.length).equals(1);
+      o(aTiff[0].source.uri).equals('s3://foo/bar/foo.tiff');
+
+      TileSets.cache.delete(subTileSet.id);
+      delete parentTileSet.tileSet.title;
+      const subTileSetB = await TileSets.get('aerial@head:tasman_rural_2018-19_0-3m', GoogleTms);
+      if (subTileSetB == null || subTileSetB.isVector()) throw new Error('null subTileSetB');
+      o(subTileSetB.title).equals('parent Tasman rural 2018-19 0.3m');
+    });
+  });
+
+  o.spec('loadTileSets', () => {
+    o('load all', async () => {
+      sandbox.stub(Config.TileSet, 'get');
+
+      TileSets.add(new TileSetRaster('aerial', GoogleTms));
+      TileSets.add(new TileSetRaster('aerial', Nztm2000Tms));
+      const tileSets = await TileSets.getAll('aerial', null);
+
+      o(tileSets.length).deepEquals(2);
+
+      o(tileSets[0].fullName).equals(TileSetName.aerial);
+      o(tileSets[0].components.name).equals(TileSetName.aerial);
+      o(tileSets[0].tileMatrix.projection.code).equals(3857);
+
+      o(tileSets[1].fullName).equals(TileSetName.aerial);
+      o(tileSets[1].components.name).equals(TileSetName.aerial);
+      o(tileSets[1].tileMatrix.projection.code).equals(2193);
+    });
+
+    o('load all subset projections', async () => {
+      sandbox.stub(Config.TileSet, 'get');
+
+      const ts1 = new TileSetRaster('aerial@head', Nztm2000Tms);
+      ts1.imagery = imgMap;
+      TileSets.add(ts1);
+      const ts2 = new TileSetRaster('aerial@head', GoogleTms);
+      ts2.imagery = imgMap;
+      TileSets.add(ts2);
+      const tileSets = await TileSets.getAll('aerial@head:tasman_rural_2018-19_0-3m', null);
+
+      o(tileSets.length).deepEquals(2);
+
+      o(tileSets[0].fullName).equals('aerial@head:tasman_rural_2018-19_0-3m');
+      o(tileSets[0].tileMatrix.projection).equals(Epsg.Google);
+      o(tileSets[1].fullName).equals('aerial@head:tasman_rural_2018-19_0-3m');
+      o(tileSets[1].tileMatrix.projection).equals(Epsg.Nztm2000);
+    });
+
+    o('load all @tag', async () => {
+      sandbox.stub(Config.TileSet, 'get');
+      const imgMap = new Map();
+      imgMap.set(imageOne.id, imageOne);
+      imgMap.set(imageTwo.id, imageTwo);
+      const ts1 = new TileSetRaster('aerial@head', Nztm2000Tms);
+      ts1.imagery = imgMap;
+      TileSets.add(ts1);
+
+      const tileSets = await TileSets.getAll('aerial@head', null);
+
+      o(tileSets.length).deepEquals(3);
+
+      o(tileSets[0].fullName).equals('aerial@head');
+      o(tileSets[1].fullName).equals('aerial@head:tasman_rural_2018-19_0-3m');
+      o(tileSets[2].fullName).equals('aerial@head:wellington_urban_2018-19_0-3m');
+    });
+  });
+});

package/src/__test__/tile.set.test.ts

@@ -0,0 +1,19 @@
+import { ConfigImagery } from '@basemaps/config';
+import { GoogleTms, Nztm2000Tms } from '@basemaps/geo';
+import o from 'ospec';
+import { TileSetRaster } from '../tile.set.raster.js';
+
+o.spec('tile.set', () => {
+  o('basePath', () => {
+    const rec = { uri: 's3://test-bucket/3857/aerail/job123' } as ConfigImagery;
+    o(TileSetRaster.basePath(rec)).equals('s3://test-bucket/3857/aerail/job123');
+    o(TileSetRaster.basePath(rec, '31223')).equals('s3://test-bucket/3857/aerail/job123/31223.tiff');
+  });
+
+  o('extent', () => {
+    o(new TileSetRaster('google', GoogleTms).extent.toBbox()).deepEquals([
+      -20037508.3427892, -20037508.3427892, 20037508.3427892, 20037508.3427892,
+    ]);
+    o(new TileSetRaster('nztm', Nztm2000Tms).extent.toBbox()).deepEquals([274000, 3087000, 3327000, 7173000]);
+  });
+});

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

@@ -0,0 +1,265 @@
+import { Bounds, Epsg, GoogleTms, Nztm2000QuadTms, Nztm2000Tms } from '@basemaps/geo';
+import { TileSetName, V, VNodeElement } from '@basemaps/shared';
+import { roundNumbersInString } from '@basemaps/test/build/rounding.js';
+import { createHash } from 'crypto';
+import o from 'ospec';
+import { WmtsCapabilities } from '../wmts.capability.js';
+import { FakeTileSet, Provider } from './xyz.util.js';
+
+import 'source-map-support/register.js';
+
+function tags(node: VNodeElement | null | undefined, tag: string): VNodeElement[] {
+  if (node == null) return [];
+  return [...node.tags(tag)];
+}
+function listTag(node: VNodeElement | null | undefined, tag: string): string[] {
+  return tags(node, tag).map((n) => n.toString());
+}
+
+o.spec('WmtsCapabilities', () => {
+  const apiKey = 'secret1234';
+  const tileSet = new FakeTileSet(TileSetName.aerial, GoogleTms);
+  const tileSetImagery = new FakeTileSet('01E7PJFR9AMQFJ05X9G7FQ3XMW', GoogleTms);
+
+  o('should build capability xml for tileset and projection', () => {
+    const wmts = new WmtsCapabilities('https://basemaps.test', Provider, [tileSet], apiKey);
+
+    const raw = wmts.toVNode();
+    const serviceId = raw.find('ows:ServiceIdentification');
+
+    o(serviceId?.find('ows:Abstract')?.textContent).equals('the description');
+    o(serviceId?.find('ows:Title')?.textContent).equals('the title');
+
+    o(raw.find('TileMatrixSetLink')?.toString()).deepEquals(
+      V('TileMatrixSetLink', [V('TileMatrixSet', 'EPSG:3857')]).toString(),
+    );
+
+    const layer = raw?.find('Contents', 'Layer');
+
+    o(listTag(layer, 'Format')).deepEquals([
+      V('Format', 'image/jpeg').toString(),
+      V('Format', 'image/webp').toString(),
+      V('Format', 'image/png').toString(),
+    ]);
+
+    o(listTag(layer, 'ows:BoundingBox')).deepEquals([
+      V('ows:BoundingBox', { crs: Epsg.Google.toUrn() }, [
+        V('ows:LowerCorner', '-20037508.3427892 -20037508.3427892'),
+        V('ows:UpperCorner', '20037508.3427892 20037508.3427892'),
+      ]).toString(),
+    ]);
+
+    o(listTag(layer, 'ows:WGS84BoundingBox').map((s) => roundNumbersInString(s, 4))).deepEquals([
+      '<ows:WGS84BoundingBox crs="urn:ogc:def:crs:OGC:2:84">\n' +
+        '  <ows:LowerCorner>-180 -85.0511</ows:LowerCorner>\n' +
+        '  <ows:UpperCorner>180 85.0511</ows:UpperCorner>\n' +
+        '</ows:WGS84BoundingBox>',
+    ]);
+
+    o(layer?.find('ows:Abstract')?.textContent).equals('aerial:description');
+    o(layer?.find('ows:Title')?.textContent).equals('aerial:title');
+    o(layer?.find('ows:Identifier')?.textContent).equals('aerial');
+
+    o(layer?.find('Style')?.toString()).equals(
+      V('Style', { isDefault: 'true' }, [V('ows:Title', 'Default Style'), V('ows:Identifier', 'default')]).toString(),
+    );
+
+    const urls = tags(layer, 'ResourceURL');
+    o(urls.length).equals(3);
+    o(urls[2].toString()).deepEquals(
+      '<ResourceURL format="image/png" resourceType="tile" ' +
+        'template="https://basemaps.test/v1/tiles/aerial/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.png?api=secret1234" />',
+    );
+
+    o(layer?.find('TileMatrixSetLink', 'TileMatrixSet')?.textContent).equals('EPSG:3857');
+
+    const matrix = tags(raw, 'TileMatrixSet')[1];
+    const matrixId = raw?.find('Contents', 'TileMatrixSet', 'ows:Identifier') ?? null;
+    o(matrix.find('ows:Identifier')).equals(matrixId);
+    o(matrixId?.textContent).equals('EPSG:3857');
+
+    o(matrix.find('ows:SupportedCRS')?.textContent).deepEquals('urn:ogc:def:crs:EPSG::3857');
+    o(matrix.find('WellKnownScaleSet')?.textContent).deepEquals(
+      'https://www.opengis.net/def/wkss/OGC/1.0/GoogleMapsCompatible',
+    );
+
+    const tileMatrices = Array.from(matrix.tags('TileMatrix'));
+
+    o(tileMatrices.length).equals(25);
+
+    function compareMatrix(x: VNodeElement, id: string, tileCount: number, scale: number): void {
+      o(x.find('ows:Identifier')?.toString()).equals(`<ows:Identifier>${id}</ows:Identifier>`);
+      o(x.find('ScaleDenominator')?.toString()).equals(`<ScaleDenominator>${scale}</ScaleDenominator>`);
+      o(x.find('TopLeftCorner')?.toString()).equals(
+        `<TopLeftCorner>-20037508.3427892 20037508.3427892</TopLeftCorner>`,
+      );
+      o(x.find('TileWidth')?.toString()).equals(`<TileWidth>256</TileWidth>`);
+      o(x.find('TileHeight')?.toString()).equals(`<TileHeight>256</TileHeight>`);
+      o(x.find('MatrixWidth')?.toString()).equals(`<MatrixWidth>${tileCount}</MatrixWidth>`);
+      o(x.find('MatrixHeight')?.toString()).equals(`<MatrixHeight>${tileCount}</MatrixHeight>`);
+    }
+
+    compareMatrix(tileMatrices[0], '0', 1, 559082264.028717);
+    compareMatrix(tileMatrices[10], '10', 1024, 545978.773465544);
+
+    const xml = WmtsCapabilities.toXml('https://basemaps.test', Provider, [tileSet], apiKey) ?? '';
+
+    o(xml).deepEquals('<?xml version="1.0"?>\n' + raw?.toString());
+
+    o(createHash('sha256').update(Buffer.from(xml)).digest('base64')).equals(
+      'beknYyMt8v74vK4p84AS3c1OnBSJ+ZE0kan+mMVQS1A=',
+    );
+  });
+
+  o('should allow individual imagery sets', () => {
+    const raw = new WmtsCapabilities('https://basemaps.test', Provider, [tileSetImagery]).toVNode();
+
+    const tms = raw?.find('TileMatrixSet', 'ows:Identifier');
+
+    o(tms?.textContent).equals('EPSG:3857');
+
+    const urls = Array.from(raw ? raw.tags('ResourceURL') : []);
+    o(urls.length).equals(3);
+    o(urls[2].toString()).deepEquals(
+      '<ResourceURL format="image/png" resourceType="tile" ' +
+        'template="https://basemaps.test/v1/tiles/01E7PJFR9AMQFJ05X9G7FQ3XMW/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.png" />',
+    );
+  });
+
+  o('should support multiple projections', () => {
+    const ts = [new FakeTileSet(TileSetName.aerial, Nztm2000Tms), new FakeTileSet(TileSetName.aerial, GoogleTms)];
+    const xml = new WmtsCapabilities('basemaps.test', Provider, ts);
+    const nodes = xml.toVNode();
+
+    const layers = tags(nodes, 'Layer');
+    o(layers.length).equals(1);
+    const layer = layers[0];
+
+    // ensure order is valid
+    o(layer?.children.map((c) => (c instanceof VNodeElement ? c.tag : null))).deepEquals([
+      'ows:Title',
+      'ows:Abstract',
+      'ows:Identifier',
+      'ows:BoundingBox',
+      'ows:BoundingBox',
+      'ows:WGS84BoundingBox',
+      'Style',
+      'Format',
+      'Format',
+      'Format',
+      'TileMatrixSetLink',
+      'TileMatrixSetLink',
+      'ResourceURL',
+      'ResourceURL',
+      'ResourceURL',
+    ]);
+
+    const sets = tags(layer, 'TileMatrixSet');
+
+    o(sets.length).equals(2);
+    o(sets[0].toString()).equals('<TileMatrixSet>EPSG:2193</TileMatrixSet>');
+    o(sets[1].toString()).equals('<TileMatrixSet>EPSG:3857</TileMatrixSet>');
+
+    const tms = tags(nodes, 'TileMatrixSet').filter((f) => f.find('ows:SupportedCRS') != null);
+    o(tms.length).equals(2);
+
+    o(tms[0].find('ows:Identifier')?.textContent).equals('EPSG:2193');
+    o(tms[0].find('ows:SupportedCRS')?.textContent).equals('urn:ogc:def:crs:EPSG::2193');
+
+    o(tms[1].find('ows:Identifier')?.textContent).equals('EPSG:3857');
+    o(tms[1].find('ows:SupportedCRS')?.textContent).equals('urn:ogc:def:crs:EPSG::3857');
+  });
+
+  o('should support multiple tilesets', () => {
+    const ts = [
+      new FakeTileSet(TileSetName.aerial, Nztm2000Tms, 'aerial-title'),
+      new FakeTileSet('01E7PJFR9AMQFJ05X9G7FQ3XMW', Nztm2000Tms, 'imagery-title'),
+    ];
+    const nodes = new WmtsCapabilities('basemaps.test', Provider, ts).toVNode();
+    const layers = tags(nodes, 'Layer');
+    o(layers.length).equals(2);
+
+    o(layers[0].find('ows:Title')?.textContent).equals('aerial-title');
+    o(layers[0].find('TileMatrixSet')?.textContent).equals('EPSG:2193');
+
+    o(layers[1].find('ows:Title')?.textContent).equals('imagery-title');
+    o(layers[1].find('TileMatrixSet')?.textContent).equals('EPSG:2193');
+  });
+
+  o('should support child tile sets', () => {
+    const ts = [
+      new FakeTileSet(
+        `${TileSetName.aerial}:wairoa_urban_2014-2015_0-10m_RGBA`,
+        Nztm2000Tms,
+        'wairoa_urban_2014-2015_0-10m_RGBA',
+      ),
+      new FakeTileSet(
+        `${TileSetName.aerial}:west-coast_rural_2016-17_0-3m`,
+        Nztm2000Tms,
+        'west-coast_rural_2016-17_0-3m',
+      ),
+    ];
+    const nodes = new WmtsCapabilities('basemaps.test', Provider, ts).toVNode();
+    const layers = tags(nodes, 'Layer');
+
+    o(layers.length).equals(2);
+
+    const boundingBoxes = tags(layers[0], 'ows:BoundingBox');
+    o(boundingBoxes.length).equals(1);
+
+    const firstTitle = layers[0].children[0].textContent;
+    o(firstTitle).equals('wairoa_urban_2014-2015_0-10m_RGBA');
+    const secondTitle = layers[1].children[0].textContent;
+    o(secondTitle).equals('west-coast_rural_2016-17_0-3m');
+  });
+
+  o('should support multiple different projections on different tiles sets', () => {
+    const ts = [
+      new FakeTileSet(TileSetName.aerial, Nztm2000Tms, TileSetName.aerial),
+      new FakeTileSet('01F75X9G7FQ3XMWPJFR9AMQFJ0', Nztm2000Tms, '01F75X9G7FQ3XMWPJFR9AMQFJ0'),
+      new FakeTileSet('01E7PJFR9AMQFJ05X9G7FQ3XMW', GoogleTms, '01E7PJFR9AMQFJ05X9G7FQ3XMW'),
+      new FakeTileSet('01E7PJFR9AMQFJ05X9G7FQ3XMW', Nztm2000QuadTms, '01E7PJFR9AMQFJ05X9G7FQ3XMW'),
+    ];
+    ts[1].extentOverride = new Bounds(1, 2, 2, 2);
+
+    ts[2].tileSet.title = 'aerial_dunedin_urban';
+    const nodes = new WmtsCapabilities('basemaps.test', Provider, ts).toVNode();
+
+    const allMatrixes = tags(nodes, 'TileMatrixSet');
+
+    o(allMatrixes[0].children[0].textContent).equals('EPSG:2193');
+    o(allMatrixes[1].children[0].textContent).equals('EPSG:2193');
+    o(allMatrixes[2].children[0].textContent).equals('EPSG:3857');
+    o(allMatrixes[3].children[0].textContent).equals('NZTM2000Quad');
+
+    o(allMatrixes[4].find('ows:Identifier')?.textContent).equals('EPSG:2193');
+    o(allMatrixes[5].find('ows:Identifier')?.textContent).equals('EPSG:3857');
+    o(allMatrixes[6].find('ows:Identifier')?.textContent).equals('NZTM2000Quad');
+    o(allMatrixes.length).equals(7);
+
+    const layers = tags(nodes, 'Layer');
+    o(layers.length).equals(3);
+
+    o(layers[0].find('ows:Title')?.textContent).equals(TileSetName.aerial);
+    o(layers[0].find('TileMatrixSet')?.textContent).equals('EPSG:2193');
+
+    o(layers[1].find('ows:Identifier')?.textContent).equals('01F75X9G7FQ3XMWPJFR9AMQFJ0');
+    o(layers[1].find('TileMatrixSet')?.textContent).equals('EPSG:2193');
+    o(layers[1].find('ows:BoundingBox')?.toString()).equals(
+      '<ows:BoundingBox crs="urn:ogc:def:crs:EPSG::2193">\n' +
+        '  <ows:LowerCorner>2 1</ows:LowerCorner>\n' +
+        '  <ows:UpperCorner>4 3</ows:UpperCorner>\n' +
+        '</ows:BoundingBox>',
+    );
+
+    o(layers[2].find('ows:Title')?.textContent).equals('aerial_dunedin_urban');
+    o(layers[2].find('ows:Identifier')?.textContent).equals('01E7PJFR9AMQFJ05X9G7FQ3XMW');
+    o(layers[2].find('TileMatrixSet')?.textContent).equals('EPSG:3857');
+    o(layers[2].find('ows:BoundingBox')?.toString()).equals(
+      '<ows:BoundingBox crs="urn:ogc:def:crs:EPSG::3857">\n' +
+        '  <ows:LowerCorner>-20037508.3427892 -20037508.3427892</ows:LowerCorner>\n' +
+        '  <ows:UpperCorner>20037508.3427892 20037508.3427892</ows:UpperCorner>\n' +
+        '</ows:BoundingBox>',
+    );
+  });
+});