@basemaps/lambda-tiler 6.28.1 → 6.31.0

package/src/__tests__/xyz.test.ts

@@ -1,6 +1,6 @@
 import { ConfigProvider, StyleJson } from '@basemaps/config';
 import { GoogleTms, Nztm2000QuadTms, TileMatrixSets } from '@basemaps/geo';
-import { Config, Env, LogConfig, VNodeParser } from '@basemaps/shared';
+import { Config, Env, LogConfig } from '@basemaps/shared';
 import { round } from '@basemaps/test/build/rounding.js';
 import o from 'ospec';
 import sinon from 'sinon';
@@ -8,7 +8,8 @@ import { handleRequest } from '../index.js';
 import { TileEtag } from '../routes/tile.etag.js';
 import { TileSets } from '../tile.set.cache.js';
 import { TileComposer } from '../tile.set.raster.js';
-import { FakeTileSet, FakeTileSetVector, mockRequest, Provider } from './xyz.util.js';
+import { Provider } from './config.data.js';
+import { FakeTileSet, FakeTileSetVector, mockRequest } from './xyz.util.js';
 
 const sandbox = sinon.createSandbox();
 
@@ -142,51 +143,6 @@ o.spec('LambdaXyz', () => {
     }
   });
 
-  o.spec('WMTSCapabilities', () => {
-    o('should 304 if a xml is not modified', async () => {
-      delete process.env[Env.PublicUrlBase];
-      o.timeout(1000);
-      const key = 'NuirTK8fozzCJV1iG1FznmdHhKvk6WaWuDhhEA1d40c=';
-      const request = mockRequest('/v1/tiles/WMTSCapabilities.xml', 'get', {
-        'if-none-match': key,
-        ...apiKeyHeader,
-      });
-
-      const res = await handleRequest(request);
-
-      if (res.status === 200) {
-        o(res.header('eTaG')).equals(key); // this line is useful for discovering the new etag
-        return;
-      }
-
-      o(res.status).equals(304);
-      o(rasterMock.calls.length).equals(0);
-
-      o(request.logContext['cache']).deepEquals({ key, match: key, hit: true });
-    });
-
-    o('should serve WMTSCapabilities for tile_set', async () => {
-      const request = mockRequest('/v1/tiles/aerial@beta/WMTSCapabilities.xml', 'get', apiKeyHeader);
-
-      const res = await handleRequest(request);
-      o(res.status).equals(200);
-      o(res.header('content-type')).equals('text/xml');
-      o(res.header('cache-control')).equals('max-age=0');
-
-      const body = Buffer.from(res.body ?? '', 'base64').toString();
-      o(body.slice(0, 100)).equals(
-        '<?xml version="1.0"?>\n' + '<Capabilities xmlns="http://www.opengis.net/wmts/1.0" xmlns:ows="http://www.op',
-      );
-
-      const vdom = await VNodeParser.parse(body);
-      const url = vdom.tags('ResourceURL').next().value;
-      o(url?.toString()).equals(
-        '<ResourceURL format="image/jpeg" resourceType="tile" ' +
-          `template="https://tiles.test/v1/tiles/aerial@beta/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.jpeg?api=${apiKey}" />`,
-      );
-    });
-  });
-
   o.spec('tileJson', () => {
     o('should 404 if invalid url is given', async () => {
       const request = mockRequest('/v1/tiles/tile.json', 'get', apiKeyHeader);
@@ -217,7 +173,7 @@ o.spec('LambdaXyz', () => {
 
       const body = Buffer.from(res.body ?? '', 'base64').toString();
       o(JSON.parse(body)).deepEquals({
-        tiles: [`https://tiles.test/v1/tiles/topographic/EPSG:3857/{z}/{x}/{y}.pbf?api=${apiKey}`],
+        tiles: [`https://tiles.test/v1/tiles/topographic/WebMercatorQuad/{z}/{x}/{y}.pbf?api=${apiKey}`],
         tilejson: '3.0.0',
       });
     });
@@ -234,7 +190,7 @@ o.spec('LambdaXyz', () => {
 
       const body = Buffer.from(res.body ?? '', 'base64').toString();
       o(JSON.parse(body)).deepEquals({
-        tiles: [`https://tiles.test/v1/tiles/fake-vector/EPSG:3857/{z}/{x}/{y}.pbf?api=${apiKey}`],
+        tiles: [`https://tiles.test/v1/tiles/fake-vector/WebMercatorQuad/{z}/{x}/{y}.pbf?api=${apiKey}`],
         maxzoom: 15,
         minzoom: 3,
         tilejson: '3.0.0',

package/src/__tests__/xyz.util.ts

@@ -1,4 +1,3 @@
-import { ConfigProvider } from '@basemaps/config';
 import { TileMatrixSet } from '@basemaps/geo';
 import { LogConfig } from '@basemaps/shared';
 import { LambdaAlbRequest, LambdaHttpRequest } from '@linzjs/lambda';
@@ -24,7 +23,12 @@ export function mockRequest(path: string, method = 'get', headers: Record<string
 export class FakeTileSet extends TileSetRaster {
   constructor(name: string, tileMatrix: TileMatrixSet, title = `${name}:title`, description = `${name}:description`) {
     super(name, tileMatrix);
-    this.tileSet = { title, description } as any;
+    this.tileSet = {
+      name,
+      title,
+      description,
+      layers: [{ name: `imagery_${name}`, [tileMatrix.projection.code]: `im_${title}` }],
+    } as any;
   }
 }
 
@@ -34,33 +38,3 @@ export class FakeTileSetVector extends TileSetVector {
     this.tileSet = {} as any;
   }
 }
-
-export const Provider: ConfigProvider = {
-  createdAt: Date.now(),
-  name: 'main',
-  id: 'pv_main_production',
-  updatedAt: Date.now(),
-  version: 1,
-  serviceIdentification: {
-    accessConstraints: 'the accessConstraints',
-    description: 'the description',
-    fees: 'the fees',
-    title: 'the title',
-  },
-  serviceProvider: {
-    contact: {
-      address: {
-        city: 'the city',
-        country: 'the country',
-        deliveryPoint: 'the deliveryPoint',
-        email: 'email address',
-        postalCode: 'the postalCode',
-      },
-      individualName: 'the contact name',
-      phone: 'the phone',
-      position: 'the position',
-    },
-    name: 'the name',
-    site: 'https://example.provider.com',
-  },
-};

package/src/cotar.cache.ts

@@ -0,0 +1,54 @@
+import { fsa } from '@chunkd/fs';
+import { Cotar } from '@cotar/core';
+import { LambdaHttpResponse } from '@linzjs/lambda';
+import { NotFound } from './routes/response.js';
+import { St } from './source.tracer.js';
+
+export class CotarCache {
+  static cache = new Map<string, Promise<Cotar | null>>();
+
+  static get(uri: string): Promise<Cotar | null> {
+    let existing = CotarCache.cache.get(uri);
+    if (existing == null) {
+      const source = fsa.source(uri);
+      St.trace(source);
+      existing = Cotar.fromTar(source);
+      CotarCache.cache.set(uri, existing);
+    }
+    return existing;
+  }
+}
+
+/**
+ *  Load a cotar and look for a file inside the cotar returning the file back as a LambdaResponse
+ *
+ * This will also set two headers
+ * - Content-Encoding if the file starts with gzip magic
+ * - Content-Type from the parameter contentType
+ */
+export async function serveFromCotar(
+  cotarPath: string,
+  assetPath: string,
+  contentType: string,
+): Promise<LambdaHttpResponse> {
+  const cotar = await CotarCache.get(cotarPath);
+  if (cotar == null) return NotFound;
+  const fileData = await cotar.get(assetPath);
+  if (fileData == null) return NotFound;
+  const buf = Buffer.from(fileData);
+  const ret = LambdaHttpResponse.ok().buffer(buf, contentType);
+  if (isGzip(buf)) ret.header('content-encoding', 'gzip');
+  return ret;
+}
+
+/**
+ * Does a buffer look like a gzipped document instead of raw json
+ *
+ * Determined by checking the first two bytes are the gzip magic bytes `0x1f 0x8b`
+ *
+ * @see https://en.wikipedia.org/wiki/Gzip
+ *
+ */
+export function isGzip(b: Buffer): boolean {
+  return b[0] === 0x1f && b[1] === 0x8b;
+}

package/src/index.ts

@@ -1,52 +1,56 @@
-import { lf, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { LogConfig } from '@basemaps/shared';
+import { LambdaHttpRequest, LambdaHttpResponse, lf } from '@linzjs/lambda';
+import { createHash } from 'crypto';
+import { Router } from './router.js';
 import { Ping, Version } from './routes/api.js';
+import { fontGet, fontList } from './routes/fonts.js';
 import { Health } from './routes/health.js';
+import { imageryGet } from './routes/imagery.js';
+import { spriteGet } from './routes/sprites.js';
 import { Tiles } from './routes/tile.js';
-import { Router } from './router.js';
-import { createHash } from 'crypto';
-import { Imagery } from './routes/imagery.js';
-import { Esri } from './routes/esri/rest.js';
 import { St } from './source.tracer.js';
 
 const app = new Router();
 
-app.get('ping', Ping);
-app.get('health', Health);
-app.get('version', Version);
 app.get('tiles', Tiles);
-app.get('imagery', Imagery);
-app.get('esri', Esri);
 
-let slowTimer: NodeJS.Timer | null = null;
 export async function handleRequest(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
-  // Reset the request tracing
-  St.reset();
+  const apiKey = Router.apiKey(req);
+  if (apiKey != null) {
+    const apiKeyHash = createHash('sha256').update(apiKey).digest('base64');
+    req.set('api', apiKeyHash);
+  }
+  return await app.handle(req);
+}
 
-  // Warn if a request takes more than 10 seconds to process
-  if (slowTimer) clearTimeout(slowTimer);
-  slowTimer = setTimeout(() => req.log.warn(req.logContext, 'Lambda:Slow'), 10_000);
-  slowTimer.unref();
+export const handler = lf.http(LogConfig.get());
 
+handler.router.hook('request', (req) => {
   req.set('name', 'LambdaTiler');
-  try {
-    const apiKey = Router.apiKey(req);
-    if (apiKey != null) {
-      const apiKeyHash = createHash('sha256').update(apiKey).digest('base64');
-      req.set('api', apiKeyHash);
-    }
-    const ret = await app.handle(req);
+  // Reset the request tracing before every request
+  St.reset();
+});
 
+handler.router.hook('response', (req) => {
+  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);
-
-    return ret;
-  } finally {
-    if (slowTimer) clearTimeout(slowTimer);
-    slowTimer = null;
   }
-}
-
-export const handler = lf.http(LogConfig.get());
+});
+// TODO some internal health checks hit these routes, we should change them all to point at /v1/
+handler.router.get('/ping', Ping);
+handler.router.get('/health', Health);
+handler.router.get('/version', Version);
+
+handler.router.get('/v1/ping', Ping);
+handler.router.get('/v1/health', Health);
+handler.router.get('/v1/version', Version);
+
+handler.router.get('/v1/imagery/:imageryId/:fileName', imageryGet);
+handler.router.get('/v1/sprites/:spriteName', spriteGet);
+handler.router.get('/v1/fonts.json', fontList);
+handler.router.get('/v1/fonts/:fontStack/:range.pbf', fontGet);
+
+// Catch all for old requests
 handler.router.get('*', handleRequest);

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

@@ -9,10 +9,11 @@ import sinon from 'sinon';
 const sandbox = sinon.createSandbox();
 import { TileSets } from '../../tile.set.cache.js';
 import { TileSetRaster } from '../../tile.set.raster.js';
-import { FakeTileSet, mockRequest, Provider } from '../../__tests__/xyz.util.js';
+import { FakeTileSet, mockRequest } from '../../__tests__/xyz.util.js';
 import { attribution, createAttributionCollection } from '../attribution.js';
 import { TileEtag } from '../tile.etag.js';
 import { Attribution } from '@basemaps/attribution';
+import { Provider } from '../../__tests__/config.data.js';
 
 const ExpectedJson = {
   id: 'aerial_WebMercatorQuad',
@@ -279,7 +280,6 @@ function makeImageRecord(id: string, name: string, x = 10): ConfigImagery {
       b.x += i * b.width;
       return b;
     }),
-    createdAt: Date.now(),
     updatedAt: Date.now(),
   };
 }
@@ -364,7 +364,7 @@ o.spec('attribution', () => {
       const res = await attribution(request);
 
       o(res.status).equals(200);
-      o(res.header(HttpHeader.ETag)).equals('3edkgmltK4/LUyTCTYU9MeiNSwlfUvJAx/qORSisUzM=');
+      o(res.header(HttpHeader.ETag)).equals('GAwx9M7X1ygnn2kr9KPCin2gcaGq7DwYMY1dCpJj3no=');
       o(res.header(HttpHeader.CacheControl)).equals('public, max-age=86400, stale-while-revalidate=604800');
 
       const body = round(JSON.parse(res.body as string), 4);
@@ -373,10 +373,9 @@ o.spec('attribution', () => {
 
     o('should 304 with etag match', async () => {
       const request = mockRequest(`/v1/attribution/aerial/EPSG:3857/summary.json`, 'get', {
-        [HttpHeader.IfNoneMatch]: '3edkgmltK4/LUyTCTYU9MeiNSwlfUvJAx/qORSisUzM=',
+        [HttpHeader.IfNoneMatch]: 'GAwx9M7X1ygnn2kr9KPCin2gcaGq7DwYMY1dCpJj3no=',
       });
       const res = await attribution(request);
-
       o(res.status).equals(304);
     });
 
@@ -402,7 +401,7 @@ o.spec('attribution', () => {
       const ts = new TileSetRaster('Fake', Nztm2000Tms);
       ts.tileSet = { ...ts.tileSet, layers: [fakeLayer] };
 
-      const output = createAttributionCollection(ts, null, fakeIm, fakeLayer, fakeHost, null as any);
+      const output = createAttributionCollection(ts, fakeIm, fakeLayer, fakeHost, null as any);
       o(output.title).equals('SomeName');
       o(output.summaries['linz:zoom']).deepEquals({ min: 5, max: 11 });
     });
@@ -410,7 +409,7 @@ o.spec('attribution', () => {
     o('should generate with correct zooms for NZTM2000Quad', () => {
       const ts = new TileSetRaster('Fake', Nztm2000QuadTms);
       ts.tileSet = { ...ts.tileSet, layers: [fakeLayer] };
-      const output = createAttributionCollection(ts, null, fakeIm, fakeLayer, fakeHost, null as any);
+      const output = createAttributionCollection(ts, fakeIm, fakeLayer, fakeHost, null as any);
       o(output.title).equals('SomeName');
       o(output.summaries['linz:zoom']).deepEquals({ min: 7, max: 14 });
     });
@@ -419,7 +418,7 @@ o.spec('attribution', () => {
       const fakeGebco = { ...fakeLayer, minZoom: 0, maxZoom: 15 };
       const ts = new TileSetRaster('Fake', Nztm2000QuadTms);
       ts.tileSet = { ...ts.tileSet, layers: [fakeLayer] };
-      const output = createAttributionCollection(ts, null, fakeIm, fakeGebco, fakeHost, null as any);
+      const output = createAttributionCollection(ts, fakeIm, fakeGebco, fakeHost, null as any);
       o(output.title).equals('SomeName');
       o(output.summaries['linz:zoom']).deepEquals({ min: 0, max: 13 });
     });
@@ -428,7 +427,7 @@ o.spec('attribution', () => {
       const fakeGebco = { ...fakeLayer, minZoom: 0, maxZoom: 32 };
       const ts = new TileSetRaster('Fake', Nztm2000QuadTms);
       ts.tileSet = { ...ts.tileSet, layers: [fakeLayer] };
-      const output = createAttributionCollection(ts, null, fakeIm, fakeGebco, fakeHost, null as any);
+      const output = createAttributionCollection(ts, fakeIm, fakeGebco, fakeHost, null as any);
       o(output.title).equals('SomeName');
       o(output.summaries['linz:zoom']).deepEquals({ min: 0, max: Nztm2000QuadTms.maxZoom });
     });

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

@@ -0,0 +1,80 @@
+import { Env } from '@basemaps/shared';
+import { fsa } from '@chunkd/fs';
+import o from 'ospec';
+import { handler } from '../../index.js';
+import { mockRequest } from '../../__tests__/xyz.util.js';
+import { fontList, getFonts } from '../fonts.js';
+import { FsMemory } from './memory.fs.js';
+
+o.spec('/v1/fonts', () => {
+  const memory = new FsMemory();
+  o.before(() => {
+    fsa.register('memory://', memory);
+  });
+
+  o.beforeEach(() => {
+    process.env[Env.AssetLocation] = 'memory://';
+  });
+
+  o.afterEach(() => {
+    delete process.env[Env.AssetLocation];
+    memory.files.clear();
+  });
+
+  o('should list font types', async () => {
+    await Promise.all([
+      fsa.write('memory://fonts/Roboto Thin/0-255.pbf', Buffer.from('')),
+      fsa.write('memory://fonts/Roboto Thin/256-512.pbf', Buffer.from('')),
+      fsa.write('memory://fonts/Roboto Black/0-255.pbf', Buffer.from('')),
+    ]);
+
+    const fonts = await getFonts('memory://fonts/');
+    o(fonts).deepEquals(['Roboto Black', 'Roboto Thin']);
+  });
+
+  o('should return empty list if no fonts found', async () => {
+    const res = await fontList();
+    o(res.status).equals(200);
+    o(res.body).equals('[]');
+  });
+
+  o('should return 404 if no assets defined', async () => {
+    delete process.env[Env.AssetLocation];
+    const res = await fontList();
+    o(res.status).equals(404);
+  });
+
+  o('should return a list of fonts found', async () => {
+    await Promise.all([
+      fsa.write('memory://fonts/Roboto Thin/0-255.pbf', Buffer.from('')),
+      fsa.write('memory://fonts/Roboto Thin/256-512.pbf', Buffer.from('')),
+      fsa.write('memory://fonts/Roboto Black/0-255.pbf', Buffer.from('')),
+    ]);
+    const res = await fontList();
+    o(res.status).equals(200);
+    o(res.header('content-type')).equals('application/json');
+    o(res.header('content-encoding')).equals(undefined);
+    o(res.body).equals(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(''));
+
+    const res255 = await handler.router.handle(mockRequest(encodeURI('/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);
+
+    const res404 = await handler.router.handle(mockRequest('/v1/fonts/Roboto Thin/256-512.pbf'));
+    o(res404.status).equals(404);
+  });
+
+  o('should get the correct utf8 font', async () => {
+    await fsa.write('memory://fonts/🦄 🌈/0-255.pbf', Buffer.from(''));
+
+    const res255 = await handler.router.handle(mockRequest(encodeURI('/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);
+  });
+});

package/src/routes/__tests__/memory.fs.ts

@@ -0,0 +1,77 @@
+import { ChunkSource, CompositeError, FileInfo, FileSystem } from '@chunkd/core';
+import { Readable } from 'stream';
+
+export async function toBuffer(stream: Readable): Promise<Buffer> {
+  return new Promise<Buffer>((resolve, reject) => {
+    const buf: Buffer[] = [];
+
+    stream.on('data', (chunk) => buf.push(chunk));
+    stream.on('end', () => resolve(Buffer.concat(buf)));
+    stream.on('error', (err) => reject(`error converting stream - ${err}`));
+  });
+}
+export function toReadable(r: string | Buffer | Readable): Readable {
+  if (typeof r === 'string') r = Buffer.from(r);
+  return Readable.from(r);
+}
+
+// TODO this should be provided by @chunkd/fs as it already provides a memory source
+export class FsMemory implements FileSystem {
+  protocol = 'memory';
+
+  files: Map<string, Buffer> = new Map();
+
+  async read(filePath: string): Promise<Buffer> {
+    const data = this.files.get(filePath);
+    if (data == null) throw new CompositeError('Not found', 404, new Error());
+    return data;
+  }
+
+  stream(filePath: string): Readable {
+    const buf = this.files.get(filePath);
+    if (buf == null) throw new CompositeError('Not found', 404, new Error());
+    return toReadable(buf);
+  }
+
+  async write(filePath: string, buffer: string | Buffer | Readable): Promise<void> {
+    if (typeof buffer === 'string') {
+      this.files.set(filePath, Buffer.from(buffer));
+      return;
+    }
+    if (Buffer.isBuffer(buffer)) {
+      this.files.set(filePath, buffer);
+      return;
+    }
+    const buf = await toBuffer(buffer);
+    this.files.set(filePath, buf);
+  }
+
+  async *list(filePath: string): AsyncGenerator<string> {
+    for (const file of this.files.keys()) {
+      if (file.startsWith(filePath)) yield file;
+    }
+  }
+
+  async *details(filePath: string): AsyncGenerator<FileInfo> {
+    for await (const file of this.list(filePath)) {
+      const data = await this.head(file);
+      if (data == null) continue;
+      yield data;
+    }
+  }
+
+  async exists(filePath: string): Promise<boolean> {
+    const dat = await this.head(filePath);
+    return dat != null;
+  }
+
+  async head(filePath: string): Promise<FileInfo | null> {
+    const buf = this.files.get(filePath);
+    if (buf == null) return null;
+    return { path: filePath, size: buf.length };
+  }
+
+  source(): ChunkSource {
+    throw new Error('Method not implemented.');
+  }
+}

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

@@ -0,0 +1,64 @@
+import { Env } from '@basemaps/shared';
+import { fsa } from '@chunkd/fs';
+import o from 'ospec';
+import { gunzipSync, gzipSync } from 'zlib';
+import { handler } from '../../index.js';
+import { mockRequest } from '../../__tests__/xyz.util.js';
+import { FsMemory } from './memory.fs.js';
+
+o.spec('/v1/sprites', () => {
+  const memory = new FsMemory();
+  o.before(() => {
+    fsa.register('memory://', memory);
+  });
+
+  o.beforeEach(() => {
+    process.env[Env.AssetLocation] = 'memory://';
+  });
+
+  o.afterEach(() => {
+    delete process.env[Env.AssetLocation];
+    memory.files.clear();
+  });
+
+  o('should return 404 if no assets defined', async () => {
+    delete process.env[Env.AssetLocation];
+    const res404 = await handler.router.handle(mockRequest('/v1/sprites/topographic.json'));
+    o(res404.status).equals(404);
+  });
+
+  o('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('')),
+    ]);
+    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(JSON.parse(Buffer.from(res.body, 'base64').toString())).deepEquals({ test: true });
+  });
+
+  o('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('')),
+    ]);
+    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('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 })))),
+    ]);
+    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(JSON.parse(gunzipSync(Buffer.from(res.body, 'base64')).toString())).deepEquals({ test: true });
+  });
+});