@hot-updater/test-utils 1.0.0-rc.15

package/LICENSE

@@ -0,0 +1,33 @@
+MIT License
+
+Copyright (c) 2023 Sungyu Kang 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+ADDITIONAL DISCLAIMER
+
+The authors of this software shall not be held responsible for any legal issues,
+regulatory violations, policy violations, or disputes arising from the use,
+distribution, or integration of this software.
+
+Users are solely responsible for ensuring compliance with all applicable laws,
+regulations, and third-party policies (including but not limited to app store
+policies).

package/README.md

@@ -0,0 +1,64 @@
+# @hot-updater/test-utils
+
+Shared Vitest conformance tests for custom Hot Updater database providers and
+HTTP servers. Official providers and example servers run these same scenarios.
+
+```bash
+pnpm add -D @hot-updater/test-utils @hot-updater/server vitest
+```
+
+Connect your database lifecycle and the real server:
+
+```ts
+import { createHotUpdater } from "@hot-updater/server";
+import {
+  setupDatabasePluginTestSuite,
+  startHttpTestServer,
+} from "@hot-updater/test-utils";
+import { myDatabase } from "./myDatabase";
+import { db, migrateDatabase, resetDatabase } from "./testDatabase";
+
+setupDatabasePluginTestSuite({
+  name: "my database",
+  createPlugin: () => myDatabase({ db }),
+  migrate: () => migrateDatabase(db),
+  reset: () => resetDatabase(db),
+  dispose: async (plugin) => { await plugin.dispose?.(); },
+  createHttpClient: (options) => startHttpTestServer(
+    createHotUpdater({ ...options, clientAccess: { type: "public" } }).handlers,
+  ),
+});
+```
+
+Run the spec with `pnpm exec vitest run`. Use an isolated test database; reset
+all data before each scenario while retaining its schema and version settings.
+
+Passing the complete suite verifies the DatabasePlugin and Release Catalog
+HTTP contracts for the installed Hot Updater version: model semantics,
+transactions, pagination, relations, Insights, catalog projections and caching,
+and artifact responses. Lifecycle scenarios feed those HTTP catalogs into the
+production client selector and advance the simulated device after checking the
+selected artifact: built-in → OTA A → OTA B → rollback A → built-in. They also
+exercise deleted Releases, the native minimum bundle, compatibility, cohort
+changes, and crash history. Native download, activation, and restart remain
+device E2E responsibilities.
+
+The HTTP scenarios use real `fetch` requests on Node,
+including independent Release/Catalog expectations and competing conditional
+writes. Run the entire suite against your provider's actual test backend without
+skipping scenarios or replacing model methods with mocks.
+
+The repository also runs the public suite against deliberately broken providers
+to check that contract violations fail. This is a versioned compatibility gate;
+passing is evidence for the exercised contracts, not a proof of every possible
+execution or deployment condition.
+Add provider-specific migration, concurrency, storage, and deployment tests
+where those need separate verification.
+
+Use `setupReleaseCatalogTestSuite` with `createHttpTestClient` to test an existing
+server by URL. Use `createHandlerHttpTestClient` for a Workers Vitest pool.
+Server processes can import `createReleaseCatalogTestStorage` from
+`@hot-updater/test-utils/node` to install the suite's storage fixtures.
+
+See the [custom database guide](https://hot-updater.dev/docs/database-plugins/custom-database)
+for the full setup and contract boundaries.

package/dist/index.d.mts

@@ -0,0 +1,452 @@
+import { ArtifactInfo, Bundle, ReleaseCatalog } from "@hot-updater/core";
+import { DatabaseAdapter, DatabaseReadCount, PhysicalTable } from "@hot-updater/plugin-core/internal";
+import { BundleRow, ChannelRow, DeployReleasePolicy, EngineDatabase, HotUpdaterCoreApi, InsightsModel, ReleaseRow, StoragePlugin } from "@hot-updater/plugin-core";
+//#region src/httpTestClient.d.ts
+type HttpTestRequestInit = NonNullable<ConstructorParameters<typeof Request>[1]>;
+type HttpTestRequest = (path: string, init?: HttpTestRequestInit) => Promise<Response>;
+interface HttpTestClient {
+  readonly client: HttpTestRequest;
+  readonly admin: HttpTestRequest;
+}
+interface HttpTestServer extends HttpTestClient {
+  readonly close: () => Promise<void>;
+}
+type HttpTestHandlers = Record<"client" | "admin", (request: Request) => Promise<Response>>;
+/** Connect the same contract suite to any running HTTP server. */
+declare function createHttpTestClient(options: {
+  readonly clientBaseUrl: string;
+  readonly adminBaseUrl: string;
+  readonly clientHeaders?: Record<string, string>;
+  readonly adminHeaders?: Record<string, string>;
+}): HttpTestClient;
+/** Workers run the same HTTP contract through their Web Request/Response boundary. */
+declare function createHandlerHttpTestClient(handlers: HttpTestHandlers): HttpTestServer;
+//#endregion
+//#region src/adminApiTestClient.d.ts
+declare const jsonRequest: (method: string, body?: unknown) => HttpTestRequestInit;
+/** A bundle row as the deploy route takes it. */
+declare const toDeployBundle: (row: BundleRow) => Bundle;
+/**
+ * Admin API protocol 2 over a test client. Each JSON call checks the answer
+ * is private and names the request when it fails. `track` records what a
+ * test wrote, and `cleanup` deletes it again: its releases, then its
+ * bundles, newest first.
+ */
+declare const createAdminApiTestClient: (getClient: () => HttpTestClient) => {
+  admin: (path: string, init?: HttpTestRequestInit) => Promise<Response>;
+  adminJson: (path: string, init?: HttpTestRequestInit) => Promise<any>;
+  deploy: (deployment: {
+    readonly bundle: Bundle;
+    readonly release: DeployReleasePolicy;
+  } | {
+    readonly bundleId: string;
+    readonly release: DeployReleasePolicy;
+  }) => Promise<ReleaseRow>;
+  ensureChannel: (name: string) => Promise<ChannelRow>;
+  removeRelease: (id: string) => Promise<void>;
+  /** Tracks a release the server wrote for a test, such as a promotion's copy. */
+  track: (releaseId: string) => void;
+  /** Stops tracking a release a test already deleted. */
+  forget: (releaseId: string) => void;
+  cleanup: () => Promise<void>;
+};
+type AdminApiTestClient = ReturnType<typeof createAdminApiTestClient>;
+//#endregion
+//#region src/setupBundleMethodsTestSuite.d.ts
+/**
+ * Bundles through admin API protocol 2: deployed with a release, read by
+ * id, paged by key, changed, and deleted. Each test deletes what it wrote.
+ */
+declare const setupBundleMethodsTestSuite: (options: {
+  readonly getClient: () => HttpTestClient;
+}) => void;
+//#endregion
+//#region src/setupCoreAdminTestSuite.d.ts
+/**
+ * Core's operations through admin API protocol 2 that the bundle and catalog
+ * suites leave out: channels, deploy refusals, promotion, preflights, and a
+ * bundle's patch children. Each test deletes what it wrote.
+ */
+declare const setupCoreAdminTestSuite: (options: {
+  readonly getClient: () => HttpTestClient;
+}) => void;
+//#endregion
+//#region src/setupInsightsHttpTestSuite.d.ts
+/**
+ * The Insights plugin's routes on a database: a client reports an event, and
+ * the admin routes read it back. The server must run `insights()`.
+ */
+declare const setupInsightsHttpTestSuite: (options: {
+  readonly getClient: () => HttpTestClient;
+}) => void;
+//#endregion
+//#region src/databaseTestRunner.d.ts
+type Awaitable<T> = Promise<T> | T;
+/** How a suite gets a provider's database, and gives it back. */
+type DatabaseTestLifecycle<TDatabase> = {
+  readonly name: string;
+  /** Creates the provider's tables and settings rows, before `createDatabase`. */
+  readonly migrate: () => Awaitable<void>;
+  /** The provider's database, as its factory returns it. */
+  readonly createDatabase: () => Awaitable<TDatabase>;
+  /** Empties every table between tests. */
+  readonly reset: (database: TDatabase) => Awaitable<void>;
+  readonly dispose: (database: TDatabase) => Awaitable<void>;
+};
+//#endregion
+//#region src/setupInsightsModelTestSuite.d.ts
+/**
+ * The Insights report contract on one database: pass the Insights plugin's
+ * model over it, `createInsightsModel(createDatabasePluginApis(database,
+ * [insights()]).insights)`, as `createDatabase`.
+ */
+declare const setupInsightsModelTestSuite: (lifecycle: DatabaseTestLifecycle<InsightsModel>) => void;
+//#endregion
+//#region src/setupSemverSatisfiesTestSuite.d.ts
+/**
+ *
+ * Filters based on semver. And sorts by the highest bundle version.
+ *
+ * * Range Expression Table:
+ *
+ * | Range Expression | Who gets the update                                                    |
+ * |------------------|------------------------------------------------------------------------|
+ * | 1.2.3            | Only devices running the specific binary app store version 1.2.3 of your app |
+ * | *                | Any device configured to consume updates from your CodePush app         |
+ * | 1.2.x            | Devices running major version 1, minor version 2 and any patch version of your app |
+ * | 1.2.3 - 1.2.7    | Devices running any binary version between 1.2.3 (inclusive) and 1.2.7 (inclusive) |
+ * | >=1.2.3 <1.2.7   | Devices running any binary version between 1.2.3 (inclusive) and 1.2.7 (exclusive) |
+ * | 1.2              | Equivalent to >=1.2.0 <1.3.0                                            |
+ * | ~1.2.3           | Equivalent to >=1.2.3 <1.3.0                                            |
+ * | ^1.2.3           | Equivalent to >=1.2.3 <2.0.0                                            |
+ */
+declare const setupSemverSatisfiesTestSuite: ({ semverSatisfies }: {
+  semverSatisfies: (targetAppVersion: string, currentVersion: string) => Promise<boolean> | boolean;
+}) => void;
+//#endregion
+//#region src/setupDatabaseTestSuite.d.ts
+type DatabaseTestSuiteOptions<TDatabase extends EngineDatabase = EngineDatabase> = DatabaseTestLifecycle<TDatabase> & {
+  /**
+   * Serves the handlers of `createHotUpdater({ database, storage, plugins:
+   * [insights()], clientAccess: "public" })` over HTTP: in process, or in the
+   * runtime the provider deploys to.
+   */
+  readonly createHttpClient: (options: {
+    readonly database: TDatabase;
+    readonly storage: readonly StoragePlugin[];
+  }) => HttpTestServer | Promise<HttpTestServer>;
+  /**
+   * The Insights plugin's model on the database, to run the Insights report
+   * contract on its tables: `(database) => createInsightsModel(
+   * createDatabasePluginApis(database, [insights()]).insights)`.
+   */
+  readonly createInsightsModel?: (database: TDatabase) => InsightsModel;
+};
+/**
+ * A provider's database under Hot Updater's server: core's operations, the
+ * Release Catalog contract, bundles, and Insights, all through HTTP, on the
+ * tables the provider's tooling creates; with `createInsightsModel`, also the
+ * Insights report contract in process.
+ */
+declare const setupDatabaseTestSuite: <TDatabase extends EngineDatabase>(options: DatabaseTestSuiteOptions<TDatabase>) => void;
+//#endregion
+//#region src/setupDatabaseAdapterConformanceSuite.d.ts
+interface DatabaseAdapterConformanceContext {
+  readonly tables: readonly PhysicalTable[];
+  /** Test-only: the adapter must fetch at most this many rows per native page. */
+  readonly nativePageSize?: number;
+}
+interface DatabaseAdapterConformanceOptions {
+  readonly name: string;
+  /** Returns an adapter over freshly created, empty tables. */
+  readonly createAdapter: (context: DatabaseAdapterConformanceContext) => Promise<{
+    readonly adapter: DatabaseAdapter;
+    readonly cleanup?: () => Promise<void>;
+  }>;
+  /** The most ops one atomic write accepts; omit when the backend has no limit. */
+  readonly maxOps?: number;
+  /** Concurrent writers in the contention cases (default 32). */
+  readonly writers?: number;
+}
+declare const conformanceItems: PhysicalTable;
+declare const conformanceCounters: PhysicalTable;
+/**
+ * The storage-adapter conformance contract (PRD S3 and S4 cases). Every
+ * adapter runs it through `verifyAdapter`, which also checks each read and
+ * write at the adapter boundary.
+ */
+declare const setupDatabaseAdapterConformanceSuite: (options: DatabaseAdapterConformanceOptions) => void;
+//#endregion
+//#region src/sqlRowsExamined.d.ts
+/**
+ * Rows a SQL database examined for the reads a storage adapter made: what
+ * read-budget suites compare with the rows the adapter read.
+ */
+interface RowsExamined {
+  /** Counts the reads from now on, and only those. */
+  reset(): void;
+  /** Rows examined for the reads since `reset`. */
+  total(): Promise<number>;
+  /** Rows the backend examines natively for each row it returns (default 1). */
+  readonly perRow?: number;
+  /** Rows the backend examines natively for each read beyond those (default 0). */
+  readonly perRead?: number;
+}
+/** A statement as the SQL core runs it. */
+interface SqlStatementLike {
+  readonly sql: string;
+  readonly params: readonly unknown[];
+}
+/** A SQL core executor: its top-level `execute` runs the adapter's reads. */
+interface SqlExecutorLike {
+  execute(statement: SqlStatementLike): Promise<unknown>;
+}
+/** Runs one statement on the session reads are explained on. */
+type SqlQuery = (sql: string, params: readonly unknown[]) => Promise<readonly Record<string, unknown>[]>;
+/**
+ * Rows examined on PostgreSQL (PGlite or a server). Each SELECT a wrapped
+ * executor runs is first run under `EXPLAIN (ANALYZE, FORMAT JSON)` on
+ * `query`, one session with the planner settings above; each `reset` first
+ * vacuums and analyzes, as autovacuum keeps a production database. A plan
+ * then takes the index path a production-sized table takes, and a read no
+ * index serves still scans. A statement counts the rows its busiest table
+ * read examined, so an exact plan counts the rows it returns, a multi-valued
+ * index's own table included.
+ */
+declare const postgresRowsExamined: (query: SqlQuery) => {
+  /** The executor, examining each SELECT it runs outside a transaction. */
+  wrap: <T extends SqlExecutorLike>(executor: T) => T;
+  examined: {
+    reset(): void;
+    total(): Promise<number>;
+  };
+};
+/**
+ * Rows examined on MySQL. Each SELECT a wrapped executor runs is first run
+ * under `EXPLAIN ANALYZE` on `query`, one session, after `ANALYZE TABLE` of
+ * the tables it reads once per `reset`, and with multi-range reads always
+ * on, so a secondary index's range is costed with sorted row reads, as a
+ * production-sized table's is. A statement counts the rows its busiest table
+ * read examined; a filter above a table read drops rows that read produced.
+ */
+declare const mysqlRowsExamined: (query: SqlQuery) => {
+  /** The executor, examining each SELECT it runs outside a transaction. */
+  wrap: <T extends SqlExecutorLike>(executor: T) => T;
+  examined: {
+    reset(): void;
+    total(): Promise<number>;
+  };
+};
+//#endregion
+//#region src/setupReadBudgetTestSuite.d.ts
+/** Core's API with the client routes' reads, which the public API leaves out. */
+type ReadBudgetCore = HotUpdaterCoreApi & {
+  getReleaseCatalog(input: {
+    readonly strategy: "APP_VERSION";
+    readonly platform: "ios" | "android";
+    readonly channelKey: string;
+    readonly appVersion: string;
+  }): Promise<ReleaseCatalog | null>;
+  getArtifactInfo(targetBundleId: string, currentBundleId: string, artifactProtocolVersion: 1): Promise<ArtifactInfo | null>;
+  latestReleaseId(scopeKey: string): Promise<string | null>;
+};
+/** How core reads bundle manifests and resolves file URLs. */
+interface ReadBudgetStorage {
+  readonly readStorageText?: (storageUri: string) => Promise<string | null>;
+  readonly resolveFileUrl: (storageUri: string | null) => Promise<string | null>;
+}
+/** What `createMeasuredDatabase` returns: core and the plugins on one engine in verify mode. */
+interface ReadBudgetDatabase {
+  readonly core: ReadBudgetCore;
+  readonly api: Readonly<Record<string, unknown>>;
+  readonly clientAuth?: {
+    authenticate(headers: Headers): Promise<boolean>;
+  };
+  measureReads<T>(read: () => Promise<T>): Promise<{
+    readonly result: T;
+    readonly adapter: DatabaseReadCount;
+    readonly engine: {
+      readonly calls: number;
+      readonly rows: number;
+    };
+  }>;
+}
+/**
+ * What the suite takes from `@hot-updater/server`; pass those exports, which
+ * keeps test-utils free of a dependency on the server.
+ */
+interface ReadBudgetServer {
+  /** `createMeasuredDatabase` from `@hot-updater/server/db`. */
+  createMeasuredDatabase(adapter: DatabaseAdapter, plugins: readonly unknown[], options: {
+    readonly now: () => number;
+    readonly storage: ReadBudgetStorage;
+  }): ReadBudgetDatabase;
+  /** `builtInSchema` from `@hot-updater/server/database`: the tables to create. */
+  readonly builtInSchema: {
+    readonly tables: readonly PhysicalTable[];
+  };
+  /** `[insights(), apiKeys()]`, the built-in plugins whose reads have budgets. */
+  readonly plugins: readonly unknown[];
+  /** `targetBaseCandidateKey` from `@hot-updater/server/db`. */
+  targetBaseCandidateKey(target: {
+    readonly channelId: string;
+    readonly platform: string;
+    readonly fingerprintHash: string | null;
+    readonly appVersion: string | null;
+  }): string | null;
+}
+interface ReadBudgetAdapterContext {
+  readonly tables: readonly PhysicalTable[];
+  /** Test-only: the adapter must fetch at most this many rows per native page. */
+  readonly nativePageSize: number;
+}
+interface ReadBudgetSuiteOptions {
+  readonly name: string;
+  readonly server: ReadBudgetServer;
+  /** Returns an adapter over freshly created, empty tables. */
+  readonly createAdapter: (context: ReadBudgetAdapterContext) => Promise<{
+    readonly adapter: DatabaseAdapter;
+    readonly cleanup?: () => Promise<void>;
+    /** SQL backends: the rows the database examined for the adapter's reads. */
+    readonly examined?: RowsExamined;
+    /**
+     * Index reads return row copies without `_v`, as the key-value adapter's
+     * do, so a transaction reads the rows it guards again, whole.
+     */
+    readonly indexCopies?: boolean;
+  }>;
+}
+/**
+ * The read-budget suite (PRD S4) on one backend: core and the built-in
+ * plugins in verify mode over the backend's adapter, native pages capped at
+ * two rows. Every API in the read-budget list reads exactly its budget at the
+ * adapter and at the engine; with `examined`, the database examines no more
+ * rows than the adapter read, within the backend's native multipliers.
+ */
+declare const setupReadBudgetTestSuite: (options: ReadBudgetSuiteOptions) => void;
+//#endregion
+//#region src/runContentionHarness.d.ts
+/** Delays every adapter call by `ms`, like a round trip to a remote database. */
+declare const withAdapterLatency: (adapter: DatabaseAdapter, ms: number) => DatabaseAdapter;
+interface ContentionOptions {
+  /** How many transactions to start. */
+  readonly transactions: number;
+  /** Arrivals per second, spaced evenly. */
+  readonly ratePerSecond: number;
+  /** At most this many run at once, like a connection pool. */
+  readonly concurrency: number;
+  /** Runs transaction `index` to completion. */
+  readonly run: (index: number) => Promise<unknown>;
+}
+interface ContentionReport {
+  readonly transactions: number;
+  readonly committed: number;
+  /** Errors thrown by `run`, counted by error name. */
+  readonly errors: Readonly<Record<string, number>>;
+  readonly durationMs: number;
+}
+/**
+ * Starts `transactions` runs at a steady arrival rate through a fixed pool and
+ * reports how they ended. Retry counts come from the engine's `onRetry`.
+ */
+declare const runContentionHarness: (options: ContentionOptions) => Promise<ContentionReport>;
+//#endregion
+//#region src/createPluginTestHarness.d.ts
+interface HarnessModule {
+  readonly id: string;
+  readonly schema: object;
+  readonly namespace?: string;
+}
+interface HarnessEngine {
+  database(module: HarnessModule): unknown;
+  measureReads<T>(read: () => Promise<T>): Promise<{
+    readonly result: T;
+    readonly adapter: DatabaseReadCount;
+    readonly engine: {
+      readonly calls: number;
+      readonly rows: number;
+    };
+  }>;
+}
+/**
+ * What the harness takes from `@hot-updater/server/database`; pass that
+ * module, which keeps test-utils free of a dependency on the server.
+ */
+interface PluginTestEngine {
+  resolveSchema(modules: readonly HarnessModule[]): {
+    readonly tables: readonly PhysicalTable[];
+  };
+  createDatabaseEngine(options: {
+    readonly adapter: DatabaseAdapter;
+    readonly schema: never;
+    readonly verify?: boolean;
+  }): HarnessEngine;
+}
+interface HarnessPlugin {
+  readonly id: string;
+  readonly schema: object;
+  init(context: never): {
+    readonly api: unknown;
+  };
+}
+interface PluginTestHarnessOptions {
+  /** `import * as engine from "@hot-updater/server/database"`. */
+  readonly engine: PluginTestEngine;
+  /** Defaults to a fresh memory adapter. */
+  readonly adapter?: DatabaseAdapter;
+  /** The plugin's clock; `setNow` changes it later. */
+  readonly now?: () => number;
+}
+/**
+ * Runs one plugin the way `createHotUpdater` does, on a memory adapter in
+ * verify mode, so tests can call its API and measure what each call reads.
+ */
+declare const createPluginTestHarness: <TPlugin extends HarnessPlugin>(plugin: TPlugin, options: PluginTestHarnessOptions) => Promise<{
+  api: ReturnType<TPlugin["init"]>["api"];
+  instance: ReturnType<TPlugin["init"]>;
+  /** The plugin's own database handle; cast it to its `HotUpdaterDatabase` type. */
+  db: unknown;
+  adapter: DatabaseAdapter;
+  tables: readonly PhysicalTable[];
+  /** Reads at both boundaries while `read` runs. */
+  measureReads: <T>(read: () => Promise<T>) => Promise<{
+    readonly result: T;
+    readonly adapter: DatabaseReadCount;
+    readonly engine: {
+      readonly calls: number;
+      readonly rows: number;
+    };
+  }>;
+  setNow: (now: () => number) => void;
+}>;
+//#endregion
+//#region src/setupReleaseCatalogTestSuite.d.ts
+/**
+ * Server conformance through HTTP only, on admin API protocol 2. The caller
+ * owns server, database, and storage setup. Releases are written with
+ * `POST /releases` and changed with `PATCH /releases/:id`; lifecycle scenarios
+ * feed HTTP catalogs to the production client selector. Each test deletes
+ * what it wrote, so a long-lived server can run the suite again.
+ */
+declare const setupReleaseCatalogTestSuite: (options: {
+  readonly getClient: () => HttpTestClient;
+}) => void;
+//#endregion
+//#region src/httpTestServer.d.ts
+/** Serve Web handlers over loopback TCP; contract tests use real fetch requests. */
+declare function startHttpTestServer(handlers: HttpTestHandlers): Promise<HttpTestServer>;
+//#endregion
+//#region src/releaseCatalogHttpFixtures.d.ts
+declare const releaseCatalogDownloadUrl: (uri: string) => string;
+declare const RELEASE_CATALOG_MANIFEST_URIS: {
+  small: string;
+  large: string;
+};
+declare const RELEASE_CATALOG_DOWNLOAD_HASH: string;
+declare const releaseCatalogArtifact: (bundle: BundleRow) => ArtifactInfo;
+/** Install these storage objects in the test server, independently of its DB. */
+declare const RELEASE_CATALOG_STORAGE_FIXTURES: Readonly<Record<string, string>>;
+/** Storage boundary shared by provider and separately spawned server tests. */
+declare const createReleaseCatalogTestStorage: () => StoragePlugin;
+//#endregion
+export { AdminApiTestClient, ContentionOptions, ContentionReport, DatabaseAdapterConformanceContext, DatabaseAdapterConformanceOptions, type DatabaseTestLifecycle, DatabaseTestSuiteOptions, HttpTestClient, HttpTestHandlers, HttpTestRequest, HttpTestRequestInit, HttpTestServer, PluginTestEngine, PluginTestHarnessOptions, RELEASE_CATALOG_DOWNLOAD_HASH, RELEASE_CATALOG_MANIFEST_URIS, RELEASE_CATALOG_STORAGE_FIXTURES, ReadBudgetAdapterContext, ReadBudgetDatabase, ReadBudgetServer, ReadBudgetStorage, ReadBudgetSuiteOptions, RowsExamined, SqlExecutorLike, SqlQuery, SqlStatementLike, conformanceCounters, conformanceItems, createAdminApiTestClient, createHandlerHttpTestClient, createHttpTestClient, createPluginTestHarness, createReleaseCatalogTestStorage, jsonRequest, mysqlRowsExamined, postgresRowsExamined, releaseCatalogArtifact, releaseCatalogDownloadUrl, runContentionHarness, setupBundleMethodsTestSuite, setupCoreAdminTestSuite, setupDatabaseAdapterConformanceSuite, setupDatabaseTestSuite, setupInsightsHttpTestSuite, setupInsightsModelTestSuite, setupReadBudgetTestSuite, setupReleaseCatalogTestSuite, setupSemverSatisfiesTestSuite, startHttpTestServer, toDeployBundle, withAdapterLatency };