@basemaps/lambda-tiler 6.46.0 → 7.1.0

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

@@ -1,13 +1,15 @@
-import o from 'ospec';
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
 import { isAllowedFile } from '../imagery.js';
 
-o.spec('ImageryRoute', () => {
-  o('should allow geojson and json files only', () => {
-    o(isAllowedFile('foo.geojson')).equals(true);
-    o(isAllowedFile('foo.json')).equals(true);
-    o(isAllowedFile('foo.tiff')).equals(false);
-    o(isAllowedFile('foo')).equals(false);
-    o(isAllowedFile('')).equals(false);
-    o(isAllowedFile(null as any)).equals(false);
+describe('ImageryRoute', () => {
+  it('should allow geojson and json files only', () => {
+    assert.equal(isAllowedFile('foo.geojson'), true);
+    assert.equal(isAllowedFile('foo.json'), true);
+    assert.equal(isAllowedFile('foo.tiff'), false);
+    assert.equal(isAllowedFile('foo'), false);
+    assert.equal(isAllowedFile(''), false);
+    assert.equal(isAllowedFile(null as any), false);
   });
 });

package/src/routes/__tests__/preview.index.test.ts

@@ -1,16 +1,18 @@
-import { Env, LogConfig, V, fsa } from '@basemaps/shared';
+import assert from 'node:assert';
+import { afterEach, beforeEach, describe, it } from 'node:test';
+
+import { ConfigProviderMemory, DefaultColorRampOutput, DefaultTerrainRgbOutput } from '@basemaps/config';
+import { LocationUrl } from '@basemaps/geo';
+import { Env, fsa, FsMemory, LogConfig, V } from '@basemaps/shared';
 import { LambdaAlbRequest, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { ALBEvent, Context } from 'aws-lambda';
-import o from 'ospec';
 
-import { PreviewIndexGet, loadAndServeIndexHtml, previewIndexGet } from '../preview.index.js';
-import { LocationUrl } from '@basemaps/geo';
-import { FsMemory } from '@chunkd/source-memory';
-import { ConfigProviderMemory } from '@basemaps/config';
 import { FakeData } from '../../__tests__/config.data.js';
+import { CachedConfig } from '../../util/config.cache.js';
+import { loadAndServeIndexHtml, PreviewIndexGet, previewIndexGet } from '../preview.index.js';
 
-o.spec('/@*', async () => {
-  o.specTimeout(1000);
+describe('/@*', async () => {
+  // o.specTimeout(1000);
   const baseRequest: ALBEvent = {
     requestContext: null as any,
     httpMethod: 'get',
@@ -21,51 +23,63 @@ o.spec('/@*', async () => {
 
   const fsMem = new FsMemory();
   let lastLocation: string | undefined;
-  o.beforeEach(() => {
+  beforeEach(async () => {
+    CachedConfig.cache.clear();
+
     fsa.register('memory://', fsMem);
+
+    const indexHtml = V('html', [
+      V('head', [
+        V('meta', { property: 'og:title', content: 'LINZ Basemaps' }),
+        V('meta', { property: 'og:image', content: '/basemaps-card.jpeg' }),
+        V('meta', { name: 'viewport' }),
+      ]),
+    ]).toString();
+    await fsa.write(new URL('memory://assets/index.html'), indexHtml);
+
     lastLocation = process.env[Env.StaticAssetLocation];
   });
-  o.afterEach(() => {
+  afterEach(() => {
     if (lastLocation == null) delete process.env[Env.StaticAssetLocation];
     else process.env[Env.StaticAssetLocation] = lastLocation;
   });
 
-  o('Should redirect on failure to load', async () => {
+  it('Should redirect on failure to load', async () => {
     const ctx: LambdaHttpRequest = new LambdaAlbRequest(baseRequest, {} as Context, LogConfig.get());
 
     const res = await loadAndServeIndexHtml(ctx);
-    o(res.status).equals(302);
-    o(res.header('location')).equals('/?');
+    assert.equal(res.status, 302);
+    assert.equal(res.header('location'), '/?');
   });
 
-  o('Should redirect with querystring on failure to load', async () => {
+  it('Should redirect with querystring on failure to load', async () => {
     const evt: ALBEvent = { ...baseRequest, queryStringParameters: { config: 'config-latest.json' } };
     const ctx: LambdaHttpRequest = new LambdaAlbRequest(evt, {} as Context, LogConfig.get());
 
     const res = await loadAndServeIndexHtml(ctx);
-    o(res.status).equals(302);
-    o(res.header('location')).equals('/?config=config-latest.json');
+    assert.equal(res.status, 302);
+    assert.equal(res.header('location'), '/?config=config-latest.json');
   });
 
-  o('Should redirect with querystring and location on failure to load', async () => {
+  it('Should redirect with querystring and location on failure to load', async () => {
     const evt: ALBEvent = { ...baseRequest, queryStringParameters: { config: 'config-latest.json' } };
     const loc = LocationUrl.fromSlug(evt.path);
     const ctx: LambdaHttpRequest = new LambdaAlbRequest(evt, {} as Context, LogConfig.get());
 
     const res = await loadAndServeIndexHtml(ctx, loc);
-    o(res.status).equals(302);
-    o(res.header('location')).equals('/?config=config-latest.json#@-41.8900012,174.0492432,z5');
+    assert.equal(res.status, 302);
+    assert.equal(res.header('location'), '/?config=config-latest.json#@-41.8900012,174.0492432,z5');
   });
 
-  o('should redirect on failure to load index.html', async () => {
+  it('should redirect on failure to load index.html', async () => {
     const ctx: LambdaHttpRequest = new LambdaAlbRequest(baseRequest, {} as Context, LogConfig.get());
-    process.env[Env.StaticAssetLocation] = 'memory://assets/';
+    process.env[Env.StaticAssetLocation] = 'memory://assets-missing/';
 
     const res = await loadAndServeIndexHtml(ctx);
-    o(res.status).equals(302);
+    assert.equal(res.status, 302);
   });
 
-  o('should redirect with new tags!', async () => {
+  it('should redirect with new tags!', async () => {
     const ctx = new LambdaAlbRequest(baseRequest, {} as Context, LogConfig.get());
     process.env[Env.StaticAssetLocation] = 'memory://assets/';
 
@@ -77,18 +91,20 @@ o.spec('/@*', async () => {
       ]),
     ]).toString();
 
-    await fsa.write('memory://assets/index.html', indexHtml);
+    await fsa.write(new URL('memory://assets/index.html'), indexHtml);
 
     // Pass back the body un altered
     const res = await loadAndServeIndexHtml(ctx);
-    o(getBody(res)?.toString()).equals(indexHtml);
+    assert.equal(getBody(res)?.toString(), indexHtml);
 
     // Replace og:title with a <fake tag />
     const resB = await loadAndServeIndexHtml(ctx, null, new Map([['og:title', '<fake tag />']]));
-    o(getBody(resB)?.toString().includes('<fake tag />')).equals(true);
+    assert.equal(getBody(resB)?.toString().includes('<fake tag />'), true);
   });
 
-  o('should include config url', async () => {
+  it('should include config url', async () => {
+    process.env[Env.StaticAssetLocation] = 'memory://assets/';
+
     const ctx = new LambdaAlbRequest(
       {
         ...baseRequest,
@@ -99,32 +115,90 @@ o.spec('/@*', async () => {
     ) as unknown as LambdaHttpRequest<PreviewIndexGet>;
     ctx.params = { location: '@-41.8900012,174.0492432,z5' };
 
-    // Create a fake config to use
     const expectedConfig = new ConfigProviderMemory();
     expectedConfig.put(FakeData.tileSetRaster('imagery-name'));
-    await fsa.write('memory://linz-basemaps/config-latest.json', JSON.stringify(expectedConfig.toJson()));
+    await fsa.write(new URL('memory://linz-basemaps/config-latest.json'), JSON.stringify(expectedConfig.toJson()));
+
+    const res = await previewIndexGet(ctx);
+    assert.equal(res.status, 200);
 
+    const ogImage = getBody(res)
+      ?.toString()
+      .split('\n')
+      .find((f) => f.includes('og:image'));
+    assert.equal(
+      ogImage,
+      '<meta name="twitter:image" property="og:image" content="/v1/preview/imagery-name/WebMercatorQuad/5/174.0492432/-41.8900012?config=QzX7ZsK6qG6p42wHZaF9dhihsgprX942gAuKwfryknM429iqxdDiRSGu" />',
+    );
+  });
+
+  it('should include default pipeline', { only: true }, async () => {
     process.env[Env.StaticAssetLocation] = 'memory://assets/';
 
-    const indexHtml = V('html', [
-      V('head', [
-        V('meta', { property: 'og:title', content: 'LINZ Basemaps' }),
-        V('meta', { property: 'og:image', content: '/basemaps-card.jepg' }),
-        V('meta', { name: 'viewport' }),
-      ]),
-    ]).toString();
+    const ctx = new LambdaAlbRequest(
+      {
+        ...baseRequest,
+        queryStringParameters: { config: 'memory://linz-basemaps/config-latest.json', i: 'imagery-name' },
+      },
+      {} as Context,
+      LogConfig.get(),
+    ) as unknown as LambdaHttpRequest<PreviewIndexGet>;
+    ctx.params = { location: '@-41.8900012,174.0492432,z5' };
 
-    await fsa.write('memory://assets/index.html', indexHtml);
+    const expectedConfig = new ConfigProviderMemory();
+    const ts = FakeData.tileSetRaster('imagery-name');
+    ts.outputs = [DefaultTerrainRgbOutput, DefaultColorRampOutput];
+    expectedConfig.put(ts);
+    await fsa.write(new URL('memory://linz-basemaps/config-latest.json'), JSON.stringify(expectedConfig.toJson()));
 
     const res = await previewIndexGet(ctx);
-    o(res.status).equals(200);
+    assert.equal(res.status, 200, res.statusDescription);
 
     const ogImage = getBody(res)
       ?.toString()
       .split('\n')
       .find((f) => f.includes('og:image'));
-    o(ogImage).equals(
-      '<meta name="twitter:image" property="og:image" content="/v1/preview/imagery-name/WebMercatorQuad/5/174.0492432/-41.8900012?config=QzX7ZsK6qG6p42wHZaF9dhihsgprX942gAuKwfryknM429iqxdDiRSGu" />',
+
+    assert.equal(
+      ogImage,
+      '<meta name="twitter:image" property="og:image" content="/v1/preview/imagery-name/WebMercatorQuad/5/174.0492432/-41.8900012?config=QzX7ZsK6qG6p42wHZaF9dhihsgprX942gAuKwfryknM429iqxdDiRSGu&pipeline=terrain-rgb" />',
+    );
+  });
+
+  it('should include pipelines', async () => {
+    process.env[Env.StaticAssetLocation] = 'memory://assets/';
+
+    const ctx = new LambdaAlbRequest(
+      {
+        ...baseRequest,
+        queryStringParameters: {
+          config: 'memory://linz-basemaps/config-latest.json',
+          i: 'imagery-name',
+          pipeline: 'color-ramp',
+        },
+      },
+      {} as Context,
+      LogConfig.get(),
+    ) as unknown as LambdaHttpRequest<PreviewIndexGet>;
+    ctx.params = { location: '@-41.8900012,174.0492432,z5' };
+
+    const expectedConfig = new ConfigProviderMemory();
+    const ts = FakeData.tileSetRaster('imagery-name');
+    ts.outputs = [DefaultTerrainRgbOutput, DefaultColorRampOutput];
+    expectedConfig.put(ts);
+    await fsa.write(new URL('memory://linz-basemaps/config-latest.json'), JSON.stringify(expectedConfig.toJson()));
+
+    const res = await previewIndexGet(ctx);
+    assert.equal(res.status, 200, res.statusDescription);
+
+    const ogImage = getBody(res)
+      ?.toString()
+      .split('\n')
+      .find((f) => f.includes('og:image'));
+
+    assert.equal(
+      ogImage,
+      '<meta name="twitter:image" property="og:image" content="/v1/preview/imagery-name/WebMercatorQuad/5/174.0492432/-41.8900012?config=QzX7ZsK6qG6p42wHZaF9dhihsgprX942gAuKwfryknM429iqxdDiRSGu&pipeline=color-ramp" />',
     );
   });
 });

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

@@ -1,69 +1,74 @@
+import assert from 'node:assert';
+import { afterEach, before, beforeEach, describe, it } from 'node:test';
+
 import { ConfigProviderMemory } from '@basemaps/config';
-import { fsa } from '@chunkd/fs';
-import o from 'ospec';
+import { fsa, FsMemory } from '@chunkd/fs';
 import { createSandbox } from 'sinon';
 import { gunzipSync, gzipSync } from 'zlib';
+
+import { mockRequest } from '../../__tests__/xyz.util.js';
 import { handler } from '../../index.js';
 import { ConfigLoader } from '../../util/config.loader.js';
-import { mockRequest } from '../../__tests__/xyz.util.js';
-import { FsMemory } from '@chunkd/source-memory';
 
-o.spec('/v1/sprites', () => {
+describe('/v1/sprites', () => {
   const memory = new FsMemory();
   const sandbox = createSandbox();
   const config = new ConfigProviderMemory();
 
-  o.before(() => {
-    fsa.register('memory://', memory);
+  before(() => {
+    fsa.register('fake-s3://assets/', memory);
   });
 
-  o.beforeEach(() => {
-    config.assets = 'memory://';
+  beforeEach(() => {
+    config.assets = 'fake-s3://assets/';
     sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
   });
 
-  o.afterEach(() => {
+  afterEach(() => {
     memory.files.clear();
     sandbox.restore();
   });
 
-  o('should fetch a json document', async () => {
+  it('should fetch a json document', async () => {
     await Promise.all([
-      fsa.write('memory://sprites/topographic.json', Buffer.from(JSON.stringify({ test: true }))),
-      fsa.write('memory://sprites/topographic.png', Buffer.from('')),
+      fsa.write(new URL('fake-s3://assets/sprites/topographic.json'), Buffer.from(JSON.stringify({ test: true }))),
+      fsa.write(new URL('fake-s3://assets/sprites/topographic.png'), Buffer.from('')),
     ]);
     const res = await handler.router.handle(mockRequest('/v1/sprites/topographic.json'));
-    o(res.status).equals(200);
-    o(res.header('content-type')).equals('application/json');
-    o(res.header('content-encoding')).equals(undefined);
-    o(res.header('etag')).notEquals(undefined);
-    o(res.header('cache-control')).equals('public, max-age=604800, stale-while-revalidate=86400');
+    assert.equal(res.status, 200);
+    assert.equal(res.header('content-type'), 'application/json');
+    assert.equal(res.header('content-encoding'), undefined);
+    assert.notEqual(res.header('etag'), undefined);
+    assert.equal(res.header('cache-control'), 'public, max-age=604800, stale-while-revalidate=86400');
 
-    o(JSON.parse(Buffer.from(res.body, 'base64').toString())).deepEquals({ test: true });
+    assert.deepEqual(JSON.parse(Buffer.from(res.body, 'base64').toString()), { test: true });
   });
 
-  o('should fetch a png', async () => {
+  it('should fetch a png', async () => {
     await Promise.all([
-      fsa.write('memory://sprites/topographic.json', Buffer.from(JSON.stringify({ test: true }))),
-      fsa.write('memory://sprites/topographic@2x.png', Buffer.from('')),
+      fsa.write(new URL('fake-s3://assets/sprites/topographic.json'), Buffer.from(JSON.stringify({ test: true }))),
+      fsa.write(new URL('fake-s3://assets/sprites/topographic@2x.png'), Buffer.from('')),
     ]);
     const res = await handler.router.handle(mockRequest('/v1/sprites/topographic@2x.png'));
-    o(res.status).equals(200);
-    o(res.header('content-type')).equals('image/png');
-    o(res.header('etag')).notEquals(undefined);
-    o(res.header('cache-control')).equals('public, max-age=604800, stale-while-revalidate=86400');
+    assert.equal(res.status, 200);
+    assert.equal(res.header('content-type'), 'image/png');
+    assert.notEqual(res.header('etag'), undefined);
+    assert.equal(res.header('cache-control'), 'public, max-age=604800, stale-while-revalidate=86400');
   });
 
-  o('should detect gziped files and set content-encoding', async () => {
+  it('should detect gziped files and set content-encoding', async () => {
     await Promise.all([
-      fsa.write('memory://sprites/topographic.json', gzipSync(Buffer.from(JSON.stringify({ test: true })))),
+      fsa.write(
+        new URL('fake-s3://assets/sprites/topographic.json'),
+        gzipSync(Buffer.from(JSON.stringify({ test: true }))),
+      ),
     ]);
     const res = await handler.router.handle(mockRequest('/v1/sprites/topographic.json'));
-    o(res.status).equals(200);
-    o(res.header('content-type')).equals('application/json');
-    o(res.header('content-encoding')).equals('gzip');
-    o(res.header('etag')).notEquals(undefined);
-    o(res.header('cache-control')).equals('public, max-age=604800, stale-while-revalidate=86400');
-    o(JSON.parse(gunzipSync(Buffer.from(res.body, 'base64')).toString())).deepEquals({ test: true });
+    assert.equal(res.status, 200);
+    assert.equal(res.header('content-type'), 'application/json');
+    assert.equal(res.header('content-encoding'), 'gzip');
+    assert.notEqual(res.header('etag'), undefined);
+    assert.equal(res.header('cache-control'), 'public, max-age=604800, stale-while-revalidate=86400');
+    assert.deepEqual(JSON.parse(gunzipSync(Buffer.from(res.body, 'base64')).toString()), { test: true });
   });
 });

package/src/routes/__tests__/tile.json.test.ts

@@ -1,68 +1,70 @@
+import assert from 'node:assert';
+import { afterEach, before, beforeEach, describe, it } from 'node:test';
+
 import { base58, ConfigProviderMemory } from '@basemaps/config';
 import { Env } from '@basemaps/shared';
-import { fsa } from '@chunkd/fs';
-import o from 'ospec';
+import { fsa, FsMemory } from '@chunkd/fs';
 import sinon from 'sinon';
+
+import { FakeData } from '../../__tests__/config.data.js';
+import { Api, mockRequest, mockUrlRequest } from '../../__tests__/xyz.util.js';
 import { handler } from '../../index.js';
 import { ConfigLoader } from '../../util/config.loader.js';
 import { CoSources } from '../../util/source.cache.js';
-import { FakeData } from '../../__tests__/config.data.js';
-import { Api, mockRequest, mockUrlRequest } from '../../__tests__/xyz.util.js';
-import { FsMemory } from '@chunkd/source-memory';
 
-o.spec('/v1/tiles/:tileSet/:tileMatrix/tile.json', () => {
+describe('/v1/tiles/:tileSet/:tileMatrix/tile.json', () => {
   const config = new ConfigProviderMemory();
   const sandbox = sinon.createSandbox();
 
-  o.before(() => {
+  before(() => {
     process.env[Env.PublicUrlBase] = 'https://tiles.test';
   });
 
-  o.beforeEach(() => {
+  beforeEach(() => {
     sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
     config.objects.clear();
     CoSources.cache.clear();
   });
 
-  o.afterEach(() => {
+  afterEach(() => {
     sandbox.restore();
   });
 
-  o('should 404 if invalid url is given', async () => {
+  it('should 404 if invalid url is given', async () => {
     const request = mockRequest('/v1/tiles/tile.json', 'get', Api.header);
 
     const res = await handler.router.handle(request);
-    o(res.status).equals(404);
+    assert.equal(res.status, 404);
   });
 
-  o('should support utf8 tilesets', async () => {
+  it('should support utf8 tilesets', async () => {
     const request = mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `api=${Api.key}`);
-    o(request.path).equals('/v1/tiles/%F0%9F%A6%84%20%F0%9F%8C%88/NZTM2000Quad/tile.json');
+    assert.equal(request.path, '/v1/tiles/%F0%9F%A6%84%20%F0%9F%8C%88/NZTM2000Quad/tile.json');
 
     const fakeTileSet = FakeData.tileSetRaster('🦄 🌈');
     config.put(fakeTileSet);
 
     const res = await handler.router.handle(request);
-    o(res.status).equals(200);
+    assert.equal(res.status, 200);
   });
 
-  o('should serve tile json for tile_set', async () => {
+  it('should serve tile json for tile_set', async () => {
     const request = mockRequest('/v1/tiles/aerial/NZTM2000Quad/tile.json', 'get', Api.header);
     const fakeTileSet = FakeData.tileSetRaster('aerial');
     config.put(fakeTileSet);
 
     const res = await handler.router.handle(request);
-    o(res.status).equals(200);
-    o(res.header('cache-control')).equals('no-store');
+    assert.equal(res.status, 200);
+    assert.equal(res.header('cache-control'), 'no-store');
 
     const body = Buffer.from(res.body ?? '', 'base64').toString();
-    o(JSON.parse(body)).deepEquals({
+    assert.deepEqual(JSON.parse(body), {
       tiles: [`https://tiles.test/v1/tiles/aerial/NZTM2000Quad/{z}/{x}/{y}.webp?api=${Api.key}`],
       tilejson: '3.0.0',
     });
   });
 
-  o('should use the correct format', async () => {
+  it('should use the correct format', async () => {
     const request = mockRequest('/v1/tiles/aerial/NZTM2000Quad/tile.json', 'get', Api.header);
     request.query.set('format', 'jpeg');
 
@@ -70,17 +72,17 @@ o.spec('/v1/tiles/:tileSet/:tileMatrix/tile.json', () => {
     config.put(fakeTileSet);
 
     const res = await handler.router.handle(request);
-    o(res.status).equals(200);
-    o(res.header('cache-control')).equals('no-store');
+    assert.equal(res.status, 200);
+    assert.equal(res.header('cache-control'), 'no-store');
 
     const body = Buffer.from(res.body ?? '', 'base64').toString();
-    o(JSON.parse(body)).deepEquals({
+    assert.deepEqual(JSON.parse(body), {
       tiles: [`https://tiles.test/v1/tiles/aerial/NZTM2000Quad/{z}/{x}/{y}.jpeg?api=${Api.key}`],
       tilejson: '3.0.0',
     });
   });
 
-  o('should use the correct format when multiple set', async () => {
+  it('should use the correct format when multiple set', async () => {
     const request = mockRequest('/v1/tiles/aerial/NZTM2000Quad/tile.json', 'get', Api.header);
     request.query.append('format', 'png');
     request.query.append('format', 'jpeg');
@@ -89,32 +91,32 @@ o.spec('/v1/tiles/:tileSet/:tileMatrix/tile.json', () => {
     config.put(fakeTileSet);
 
     const res = await handler.router.handle(request);
-    o(res.status).equals(200);
-    o(res.header('cache-control')).equals('no-store');
+    assert.equal(res.status, 200);
+    assert.equal(res.header('cache-control'), 'no-store');
 
     const body = Buffer.from(res.body ?? '', 'base64').toString();
-    o(JSON.parse(body)).deepEquals({
+    assert.deepEqual(JSON.parse(body), {
       tiles: [`https://tiles.test/v1/tiles/aerial/NZTM2000Quad/{z}/{x}/{y}.png?api=${Api.key}`],
       tilejson: '3.0.0',
     });
   });
 
-  o('should serve vector tiles', async () => {
+  it('should serve vector tiles', async () => {
     const request = mockRequest('/v1/tiles/topographic/EPSG:3857/tile.json', 'get', Api.header);
     const fakeTileSet = FakeData.tileSetVector('topographic');
     config.put(fakeTileSet);
 
     const res = await handler.router.handle(request);
-    o(res.status).equals(200);
+    assert.equal(res.status, 200);
 
     const body = Buffer.from(res.body ?? '', 'base64').toString();
-    o(JSON.parse(body)).deepEquals({
+    assert.deepEqual(JSON.parse(body), {
       tiles: [`https://tiles.test/v1/tiles/topographic/WebMercatorQuad/{z}/{x}/{y}.pbf?api=${Api.key}`],
       tilejson: '3.0.0',
     });
   });
 
-  o('should serve vector tiles with min/max zoom', async () => {
+  it('should serve vector tiles with min/max zoom', async () => {
     const fakeTileSet = FakeData.tileSetVector('fake-vector');
     fakeTileSet.maxZoom = 15;
     fakeTileSet.minZoom = 3;
@@ -122,10 +124,10 @@ o.spec('/v1/tiles/:tileSet/:tileMatrix/tile.json', () => {
     const request = mockRequest('/v1/tiles/fake-vector/WebMercatorQuad/tile.json', 'get', Api.header);
 
     const res = await handler.router.handle(request);
-    o(res.status).equals(200);
+    assert.equal(res.status, 200);
 
     const body = Buffer.from(res.body ?? '', 'base64').toString();
-    o(JSON.parse(body)).deepEquals({
+    assert.deepEqual(JSON.parse(body), {
       tiles: [`https://tiles.test/v1/tiles/fake-vector/WebMercatorQuad/{z}/{x}/{y}.pbf?api=${Api.key}`],
       maxzoom: 15,
       minzoom: 3,
@@ -133,25 +135,25 @@ o.spec('/v1/tiles/:tileSet/:tileMatrix/tile.json', () => {
     });
   });
 
-  o('should load from config bundle', async () => {
+  it('should load from config bundle', async () => {
     const memoryFs = new FsMemory();
     fsa.register('memory://', memoryFs);
     const fakeTileSet = FakeData.tileSetRaster('🦄 🌈');
 
     const cfgBundle = new ConfigProviderMemory();
     cfgBundle.put(fakeTileSet);
-    memoryFs.write('memory://linz-basemaps/bar.json', JSON.stringify(cfgBundle.toJson()));
+    memoryFs.write(new URL('memory://linz-basemaps/bar.json'), JSON.stringify(cfgBundle.toJson()));
 
     const configLocation = base58.encode(Buffer.from('memory://linz-basemaps/bar.json'));
     const request = mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=${configLocation}`, Api.header);
     const res = await handler.router.handle(request);
-    o(res.status).equals(200);
+    assert.equal(res.status, 200);
 
     const body = JSON.parse(Buffer.from(res.body, 'base64').toString());
-    o(body.tiles[0].includes(`config=${configLocation}`)).equals(true);
+    assert.equal(body.tiles[0].includes(`config=${configLocation}`), true);
   });
 
-  o('should serve convert zoom to tile matrix', async () => {
+  it('should serve convert zoom to tile matrix', async () => {
     const fakeTileSet = FakeData.tileSetVector('fake-vector');
     fakeTileSet.maxZoom = 15;
     fakeTileSet.minZoom = 1;
@@ -160,10 +162,10 @@ o.spec('/v1/tiles/:tileSet/:tileMatrix/tile.json', () => {
     const request = mockRequest('/v1/tiles/fake-vector/NZTM2000Quad/tile.json', 'get', Api.header);
 
     const res = await handler.router.handle(request);
-    o(res.status).equals(200);
+    assert.equal(res.status, 200);
 
     const body = Buffer.from(res.body ?? '', 'base64').toString();
-    o(JSON.parse(body)).deepEquals({
+    assert.deepEqual(JSON.parse(body), {
       tiles: [`https://tiles.test/v1/tiles/fake-vector/NZTM2000Quad/{z}/{x}/{y}.pbf?api=${Api.key}`],
       maxzoom: 13,
       minzoom: 0,