@basemaps/lambda-tiler 7.0.0 → 7.1.1

package/src/cli/render.tile.ts

@@ -1,34 +1,38 @@
 import { ConfigProviderMemory } from '@basemaps/config';
-import { initConfigFromUrls } from '@basemaps/config/build/json/tiff.config.js';
-import { ImageFormat, Tile, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
-import { LogConfig, setDefaultConfig } from '@basemaps/shared';
-import { fsa } from '@chunkd/fs';
+import { initConfigFromUrls } from '@basemaps/config-loader';
+import { Tile, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
+import { fsa, LogConfig, setDefaultConfig } from '@basemaps/shared';
 import { LambdaHttpRequest, LambdaUrlRequest, UrlEvent } from '@linzjs/lambda';
 import { Context } from 'aws-lambda';
-import { pathToFileURL } from 'url';
-import { TileXyzRaster } from '../routes/tile.xyz.raster.js';
+import { extname } from 'path';
 
-const target = pathToFileURL(`/home/blacha/tmp/imagery/southland-0.25-rural-2023/`);
-const tile = fromPath('/18/117833/146174.webp');
+import { TileXyzRaster } from '../routes/tile.xyz.raster.js';
 
-const outputFormat = ImageFormat.Webp;
+// Render configuration
+const source = fsa.toUrl(`/home/blacha/data/elevation/christchurch_2020-2021/`);
+const tile = fromPath('/14/7898/8615.webp');
+const pipeline: string | null = 'color-ramp';
 let tileMatrix: TileMatrixSet | null = null;
 
-/** Convert a tile path /:z/:x/:y.png into a tile */
-function fromPath(s: string): Tile {
+/** Convert a tile path /:z/:x/:y.png into a tile & extension */
+function fromPath(s: string): Tile & { extension: string } {
+  const ext = extname(s).slice(1);
   const parts = s.split('.')[0].split('/').map(Number);
   if (s.startsWith('/')) parts.shift();
   if (parts.length !== 3) throw new Error(`Invalid tile path ${s}`);
-  return { z: parts[0], x: parts[1], y: parts[2] };
+  return { z: parts[0], x: parts[1], y: parts[2], extension: ext };
 }
 
 async function main(): Promise<void> {
   const log = LogConfig.get();
+  log.level = 'trace';
   const provider = new ConfigProviderMemory();
   setDefaultConfig(provider);
-  const { tileSet, imagery } = await initConfigFromUrls(provider, [target]);
+  const { imagery, tileSets } = await initConfigFromUrls(provider, [source]);
+
+  const tileSet = tileSets.find((f) => f.layers.length > 0);
 
-  if (tileSet.layers.length === 0) throw new Error('No imagery found in path: ' + target);
+  if (tileSet == null || tileSet.layers.length === 0) throw new Error('No imagery found in path: ' + source);
   log.info({ tileSet: tileSet.name, layers: tileSet.layers.length }, 'TileSet:Loaded');
 
   for (const im of imagery) {
@@ -47,11 +51,16 @@ async function main(): Promise<void> {
     tile,
     tileMatrix,
     tileSet: tileSet.id,
-    tileType: outputFormat,
+    tileType: tile.extension,
+    pipeline,
   });
+  const pipelineName = pipeline ? `-${pipeline}` : '';
 
-  await fsa.write(`./${tile.z}_${tile.x}_${tile.y}.${outputFormat}`, Buffer.from(res.body, 'base64'));
-  log.info({ path: `./${tile.z}_${tile.x}_${tile.y}.${outputFormat}` }, 'Tile:Write');
+  const fileName = `./render/${tile.z}_${tile.x}_${tile.y}${pipelineName}.${tile.extension}`;
+  await fsa.write(fsa.toUrl(fileName), Buffer.from(res.body, 'base64'));
+  log.info({ path: fileName, ...request.timer.metrics }, 'Tile:Write');
 }
 
-main();
+main().catch((e) => {
+  LogConfig.get().fatal({ err: e }, 'Cli:Failed');
+});

package/src/index.ts

@@ -1,5 +1,6 @@
-import { LogConfig } from '@basemaps/shared';
-import { LambdaHttpResponse, lf } from '@linzjs/lambda';
+import { FsaCache, FsaLog, LogConfig } from '@basemaps/shared';
+import { LambdaHttpRequest, LambdaHttpResponse, lf } from '@linzjs/lambda';
+
 import { tileAttributionGet } from './routes/attribution.js';
 import { configImageryGet, configTileSetGet } from './routes/config.js';
 import { fontGet, fontList } from './routes/fonts.js';
@@ -15,38 +16,40 @@ import { wmtsCapabilitiesGet } from './routes/tile.wmts.js';
 import { tileXyzGet } from './routes/tile.xyz.js';
 import { versionGet } from './routes/version.js';
 import { NotFound } from './util/response.js';
-import { CoSources } from './util/source.cache.js';
-import { St } from './util/source.tracer.js';
 
 export const handler = lf.http(LogConfig.get());
 
 /** If the request takes too long, respond with a 408 timeout when there is approx 1 second remaining */
 handler.router.timeoutEarlyMs = 1_000;
 
+function randomTrace(req: LambdaHttpRequest): void {
+  // If the env is set to trace level always trace requests
+  if (process.env['TRACE']) {
+    req.log.level = 'trace';
+    return;
+  }
+
+  // Set the logging level based off a percent
+  const rand = Math.random();
+  // 1% trace
+  if (rand < 0.01) req.log.level = 'trace';
+  // 5% debug
+  else if (rand < 0.04) req.log.level = 'debug';
+  // everything else info
+  else req.log.level = 'info';
+}
+
 handler.router.hook('request', (req) => {
-  req.set('name', 'LambdaTiler');
+  FsaLog.reset();
 
-  // Reset the request tracing before every request
-  St.reset();
+  randomTrace(req);
+
+  req.set('name', 'LambdaTiler');
 });
 
 handler.router.hook('response', (req, res) => {
-  if (St.requests.length > 0) {
-    // TODO this could be relaxed to every say 5% of requests if logging gets too verbose.
-    req.set('requests', St.requests.slice(0, 100)); // limit to 100 requests (some tiles need 100s of requests)
-    req.set('requestCount', St.requests.length);
-  }
-  // Log the source cache hit/miss ratio
-  req.set('sources', {
-    hits: CoSources.cache.hits,
-    misses: CoSources.cache.misses,
-    size: CoSources.cache.currentSize,
-    resets: CoSources.cache.resets,
-    clears: CoSources.cache.clears,
-    cacheA: CoSources.cache.cacheA.size,
-    cacheB: CoSources.cache.cacheB.size,
-  });
-
+  req.set('requestCount', FsaLog.requests.length);
+  req.set('cacheSize', FsaCache.size);
   // Force access-control-allow-origin to everything
   res.header('access-control-allow-origin', '*');
 });
@@ -94,6 +97,8 @@ handler.router.get('/v1/tiles/:tileSet/:tileMatrix/:z/:x/:y.:tileType', tileXyzG
 
 // Preview
 handler.router.get('/v1/preview/:tileSet/:tileMatrix/:z/:lon/:lat', tilePreviewGet);
+handler.router.get('/v1/preview/:tileSet/:tileMatrix/:z/:lon/:lat/:outputType', tilePreviewGet);
+
 handler.router.get('/v1/@:location', previewIndexGet);
 handler.router.get('/@:location', previewIndexGet);
 

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

@@ -1,15 +1,18 @@
+import assert from 'node:assert';
+import { afterEach, beforeEach, describe, it } from 'node:test';
+
 import { Attribution } from '@basemaps/attribution';
 import { ConfigProviderMemory } from '@basemaps/config';
 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';
-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 { handler } from '../../index.js';
+import { ConfigLoader } from '../../util/config.loader.js';
 import { createCoordinates } from '../attribution.js';
 
 // const ExpectedJson = {
@@ -280,11 +283,11 @@ import { createCoordinates } from '../attribution.js';
 //     updatedAt: Date.now(),
 //   };
 // }
-o.spec('/v1/attribution', () => {
+describe('/v1/attribution', () => {
   const config = new ConfigProviderMemory();
   const sandbox = sinon.createSandbox();
 
-  o.beforeEach(() => {
+  beforeEach(() => {
     LogConfig.get().level = 'silent';
     sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
 
@@ -296,107 +299,107 @@ o.spec('/v1/attribution', () => {
     config.put(Provider);
   });
 
-  o.afterEach(() => {
+  afterEach(() => {
     sandbox.restore();
   });
 
-  o('should notFound', async () => {
+  it('should notFound', async () => {
     const request = mockUrlRequest(`/v1/attribution/aerial/1234/summary.json`);
     const res = await handler.router.handle(request);
 
-    o(res.status).equals(404);
+    assert.equal(res.status, 404);
   });
 
-  o('should 304 with etag match', async () => {
+  it('should 304 with etag match', async () => {
     const request = mockUrlRequest(`/v1/attribution/aerial/EPSG:3857/summary.json`, 'get', {
-      [HttpHeader.IfNoneMatch]: 'E5HGpTqF8AiJ7VgGVKLehYnVfLN9jaVw8Sy6UafJRh2f',
+      [HttpHeader.IfNoneMatch]: 'AFV7dcchHkfyFvmmyXwpkxuAPb5BuVXLkLzzYgeB3mFy',
     });
 
     const res = await handler.router.handle(request);
 
-    if (res.status === 200) o(res.header('etag')).equals('E5HGpTqF8AiJ7VgGVKLehYnVfLN9jaVw8Sy6UafJRh2f');
+    if (res.status === 200) assert.equal(res.header('etag'), 'AFV7dcchHkfyFvmmyXwpkxuAPb5BuVXLkLzzYgeB3mFy');
 
     console.log(res.header('etag'));
-    o(res.status).equals(304);
+    assert.equal(res.status, 304);
   });
 
-  o('should parse attribution', async () => {
+  it('should parse attribution', async () => {
     const request = mockUrlRequest(`/v1/attribution/aerial/EPSG:3857/summary.json`);
     const res = await handler.router.handle(request);
-    o(res.status).equals(200);
+    assert.equal(res.status, 200);
 
     const json = JSON.parse(res.body);
 
     const attr = Attribution.fromStac(json);
-    o(attr.attributions.length).equals(1);
-    o(attr.attributions[0].minZoom).equals(0);
-    o(attr.attributions[0].maxZoom).equals(32);
+    assert.equal(attr.attributions.length, 1);
+    assert.equal(attr.attributions[0].minZoom, 0);
+    assert.equal(attr.attributions[0].maxZoom, 32);
   });
 
-  o.spec('ImageryRules', () => {
+  describe('ImageryRules', () => {
     const fakeLayer = { [2193]: Imagery2193.id, name: 'image', minZoom: 9, maxZoom: 16, title: 'Image' };
     const ts = FakeData.tileSetRaster('fake');
 
-    o.beforeEach(() => {
+    beforeEach(() => {
       ts.layers = [fakeLayer];
       config.put(Imagery2193);
       config.put(ts);
     });
 
-    o('should generate for NZTM', async () => {
+    it('should generate for NZTM', async () => {
       const req = mockUrlRequest('/v1/tiles/fake/NZTM2000/attribution.json', '');
       const res = await handler.router.handle(req);
-      o(res.status).equals(200);
+      assert.equal(res.status, 200);
 
       const output = JSON.parse(res.body);
-      o(output.title).equals(ts.title);
-      o(output.collections[0].summaries['linz:zoom']).deepEquals({ min: 5, max: 11 });
+      assert.equal(output.title, ts.title);
+      assert.deepEqual(output.collections[0].summaries['linz:zoom'], { min: 5, max: 11 });
     });
 
-    o('should generate with correct zooms for NZTM2000Quad', async () => {
+    it('should generate with correct zooms for NZTM2000Quad', async () => {
       const req = mockUrlRequest('/v1/tiles/fake/NZTM2000Quad/attribution.json', '');
       const res = await handler.router.handle(req);
-      o(res.status).equals(200);
+      assert.equal(res.status, 200);
 
       const output = JSON.parse(res.body);
-      o(output.title).equals(ts.title);
-      o(output.collections[0].summaries['linz:zoom']).deepEquals({ min: 7, max: 14 });
+      assert.equal(output.title, ts.title);
+      assert.deepEqual(output.collections[0].summaries['linz:zoom'], { min: 7, max: 14 });
     });
 
-    o('should generate with correct zooms for gebco NZTM2000Quad', async () => {
+    it('should generate with correct zooms for gebco NZTM2000Quad', async () => {
       const fakeGebco = { ...fakeLayer, minZoom: 0, maxZoom: 15 };
       ts.layers = [fakeGebco];
 
       const req = mockUrlRequest('/v1/tiles/fake/NZTM2000Quad/attribution.json', '');
       const res = await handler.router.handle(req);
-      o(res.status).equals(200);
+      assert.equal(res.status, 200);
 
       const output = JSON.parse(res.body);
-      o(output.title).equals(ts.title);
-      o(output.collections[0].summaries['linz:zoom']).deepEquals({ min: 0, max: 13 });
+      assert.equal(output.title, ts.title);
+      assert.deepEqual(output.collections[0].summaries['linz:zoom'], { min: 0, max: 13 });
     });
 
-    o('should generate with correct zooms for nz sentinel NZTM2000Quad', async () => {
+    it('should generate with correct zooms for nz sentinel NZTM2000Quad', async () => {
       const fakeGebco = { ...fakeLayer, minZoom: 0, maxZoom: 32 };
       ts.layers = [fakeGebco];
 
       const req = mockUrlRequest('/v1/tiles/fake/NZTM2000Quad/attribution.json', '');
       const res = await handler.router.handle(req);
-      o(res.status).equals(200);
+      assert.equal(res.status, 200);
 
       const output = JSON.parse(res.body);
-      o(output.title).equals(ts.title);
-      o(output.collections[0].summaries['linz:zoom']).deepEquals({ min: 0, max: Nztm2000QuadTms.maxZoom });
+      assert.equal(output.title, ts.title);
+      assert.deepEqual(output.collections[0].summaries['linz:zoom'], { min: 0, max: Nztm2000QuadTms.maxZoom });
     });
   });
 
-  o('should create valid coordinates', async () => {
+  it('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([
+    assert.deepEqual(coordinates, [
       [
         [
           [174.79247149, -38.09998972],

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

@@ -1,108 +1,112 @@
-import { base58, ConfigProviderMemory } from '@basemaps/config';
-import { getDefaultConfig } from '@basemaps/shared';
-import { fsa } from '@chunkd/fs';
-import o from 'ospec';
-import { createSandbox } from 'sinon';
+import assert from 'node:assert';
+import { afterEach, beforeEach, describe, it } from 'node:test';
+
+import { base58, BaseConfig, ConfigProviderMemory } from '@basemaps/config';
+import { setDefaultConfig } from '@basemaps/shared';
+import { fsa, FsMemory } from '@chunkd/fs';
+
+import { Api, mockRequest, mockUrlRequest } from '../../__tests__/xyz.util.js';
 import { handler } from '../../index.js';
 import { CachedConfig } from '../../util/config.cache.js';
-import { ConfigLoader } from '../../util/config.loader.js';
 import { CoSources } from '../../util/source.cache.js';
-import { Api, mockRequest, mockUrlRequest } from '../../__tests__/xyz.util.js';
 import { fontList } from '../fonts.js';
-import { FsMemory } from '@chunkd/source-memory';
 
-o.spec('/v1/fonts', () => {
+describe('/v1/fonts', () => {
   const memory = new FsMemory();
-  const sandbox = createSandbox();
   const config = new ConfigProviderMemory();
 
-  o.before(() => {
+  beforeEach(() => {
+    config.objects.clear();
     fsa.register('memory://', memory);
+    config.assets = 'memory://assets/';
+    setDefaultConfig(config);
   });
 
-  o.beforeEach(() => {
-    config.assets = 'memory://';
-    sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
-  });
-
-  o.afterEach(() => {
-    sandbox.restore();
+  afterEach(() => {
     CachedConfig.cache.clear();
     CoSources.cache.clear();
     memory.files.clear();
   });
 
-  o('should return 404 if no font found', async () => {
+  it('should return 404 if no font found', async () => {
     const res = await fontList(mockRequest('/v1/fonts.json'));
-    o(res.status).equals(404);
+    assert.equal(res.status, 404);
   });
 
-  o('should return a list of fonts found', async () => {
-    await fsa.write('memory://fonts/fonts.json', Buffer.from(JSON.stringify(['Roboto Black', 'Roboto Thin'])));
+  it('should return a list of fonts found', async () => {
+    await fsa.write(
+      new URL('memory://assets/fonts/fonts.json'),
+      Buffer.from(JSON.stringify(['Roboto Black', 'Roboto Thin'])),
+    );
     const res = await fontList(mockRequest('/v1/fonts.json'));
-    o(res.status).equals(200);
-    o(res.header('content-type')).equals('application/json');
-    o(res.header('content-encoding')).equals(undefined);
-    o(res._body?.toString()).equals(JSON.stringify(['Roboto Black', 'Roboto Thin']));
+    assert.equal(res.status, 200);
+    assert.equal(res.header('content-type'), 'application/json');
+    assert.equal(res.header('content-encoding'), undefined);
+    assert.equal(res._body?.toString(), JSON.stringify(['Roboto Black', 'Roboto Thin']));
   });
 
-  o('should get the correct font', async () => {
-    await fsa.write('memory://fonts/Roboto Thin/0-255.pbf', Buffer.from(''));
+  it('should get the correct font', async () => {
+    await fsa.write(new URL('memory://assets/fonts/Roboto Thin/0-255.pbf'), Buffer.from(''));
     const res255 = await handler.router.handle(mockRequest('/v1/fonts/Roboto Thin/0-255.pbf'));
-    o(res255.status).equals(200);
-    o(res255.header('content-type')).equals('application/x-protobuf');
-    o(res255.header('content-encoding')).equals(undefined);
-    o(res255.header('etag')).notEquals(undefined);
-    o(res255.header('cache-control')).equals('public, max-age=604800, stale-while-revalidate=86400');
+    assert.equal(res255.status, 200);
+    assert.equal(res255.header('content-type'), 'application/x-protobuf');
+    assert.equal(res255.header('content-encoding'), undefined);
+    assert.notEqual(res255.header('etag'), undefined);
+    assert.equal(res255.header('cache-control'), 'public, max-age=604800, stale-while-revalidate=86400');
 
     const res404 = await handler.router.handle(mockRequest('/v1/fonts/Roboto Thin/256-512.pbf'));
-    o(res404.status).equals(404);
+    assert.equal(res404.status, 404);
   });
 
-  o('should get the correct utf8 font', async () => {
-    await fsa.write('memory://fonts/🦄 🌈/0-255.pbf', Buffer.from(''));
+  it('should get the correct utf8 font', async () => {
+    await fsa.write(new URL('memory://assets/fonts/🦄 🌈/0-255.pbf'), Buffer.from(''));
     const res255 = await handler.router.handle(mockRequest('/v1/fonts/🦄 🌈/0-255.pbf'));
-    o(res255.status).equals(200);
-    o(res255.header('content-type')).equals('application/x-protobuf');
-    o(res255.header('content-encoding')).equals(undefined);
-    o(res255.header('etag')).notEquals(undefined);
-    o(res255.header('cache-control')).equals('public, max-age=604800, stale-while-revalidate=86400');
+    assert.equal(res255.status, 200);
+    assert.equal(res255.header('content-type'), 'application/x-protobuf');
+    assert.equal(res255.header('content-encoding'), undefined);
+    assert.notEqual(res255.header('etag'), undefined);
+    assert.equal(res255.header('cache-control'), 'public, max-age=604800, stale-while-revalidate=86400');
   });
 
-  o('should return 404 if no asset location set', async () => {
-    getDefaultConfig().assets = undefined;
+  it('should return 404 if no asset location set', async () => {
+    config.assets = undefined;
     const res = await fontList(mockRequest('/v1/fonts.json'));
-    o(res.status).equals(404);
+    assert.equal(res.status, 404);
   });
 
-  o('should get the correct utf8 font with default assets', async () => {
-    getDefaultConfig().assets = undefined;
-    sandbox
-      .stub(config.ConfigBundle, 'get')
-      .resolves({ id: 'cb_latest', name: 'latest', path: 'latest', hash: 'hash', assets: 'memory://' });
-    await fsa.write('memory://fonts/Roboto Thin/0-255.pbf', Buffer.from(''));
+  it('should get the correct utf8 font with default assets', async () => {
+    config.assets = undefined;
+    config.objects.set('cb_latest', {
+      id: 'cb_latest',
+      name: 'latest',
+      path: 'latest',
+      hash: 'hash',
+      assets: 'memory://new-location/',
+    } as BaseConfig);
+
+    await fsa.write(new URL('memory://new-location/fonts/Roboto Thin/0-255.pbf'), Buffer.from(''));
     const res255 = await handler.router.handle(mockRequest('/v1/fonts/Roboto Thin/0-255.pbf'));
-    o(res255.status).equals(200);
-    o(res255.header('content-type')).equals('application/x-protobuf');
-    o(res255.header('content-encoding')).equals(undefined);
-    o(res255.header('etag')).notEquals(undefined);
-    o(res255.header('cache-control')).equals('public, max-age=604800, stale-while-revalidate=86400');
+    assert.equal(res255.status, 200, res255.statusDescription);
+    assert.equal(res255.header('content-type'), 'application/x-protobuf');
+    assert.equal(res255.header('content-encoding'), undefined);
+    assert.notEqual(res255.header('etag'), undefined);
+    assert.equal(res255.header('cache-control'), 'public, max-age=604800, stale-while-revalidate=86400');
   });
 
-  o('should get the correct utf8 font with config assets', async () => {
+  it('should get the correct utf8 font with config assets', async () => {
     const cfgBundle = new ConfigProviderMemory();
-    cfgBundle.assets = 'memory://config/assets';
-    await fsa.write('memory://linz-basemaps/bar.json', JSON.stringify(cfgBundle.toJson()));
-    await fsa.write('memory://config/assets/fonts/🦄 🌈/0-255.pbf', Buffer.from(''));
+    cfgBundle.assets = 'memory://config/assets/';
+    await fsa.write(new URL('memory://linz-basemaps/bar.json'), JSON.stringify(cfgBundle.toJson()));
+    await fsa.write(new URL('memory://config/assets/fonts/🦄 🌈/0-255.pbf'), Buffer.from(''));
 
     const configLocation = base58.encode(Buffer.from('memory://linz-basemaps/bar.json'));
     const res255 = await handler.router.handle(
       mockUrlRequest('/v1/fonts/🦄 🌈/0-255.pbf', `?config=${configLocation}`, Api.header),
     );
-    o(res255.status).equals(200);
-    o(res255.header('content-type')).equals('application/x-protobuf');
-    o(res255.header('content-encoding')).equals(undefined);
-    o(res255.header('etag')).notEquals(undefined);
-    o(res255.header('cache-control')).equals('public, max-age=604800, stale-while-revalidate=86400');
+    assert.equal(res255.status, 200);
+    assert.equal(res255.header('content-type'), 'application/x-protobuf');
+    assert.equal(res255.header('content-encoding'), undefined);
+    assert.notEqual(res255.header('etag'), undefined);
+    assert.equal(res255.header('cache-control'), 'public, max-age=604800, stale-while-revalidate=86400');
   });
 });

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

@@ -1,12 +1,14 @@
+import assert from 'node:assert';
+import { afterEach, before, beforeEach, describe, it } from 'node:test';
+
 import { ConfigProviderMemory } from '@basemaps/config';
 import { LogConfig } from '@basemaps/shared';
 import { LambdaAlbRequest, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { Context } from 'aws-lambda';
-import o from 'ospec';
 import sinon from 'sinon';
-import { ConfigLoader } from '../../util/config.loader.js';
-import { FakeData } from '../../__tests__/config.data.js';
 
+import { FakeData } from '../../__tests__/config.data.js';
+import { ConfigLoader } from '../../util/config.loader.js';
 import { getTestBuffer, healthGet, TestTiles } from '../health.js';
 import { TileXyzRaster } from '../tile.xyz.raster.js';
 
@@ -22,24 +24,23 @@ const ctx: LambdaHttpRequest = new LambdaAlbRequest(
   LogConfig.get(),
 );
 
-o.spec('/v1/health', async () => {
-  o.specTimeout(1000);
+describe('/v1/health', async () => {
   const sandbox = sinon.createSandbox();
   const config = new ConfigProviderMemory();
 
   const fakeTileSet = FakeData.tileSetRaster('health');
-  o.beforeEach(() => {
+  beforeEach(() => {
     config.objects.clear();
     sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
     config.put(fakeTileSet);
   });
 
-  o.afterEach(() => {
+  afterEach(() => {
     config.objects.clear();
     sandbox.restore();
   });
 
-  o('Should return bad response', async () => {
+  it('Should return bad response', async () => {
     // Given ... a bad get tile response
     const BadResponse = new LambdaHttpResponse(500, 'Can not get Tile Set.');
     sandbox.stub(TileXyzRaster, 'tile').resolves(BadResponse);
@@ -48,14 +49,14 @@ o.spec('/v1/health', async () => {
     const res = await healthGet(ctx);
 
     // Then ...
-    o(res.status).equals(500);
-    o(res.statusDescription).equals('Can not get Tile Set.');
+    assert.equal(res.status, 500);
+    assert.equal(res.statusDescription, 'Can not get Tile Set.');
   });
 
   const Response1 = new LambdaHttpResponse(200, 'ok');
   const Response2 = new LambdaHttpResponse(200, 'ok');
 
-  o.before(async () => {
+  before(async () => {
     const testTileFile1 = await getTestBuffer(TestTiles[0]);
     Response1.buffer(testTileFile1);
     const testTileFile2 = await getTestBuffer(TestTiles[1]);
@@ -63,7 +64,7 @@ o.spec('/v1/health', async () => {
   });
   // Prepare mock test tile response based on the static test tiles
 
-  o('Should give a 200 response', async () => {
+  it('Should give a 200 response', async () => {
     // Given ... a series good get tile response
     const callback = sandbox.stub(TileXyzRaster, 'tile');
     callback.onCall(0).resolves(Response1);
@@ -73,11 +74,11 @@ o.spec('/v1/health', async () => {
     const res = await healthGet(ctx);
 
     // Then ...
-    o(res.status).equals(200);
-    o(res.statusDescription).equals('ok');
+    assert.equal(res.status, 200);
+    assert.equal(res.statusDescription, 'ok');
   });
 
-  o('Should return mis-match tile response', async () => {
+  it('Should return mis-match tile response', async () => {
     // Given ... a bad get tile response for second get tile
     const callback = sandbox.stub(TileXyzRaster, 'tile');
     callback.onCall(0).resolves(Response1);
@@ -87,7 +88,7 @@ o.spec('/v1/health', async () => {
     const res = await healthGet(ctx);
 
     // Then ...
-    o(res.status).equals(500);
-    o(res.statusDescription).equals('TileSet does not match.');
+    assert.equal(res.status, 500);
+    assert.equal(res.statusDescription, 'TileSet does not match.');
   });
 });

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);
   });
 });