@quanthea/plugin-kit 0.1.0

package/testing.js

@@ -0,0 +1,642 @@
+// @bun
+import {
+  kitVersion2
+} from "./chunk-3ayrhcmg.js";
+
+// packages/plugin-kit/src/testing.ts
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+
+// packages/plugin-kit/src/checks.ts
+import { z as z2 } from "zod";
+
+// packages/plugin-kit/src/languages.ts
+import { z } from "zod";
+var queryLanguages = [
+  "sql",
+  "promql",
+  "search",
+  "logql",
+  "http",
+  "redis",
+  "mongodb"
+];
+var queryLanguageSchema = z.enum(queryLanguages);
+
+// packages/plugin-kit/src/queries.ts
+var sqlDialects = [
+  "postgres",
+  "mysql",
+  "clickhouse",
+  "trino",
+  "influxdb",
+  "ansi"
+];
+var sqlPlaceholderStyles = ["?", "$1", ":1", "@p1"];
+var sqlRowLimits = ["fetch", "limit"];
+
+// packages/plugin-kit/src/checks.ts
+var kindPattern = /^[a-z][a-z0-9-]{0,39}$/;
+var pathPattern = /^[MmZzLlHhVvCcSsQqTtAa0-9eE.,\s+-]+$/;
+var colorPattern = /^#[0-9a-fA-F]{6}$/;
+var maxGuideLength = 8192;
+function oneOf(list, value) {
+  return typeof value === "string" && list.includes(value);
+}
+var namingChecks = [
+  [
+    (kind) => typeof kind.kind !== "string" || !kindPattern.test(kind.kind),
+    "kind must be lowercase letters, digits and dashes, up to 40 characters"
+  ],
+  [
+    (kind) => typeof kind.displayName !== "string" || kind.displayName.trim() === "",
+    "displayName must be a name"
+  ],
+  [
+    (kind) => {
+      const aliases = kind.aliases ?? [];
+      return !Array.isArray(aliases) || !aliases.every((alias) => typeof alias === "string");
+    },
+    "aliases must be a list of names"
+  ],
+  [
+    (kind) => kind.queryGuide !== undefined && (typeof kind.queryGuide !== "string" || kind.queryGuide.length > maxGuideLength),
+    `queryGuide must be text of at most ${maxGuideLength} characters`
+  ]
+];
+var languageChecks = [
+  [
+    (kind) => !oneOf(queryLanguages, kind.language),
+    `language must be one of ${queryLanguages.join(", ")}`
+  ],
+  [
+    (kind) => kind.language === "sql" && !oneOf(sqlDialects, kind.dialect),
+    `a SQL kind's dialect must be one of ${sqlDialects.join(", ")}`
+  ],
+  [
+    (kind) => kind.language !== "sql" && kind.dialect !== undefined,
+    "only a SQL kind declares a dialect"
+  ],
+  [
+    (kind) => kind.placeholders !== undefined && !(kind.dialect === "ansi" && oneOf(sqlPlaceholderStyles, kind.placeholders)),
+    `placeholders is for ansi only: ${sqlPlaceholderStyles.join(", ")}`
+  ],
+  [
+    (kind) => kind.rowLimit !== undefined && !(kind.dialect === "ansi" && oneOf(sqlRowLimits, kind.rowLimit)),
+    "rowLimit is for ansi only: fetch or limit"
+  ]
+];
+function isIcon(icon) {
+  if (typeof icon !== "object" || icon === null)
+    return false;
+  const { path, color } = icon;
+  return typeof path === "string" && pathPattern.test(path) && typeof color === "string" && colorPattern.test(color);
+}
+var shapeChecks = [
+  [
+    (kind) => kind.icon !== undefined && !isIcon(kind.icon),
+    "icon must be SVG path data and a #rrggbb colour"
+  ],
+  [(kind) => typeof kind.open !== "function", "open must be a function"],
+  [
+    (kind) => kind.describeTarget !== undefined && typeof kind.describeTarget !== "function",
+    "describeTarget must be a function"
+  ]
+];
+function propertiesOf(schema) {
+  if (!(schema instanceof z2.ZodType))
+    return;
+  try {
+    const json = z2.toJSONSchema(schema, { io: "input", unrepresentable: "any" });
+    return json.type === "object" ? Object.keys(json.properties ?? {}) : undefined;
+  } catch {
+    return;
+  }
+}
+function schemaProblems(kind) {
+  const config = propertiesOf(kind.configSchema);
+  const secret = propertiesOf(kind.secretSchema);
+  const problems = [];
+  if (!config || config.length === 0)
+    problems.push("configSchema must be an object schema with fields, built with the kit's z");
+  if (!secret)
+    problems.push("secretSchema must be an object schema, built with the kit's z");
+  const shared = (config ?? []).filter((name) => (secret ?? []).includes(name));
+  if (shared.length > 0)
+    problems.push(`credentials in configSchema: ${shared.join(", ")}`);
+  return problems;
+}
+function kindProblems(kind) {
+  if (typeof kind !== "object" || kind === null)
+    return ["a kind must be an object"];
+  const candidate = kind;
+  const failed = [...namingChecks, ...languageChecks, ...shapeChecks].filter(([breaks]) => breaks(candidate)).map(([, message]) => message);
+  return [...failed, ...schemaProblems(candidate)];
+}
+
+// packages/plugin-kit/src/errors.ts
+var connectorErrorCodes = [
+  "unreachable",
+  "authentication",
+  "permission",
+  "syntax",
+  "not_found",
+  "timeout",
+  "rejected",
+  "internal"
+];
+var brand = Symbol.for("quanthea.connector-error");
+var knownCodes = new Set(connectorErrorCodes);
+
+class ConnectorError extends Error {
+  code;
+  safeMessage;
+  constructor(code, safeMessage, message, options) {
+    super(message ?? safeMessage, options);
+    this.name = "ConnectorError";
+    this.code = code;
+    this.safeMessage = safeMessage;
+  }
+  static [Symbol.hasInstance](value) {
+    if (typeof value !== "object" || value === null)
+      return false;
+    const candidate = value;
+    return candidate[brand] === true && knownCodes.has(candidate.code) && typeof candidate.safeMessage === "string";
+  }
+}
+Object.defineProperty(ConnectorError.prototype, brand, { value: true });
+
+// packages/plugin-kit/src/frames.ts
+import { z as z3 } from "zod";
+var fieldTypes = ["time", "number", "string", "boolean"];
+var fieldSchema = z3.object({
+  name: z3.string().min(1),
+  type: z3.enum(fieldTypes),
+  labels: z3.record(z3.string(), z3.string()).optional(),
+  unit: z3.string().optional()
+});
+var frameMetaSchema = z3.object({
+  rowCount: z3.number().int().nonnegative(),
+  truncated: z3.boolean(),
+  durationMs: z3.number().nonnegative()
+});
+var frameSchema = z3.object({
+  refId: z3.string().min(1),
+  name: z3.string().optional(),
+  fields: z3.array(fieldSchema),
+  values: z3.array(z3.array(z3.unknown())),
+  meta: frameMetaSchema
+});
+function fitsType(type, value) {
+  if (value === null)
+    return true;
+  if (type === "time" || type === "number") {
+    return typeof value === "number" && Number.isFinite(value);
+  }
+  return typeof value === type;
+}
+function frameProblems(frame) {
+  const parsed = frameSchema.safeParse(frame);
+  if (!parsed.success) {
+    return parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`);
+  }
+  const { fields, values, meta } = parsed.data;
+  if (values.length !== fields.length) {
+    return [`${fields.length} fields but ${values.length} value columns`];
+  }
+  return fields.flatMap((field, index) => {
+    const column = values[index] ?? [];
+    if (column.length !== meta.rowCount) {
+      return [`field "${field.name}" has ${column.length} values for ${meta.rowCount} rows`];
+    }
+    const wrong = column.findIndex((value) => !fitsType(field.type, value));
+    return wrong === -1 ? [] : [`field "${field.name}" row ${wrong} is not a ${field.type}`];
+  });
+}
+
+// packages/plugin-kit/src/host.ts
+import { z as z4 } from "zod";
+
+// packages/plugin-kit/src/connector-kind.ts
+var kindPattern2 = /^[a-z][a-z0-9-]*$/;
+var pathPattern2 = /^[MmZzLlHhVvCcSsQqTtAa0-9eE.,\s+-]+$/;
+var colorPattern2 = /^#[0-9a-fA-F]{6}$/;
+function checkIcon(kind, icon) {
+  if (icon === undefined)
+    return;
+  if (!pathPattern2.test(icon.path) || !colorPattern2.test(icon.color))
+    throw new Error(`Connector kind "${kind}" has an icon that is not SVG path data and a colour.`);
+}
+function checkAnsiStyles(definition) {
+  const { kind, dialect, placeholders, rowLimit } = definition;
+  if (dialect !== "ansi" && (placeholders !== undefined || rowLimit !== undefined))
+    throw new Error(`Connector kind "${kind}" sets placeholders or rowLimit, which only the ansi dialect takes.`);
+  if (placeholders !== undefined && !sqlPlaceholderStyles.includes(placeholders))
+    throw new Error(`Connector kind "${kind}" has placeholders "${placeholders}": use ${sqlPlaceholderStyles.join(", ")}.`);
+  if (rowLimit !== undefined && !sqlRowLimits.includes(rowLimit))
+    throw new Error(`Connector kind "${kind}" has rowLimit "${rowLimit}": use fetch or limit.`);
+}
+function defineConnector(definition) {
+  if (!kindPattern2.test(definition.kind)) {
+    throw new Error(`Connector kind "${definition.kind}" must be lowercase letters, digits and dashes.`);
+  }
+  if (definition.language === "sql" && definition.dialect === undefined)
+    throw new Error(`Connector kind "${definition.kind}" runs SQL and must declare its dialect.`);
+  checkAnsiStyles(definition);
+  checkIcon(definition.kind, definition.icon);
+  return definition;
+}
+
+// packages/plugin-kit/src/frame-builder.ts
+function createFrameBuilder(options) {
+  const columns = options.fields.map(() => []);
+  let rowCount = 0;
+  let truncated = false;
+  return {
+    add(row) {
+      if (rowCount >= options.maxRows) {
+        truncated = true;
+        return false;
+      }
+      columns.forEach((column, index) => {
+        column.push(row[index] ?? null);
+      });
+      rowCount += 1;
+      return true;
+    },
+    build(durationMs) {
+      const frame = {
+        refId: options.refId,
+        fields: [...options.fields],
+        values: columns,
+        meta: { rowCount, truncated, durationMs: Math.round(durationMs) }
+      };
+      return options.name === undefined ? frame : { ...frame, name: options.name };
+    }
+  };
+}
+
+// packages/plugin-kit/src/http-address.ts
+var metadataIpv4 = [/^169\.254\./, /^100\.100\.100\.200$/];
+var metadataIpv6 = [/^fe[89ab][0-9a-f]:/, /^fd00:ec2::254$/];
+var dottedIpv4 = /^\d{1,3}(?:\.\d{1,3}){3}$/;
+function mappedIpv4(address) {
+  const dotted = /^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/.exec(address);
+  if (dotted)
+    return dotted[1];
+  const hex = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(address);
+  if (!hex)
+    return;
+  const high = Number.parseInt(hex[1] ?? "0", 16);
+  const low = Number.parseInt(hex[2] ?? "0", 16);
+  return [high >> 8, high & 255, low >> 8, low & 255].join(".");
+}
+function isMetadataAddress(address) {
+  const bare = address.replace(/^\[|\]$/g, "").toLowerCase();
+  const ipv4 = dottedIpv4.test(bare) ? bare : mappedIpv4(bare);
+  if (ipv4 !== undefined)
+    return metadataIpv4.some((pattern) => pattern.test(ipv4));
+  return metadataIpv6.some((pattern) => pattern.test(bare));
+}
+function isIpLiteral(host) {
+  return host.startsWith("[") || dottedIpv4.test(host);
+}
+async function checkDestination(url, sourceName) {
+  const refused = new ConnectorError("rejected", `The ${sourceName} URL points to a cloud metadata address, which connectors never call.`);
+  if (isMetadataAddress(url.hostname))
+    throw refused;
+  if (isIpLiteral(url.hostname))
+    return;
+  const addresses = await Bun.dns.lookup(url.hostname).catch(() => []);
+  if (addresses.some((entry) => isMetadataAddress(entry.address)))
+    throw refused;
+}
+
+// packages/plugin-kit/src/http.ts
+var maxRedirects = 5;
+function transportError(error, signal, sourceName) {
+  if (error instanceof ConnectorError)
+    return error;
+  if (signal.aborted) {
+    return new ConnectorError("timeout", "The query was cancelled: it ran longer than the timeout, or the caller gave up.");
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new ConnectorError("unreachable", `${sourceName} cannot be reached.`, message, {
+    cause: error
+  });
+}
+function requestUrl(settings, request) {
+  const absolute = /^https?:\/\//i.test(request.path);
+  const url = new URL(absolute ? request.path : `${settings.base}${request.path}`);
+  if (url.origin !== settings.origin)
+    throw new ConnectorError("rejected", `A request left the ${settings.sourceName} origin.`);
+  const parameters = Object.entries(request.query ?? {}).flatMap(([name, value]) => (typeof value === "string" ? [value] : value).map((item) => [name, item]));
+  for (const [name, item] of parameters)
+    url.searchParams.append(name, item);
+  return url;
+}
+async function* chunksOf(body, settings, signal) {
+  if (!body)
+    return;
+  const reader = body.getReader();
+  let total = 0;
+  try {
+    for (let chunk = await reader.read();!chunk.done; chunk = await reader.read()) {
+      total += chunk.value.byteLength;
+      if (total > settings.maxBytes)
+        throw tooLarge(settings);
+      yield chunk.value;
+    }
+  } catch (error) {
+    throw transportError(error, signal, settings.sourceName);
+  } finally {
+    await reader.cancel().catch(() => {
+      return;
+    });
+  }
+}
+function tooLarge(settings) {
+  const mebibytes = Math.round(settings.maxBytes / 1024 / 1024);
+  return new ConnectorError("rejected", `${settings.sourceName} sent more than ${mebibytes} MiB. Ask for fewer rows or a shorter range.`);
+}
+async function* linesOf(chunks) {
+  const decoder = new TextDecoder;
+  let pending = "";
+  for await (const chunk of chunks) {
+    const parts = (pending + decoder.decode(chunk, { stream: true })).split(`
+`);
+    pending = parts.pop() ?? "";
+    for (const line of parts)
+      yield line.replace(/\r$/, "");
+  }
+  pending += decoder.decode();
+  if (pending !== "")
+    yield pending.replace(/\r$/, "");
+}
+function wrapResponse(response, settings, signal) {
+  const text = async () => {
+    const decoder = new TextDecoder;
+    let result = "";
+    for await (const chunk of chunksOf(response.body, settings, signal))
+      result += decoder.decode(chunk, { stream: true });
+    return result + decoder.decode();
+  };
+  return {
+    status: response.status,
+    ok: response.ok,
+    headers: response.headers,
+    text,
+    json: async () => {
+      const body = await text();
+      try {
+        return JSON.parse(body);
+      } catch {
+        throw new ConnectorError("internal", `${settings.sourceName} did not answer with JSON.`);
+      }
+    },
+    lines: () => linesOf(chunksOf(response.body, settings, signal)),
+    cancel: async () => {
+      await response.body?.cancel().catch(() => {
+        return;
+      });
+    }
+  };
+}
+function redirectTarget(response, url, settings) {
+  const location = response.headers.get("location");
+  if (response.status < 300 || response.status > 399 || location === null)
+    return;
+  const target = new URL(location, url);
+  if (target.origin === settings.origin)
+    return target;
+  throw new ConnectorError("rejected", `${settings.sourceName} redirected to another origin, which connectors never follow.`);
+}
+function fetchOnce(url, method, settings, request, signal) {
+  return fetch(url, {
+    method,
+    headers: { ...settings.headers, ...request.headers },
+    ...method === "POST" ? { body: request.body } : {},
+    redirect: "manual",
+    signal,
+    tls: { rejectUnauthorized: settings.verifyTls }
+  });
+}
+async function send(settings, request, signal) {
+  let url = requestUrl(settings, request);
+  await checkDestination(url, settings.sourceName);
+  let method = request.method ?? "GET";
+  for (let redirects = 0;; redirects += 1) {
+    const response = await fetchOnce(url, method, settings, request, signal);
+    const target = redirectTarget(response, url, settings);
+    if (target === undefined || redirects === maxRedirects)
+      return response;
+    await response.body?.cancel();
+    if (response.status !== 307 && response.status !== 308)
+      method = "GET";
+    url = target;
+  }
+}
+function createHttpClient(options) {
+  const base = new URL(options.baseUrl);
+  const settings = {
+    base: base.href.replace(/\/+$/, ""),
+    origin: base.origin,
+    sourceName: options.sourceName,
+    headers: options.headers ?? {},
+    verifyTls: options.verifyTls ?? true,
+    timeoutMs: options.timeoutMs ?? 120000,
+    maxBytes: options.maxBytes ?? 64 * 1024 * 1024
+  };
+  return {
+    async request(request) {
+      const signal = AbortSignal.any([request.signal, AbortSignal.timeout(settings.timeoutMs)]);
+      try {
+        return wrapResponse(await send(settings, request, signal), settings, signal);
+      } catch (error) {
+        throw transportError(error, signal, settings.sourceName);
+      }
+    }
+  };
+}
+
+// packages/plugin-kit/src/series-frames.ts
+var maxSeries = 1000;
+function sampleValue(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+function seriesName(metric) {
+  const { __name__: name = "", ...labels } = metric;
+  const pairs = Object.entries(labels).map(([key, value]) => `${key}="${value}"`);
+  return `${name}{${pairs.join(", ")}}`;
+}
+function matrixFrames(result, context, durationMs) {
+  const frames = result.slice(0, maxSeries).map((series) => {
+    const { __name__: _name, ...labels } = series.metric;
+    const fields = [
+      { name: "time", type: "time" },
+      { name: "Value", type: "number", labels }
+    ];
+    const builder = createFrameBuilder({
+      refId: context.refId,
+      fields,
+      maxRows: context.maxRows,
+      name: seriesName(series.metric)
+    });
+    for (const [seconds, value] of series.values) {
+      if (!builder.add([seconds * 1000, sampleValue(value)]))
+        break;
+    }
+    return builder.build(durationMs);
+  });
+  return markDroppedSeries(frames, result.length);
+}
+function markDroppedSeries(frames, seriesCount) {
+  const last = frames.at(-1);
+  if (seriesCount <= frames.length || !last)
+    return frames;
+  return [...frames.slice(0, -1), { ...last, meta: { ...last.meta, truncated: true } }];
+}
+function vectorFrame(result, context, durationMs) {
+  const labelNames = [...new Set(result.flatMap((sample) => Object.keys(sample.metric)))].filter((name) => name !== "__name__").sort();
+  const fields = [
+    ...labelNames.map((name) => ({ name, type: "string" })),
+    { name: "Value", type: "number" }
+  ];
+  const builder = createFrameBuilder({ refId: context.refId, fields, maxRows: context.maxRows });
+  for (const sample of result) {
+    const row = [
+      ...labelNames.map((name) => sample.metric[name] ?? null),
+      sampleValue(sample.value[1])
+    ];
+    if (!builder.add(row))
+      break;
+  }
+  return builder.build(durationMs);
+}
+function seriesFrames(data, context, durationMs) {
+  if (data.resultType === "matrix")
+    return matrixFrames(data.result, context, durationMs);
+  if (data.resultType === "vector")
+    return [vectorFrame(data.result, context, durationMs)];
+  const [seconds, value] = data.result;
+  const valueType = data.resultType === "scalar" ? "number" : "string";
+  const builder = createFrameBuilder({
+    refId: context.refId,
+    fields: [
+      { name: "time", type: "time" },
+      { name: "Value", type: valueType }
+    ],
+    maxRows: context.maxRows
+  });
+  builder.add([seconds * 1000, valueType === "number" ? sampleValue(value) : value]);
+  return [builder.build(durationMs)];
+}
+
+// packages/plugin-kit/src/host.ts
+var hostKit = Object.freeze({
+  version: kitVersion2,
+  z: z4,
+  defineConnector,
+  ConnectorError,
+  createFrameBuilder,
+  createHttpClient,
+  seriesFrames
+});
+
+// packages/plugin-kit/src/testing.ts
+function createTestKit() {
+  return hostKit;
+}
+function contextFor(fixture, overrides = {}) {
+  return {
+    refId: "A",
+    signal: AbortSignal.timeout(1e4),
+    timeoutMs: 1e4,
+    maxRows: 1000,
+    timeRange: fixture.timeRange,
+    ...overrides
+  };
+}
+function testDeclaration(kind, fixture) {
+  test("passes the static checks the loader runs on every plugin", () => {
+    expect(kindProblems(kind)).toEqual([]);
+  });
+  test("accepts the fixture configuration and credentials", () => {
+    expect(kind.configSchema.safeParse(fixture.config).success).toBe(true);
+    expect(kind.secretSchema.safeParse(fixture.secret).success).toBe(true);
+  });
+}
+function testReading(connection, fixture) {
+  test("test() reports a healthy source", async () => {
+    const report = await connection().test(AbortSignal.timeout(1e4));
+    expect(report.ok).toBe(true);
+    expect(report.latencyMs).toBeGreaterThanOrEqual(0);
+    expect([true, false, null]).toContain(report.readOnly);
+  });
+  test("describe() lists entities with unique names and their fields", async () => {
+    const snapshot = await connection().describe(AbortSignal.timeout(1e4));
+    const names = snapshot.entities.map((entity) => entity.name);
+    expect(names.length).toBeGreaterThan(0);
+    expect(new Set(names).size).toBe(names.length);
+    expect(snapshot.entities.every((entity) => Array.isArray(entity.fields))).toBe(true);
+    expect(snapshot.entities.some((entity) => entity.fields.length > 0)).toBe(true);
+  });
+  test("sampleValues() returns no more values than asked", async () => {
+    const sample = await connection().sampleValues(fixture.sampleField, 1, AbortSignal.timeout(1e4));
+    expect(sample.values.length).toBeLessThanOrEqual(1);
+    expect(sample.complete).toBe(false);
+  });
+}
+function testExecution(connection, fixture) {
+  test("execute() returns valid frames named after the refId", async () => {
+    const frames = await connection().execute(fixture.query, contextFor(fixture, { refId: "Q" }));
+    expect(frames.length).toBeGreaterThan(0);
+    frames.forEach((frame) => {
+      expect(frameProblems(frame)).toEqual([]);
+      expect(frame.refId).toBe("Q");
+    });
+    expect(frames.reduce((rows, frame) => rows + frame.meta.rowCount, 0)).toBeGreaterThanOrEqual(2);
+  });
+  test("execute() stops at maxRows and marks the frame truncated", async () => {
+    const frames = await connection().execute(fixture.query, contextFor(fixture, { maxRows: 1 }));
+    frames.forEach((frame) => {
+      expect(frame.meta.rowCount).toBeLessThanOrEqual(1);
+    });
+    expect(frames.some((frame) => frame.meta.truncated)).toBe(true);
+  });
+  test("execute() rejects with a ConnectorError when the signal is already aborted", async () => {
+    const signal = AbortSignal.abort();
+    const failure = await connection().execute(fixture.query, contextFor(fixture, { signal })).catch((error) => error);
+    expect(failure).toBeInstanceOf(ConnectorError);
+  });
+  test("execute() reports a failed query as a ConnectorError with a safe message", async () => {
+    const failure = await connection().execute(fixture.invalidQuery, contextFor(fixture)).catch((error) => error);
+    expect(failure).toBeInstanceOf(ConnectorError);
+    expect(failure.safeMessage.length).toBeGreaterThan(0);
+  });
+}
+function testConnectorConformance(kind, fixture) {
+  const name = fixture.label ? `${kind.kind}" on "${fixture.label}` : kind.kind;
+  describe(`connector kind "${name}": declaration`, () => testDeclaration(kind, fixture));
+  describe.skipIf(!fixture.live)(`connector kind "${name}": live source`, () => {
+    let instance;
+    const connection = () => {
+      if (!instance)
+        throw new Error("The connection is not open.");
+      return instance;
+    };
+    beforeAll(() => {
+      instance = kind.open({
+        config: kind.configSchema.parse(fixture.config),
+        secret: kind.secretSchema.parse(fixture.secret)
+      });
+    });
+    afterAll(() => instance?.close());
+    testReading(connection, fixture);
+    testExecution(connection, fixture);
+  });
+}
+export {
+  createTestKit,
+  testConnectorConformance
+};