@kovojs/test

function assertMutationError<
  const Key extends string,
  InputSchema extends Schema<unknown>,
  Errors extends Record<string, Schema<unknown>>,
  Request,
  Value,
  const Code extends Extract<keyof Errors, string>,
>(
  mutation: MutationDefinition<Key, InputSchema, Errors, Request, Value>,
  result: MutationResult<Value>,
  expected: MutationErrorExpectation<Errors, Code>,
): InferSchema<Errors[Code]>;

function propertyTest<State, Input, ClientShape = State>(
  options: PropertyTestOptions<State, Input, ClientShape>,
): PropertyTestResult;

import { propertyTest } from '@kovojs/test/assertions';

type Cart = { count: number };

const result = propertyTest<Cart, { quantity: number }>({
  apply: (state, input) => ({ count: state.count + input.quantity }),
  predict: (state, input) => ({ count: state.count + input.quantity }),
  cases: [{ state: { count: 0 }, input: { quantity: 2 } }],
});
// result.cases === 1

type MutationErrorExpectation<
  Errors extends Record<string, Schema<unknown>>,
  Code extends Extract<keyof Errors, string>,
> =
  | Code
  | {
      code: Code;
      payload?: InferSchema<Errors[Code]>;
    };

interface PropertyCase<State, Input> {
  input: Input;
  state: State;
}

interface PropertyTestOptions<State, Input, ClientShape = unknown> {
  apply: (state: State, input: Input) => State;
  cases: Iterable<PropertyCase<State, Input>>;
  predict: (state: State, input: Input) => ClientShape;
  shape?: (state: State) => ClientShape;
}

interface PropertyTestResult {
  cases: number;
}

function headerValues(source: HeaderSource, name: string): string[];

function setCookieValues(source: HeaderSource): string[];

function cookiePair(setCookie: string | undefined): string;

function firstSetCookiePair(source: HeaderSource): string;

function enhancedMutationHeaders(
  options: EnhancedMutationHeaderOptions = {},
): Record<string, string>;

type HeaderRecord = Record<string, string | string[] | undefined>;

type HeaderSource = Headers | HeaderRecord | undefined;

interface EnhancedMutationTarget {
  queries?: readonly string[] | string;
  target: string;
}

interface EnhancedMutationLiveTarget {
  component: string;
  props?: Record<string, unknown>;
  target: string;
}

interface EnhancedMutationHeaderOptions {
  formTarget?: string;
  liveTargets?: readonly (EnhancedMutationLiveTarget | string)[] | string;
  targets?: readonly (EnhancedMutationTarget | string)[] | string;
}

function createKovoTestHarness<Db>(
  options: KovoTestHarnessOptions<Db>,
): KovoTestContext<Db>;

interface KovoTestContext<Db = unknown> {
  db: Db;
  dbHandle(): Db;
  exec: <
    InputSchema extends Schema<unknown>,
    Errors extends Record<string, Schema<unknown>>,
    Request extends { db: unknown },
    Value,
  >(
    mutation: MutationDefinition<string, InputSchema, Errors, Request, Value>,
    input: unknown,
    options?: KovoTestExecOptions<Request>,
  ) => Promise<MutationResult<Value>>;
  page: (path: string) => Promise<PageAssertion>;
  query: (query: QueryDefinition, input?: unknown) => Promise<unknown>;
  verificationDiagnostics(): readonly DbVerificationDiagnostic[];
}

interface KovoTestRequest<Db> {
  db: Db;
}

interface KovoTestHarnessOptions<Db> {
  db: Db;
  pages?: Record<string, string | (() => string | Promise<string>)>;
  request?: Record<string, unknown>;
  touchGraph?: CoreGraph.TouchGraph;
  verification?: DbVerificationConfig;
}

type KovoTestExecOptions<Request> = HarnessMutationOptions<Request>;

async function executeHarnessMutation<
  InputSchema extends Schema<unknown>,
  Errors extends Record<string, Schema<unknown>>,
  Request extends { db: unknown },
  Value,
>(
  mutation: MutationDefinition<string, InputSchema, Errors, Request, Value>,
  input: unknown,
  db: Request['db'],
  requestFixture: Record<string, unknown> | undefined,
  verifier: HarnessOperationVerifier | null,
  options?: HarnessMutationOptions<Request>,
): Promise<MutationResult<Value>>;

async function loadHarnessPage(
  pages: Record<string, string | (() => string | Promise<string>)> | undefined,
  path: string,
): Promise<PageAssertion>;

async function executeHarnessQuery<Db>(
  query: QueryDefinition,
  input: unknown,
  db: Db,
  requestFixture: Record<string, unknown> | undefined,
  verifier: HarnessOperationVerifier | null,
): Promise<unknown>;

interface HarnessOperationVerifier {
  assertCoveredOperations(observed: readonly ObservedDbOperation[], touchGraphKey?: string): void;
  assertReadsCoveredOperations(
    observed: readonly ObservedDbOperation[],
    domains: readonly string[],
  ): void;
  capture<T>(
    callback: () => T | Promise<T>,
  ): Promise<{ observed: readonly ObservedDbOperation[]; result: T }>;
}

interface HarnessMutationOptions<Request> {
  csrf?: CsrfValidationOptions<Request>;
  request?: Partial<Omit<Request, 'db'>>;
  touchGraphKey?: string;
}

function fragmentHtml(html: string, target: string): string;

function htmlElementCount(html: string, selector: HtmlElementSelector = {}): number;

function htmlElementFacts(
  html: string,
  selector: HtmlElementSelector = {},
): HtmlElementFact[];

function htmlJsonScriptFacts(
  html: string,
  attrs: Record<string, string | true> = { type: 'application/json' },
): HtmlJsonScriptFact[];

function htmlDocumentFacts(html: string): HtmlDocumentFact;

function htmlDocumentRegions(html: string): HtmlDocumentRegions;

function htmlMainMarkerFact(
  html: string,
  attribute = 'data-kovo-check-export',
): HtmlMainMarkerFact;

function htmlLinkHrefs(html: string, attrs: Record<string, string | true> = {}): string[];

function kovoQueryFacts(html: string, name?: string): KovoQueryFact[];

function kovoFragmentFacts(html: string, target?: string): KovoFragmentFact[];

function kovoResponseBodyFact(html: string): KovoResponseBodyFact;

function kovoQueryJsonValues(html: string, name: string): unknown[];

function documentQueryScriptBehaviorFact(
  renderedDocument: string,
  options: {
    queryName: string;
    renderedDocumentQueryScript: string;
    renderedQueryScript: string;
  },
): DocumentQueryScriptBehaviorFact;

function htmlFormFacts(html: string): HtmlFormFact[];

function htmlFormActions(html: string): string[];

function htmlFormFields(html: string, name?: string): HtmlFormFieldFact[];

function htmlFormFieldsByName(
  form: HtmlFormFact | undefined,
): Record<string, HtmlFormFieldFact>;

function htmlKeyFacts(html: string, key?: string): HtmlKeyFact[];

function htmlKeyValues(html: string): string[];

function htmlKeyTextMap(html: string): Record<string, string>;

function htmlTextContent(html: string): string;

interface HtmlElementFact {
  attrs: Record<string, string>;
  html: string;
  innerHtml: string;
  tag: string;
}

interface HtmlElementSelector {
  attrs?: Record<string, string | true>;
  tag?: string;
}

interface HtmlJsonScriptFact {
  attrs: Record<string, string>;
  html: string;
  json: unknown;
  rawJson: string;
}

interface HtmlDocumentFact {
  bodyAttrs: Record<string, string>;
  jsonScripts: HtmlJsonScriptFact[];
  links: HtmlElementFact[];
  metas: HtmlElementFact[];
  text: string;
  title: string;
}

interface HtmlDocumentRegions {
  body: HtmlElementFact;
  head: HtmlElementFact;
  html: HtmlElementFact;
}

interface HtmlMainMarkerFact {
  attribute: string;
  mainCount: number;
  marker: string | undefined;
}

interface KovoQueryFact {
  attrs: Record<string, string>;
  html: string;
  json: unknown;
  name: string;
  rawJson: string;
  tag: string;
}

interface KovoFragmentFact {
  attrs: Record<string, string>;
  html: string;
  innerHtml: string;
  stylesheetHrefs: string[];
  target: string;
}

interface KovoResponseBodyFact {
  fragmentTargets: string[];
  fragments: KovoFragmentFact[];
  keyValues: string[];
  queries: KovoQueryFact[];
  queryJsonByName: Record<string, unknown[]>;
  queryNames: string[];
  stylesheetHrefsByTarget: Record<string, string[]>;
}

interface DocumentQueryScriptBehaviorFact {
  bodyElements: HtmlElementFact[];
  bodyQueryScripts: Array<Pick<KovoQueryFact, 'attrs' | 'rawJson'>>;
  documentQueryScripts: Array<Pick<KovoQueryFact, 'attrs' | 'rawJson'>>;
  headQueryScripts: Array<Pick<KovoQueryFact, 'attrs' | 'rawJson'>>;
  renderedDocumentQueryScript: string;
  renderedQueryScript: string;
}

interface HtmlFormFieldFact {
  attrs: Record<string, string>;
  html: string;
  name: string;
  tag: string;
  type: string;
  value: string;
}

interface HtmlFormFact {
  action: string;
  attrs: Record<string, string>;
  fields: HtmlFormFieldFact[];
  html: string;
  innerHtml: string;
  method: string;
}

interface HtmlKeyFact {
  attrs: Record<string, string>;
  html: string;
  innerHtml: string;
  key: string;
  tag: string;
  text: string;
}

function createPageAssertion(html: string): PageAssertion;

interface PageAssertion {
  fragment(target: string): string;
  html: string;
}

async function createPgliteTestDb(options: PGliteOptions = {}): Promise<PgliteTestDb>;

interface PgliteTestDb {
  close(): Promise<void>;
  exec(statement: string): Promise<Results[]>;
  pglite: PGlite;
  query<Row extends Record<string, unknown> = Record<string, unknown>>(
    statement: string,
    params?: readonly unknown[],
  ): Promise<Row[]>;
  read<Row extends Record<string, unknown> = Record<string, unknown>>(
    table: string,
  ): Promise<Row[]>;
  sql<Row extends Record<string, unknown> = Record<string, unknown>>(
    statement: string,
    params?: readonly unknown[],
  ): Promise<Row[]>;
  write(table: string, value: Record<string, unknown>): Promise<void>;
}

function observeSqlStatementArgument(
  statement: unknown,
  config: DbVerificationConfig,
  recorder: ObservationRecorder,
): void;

function observeSqlStatementIfString(
  statement: unknown,
  config: DbVerificationConfig,
  recorder: ObservationRecorder,
): void;

function sqlStatementText(statement: unknown): string | undefined;

function kovoTest<Db>(
  name: string,
  fn: (ctx: KovoTestContext<Db>) => void | Promise<void>,
  options: KovoTestHarnessOptions<Db>,
  runner?: KovoTestRunner,
): KovoTestCase;

type KovoTestRunner = (name: string, run: () => Promise<void>) => unknown;

interface KovoTestCase {
  name: string;
  run: () => Promise<void>;
}

function createDbVerifier(
  touchGraph: CoreGraph.TouchGraph,
  config: DbVerificationConfig,
): DbVerifier;

interface DbObservationOptions {
  branch?: string;
  rowKey?: string;
}

interface DbVerificationConfig {
  domainByTable: Record<string, string>;
  exemptTables?: readonly string[];
  keyByTable?: Record<string, string>;
}

interface ObservedDbOperation {
  branch: string | undefined;
  domain: string | undefined;
  kind: 'read' | 'write';
  mutationRead: boolean | undefined;
  rowKey: string | undefined;
  sql: string | undefined;
  table: string;
}

interface DbVerifier {
  assertCovered(touchGraphKey?: string): void;
  assertCoveredOperations(observed: readonly ObservedDbOperation[], touchGraphKey?: string): void;
  assertCoveredSince(start: number, touchGraphKey?: string): void;
  assertReadsCovered(domains: readonly string[]): void;
  assertReadsCoveredOperations(
    observed: readonly ObservedDbOperation[],
    domains: readonly string[],
  ): void;
  assertReadsCoveredSince(start: number, domains: readonly string[]): void;
  capture<T>(
    callback: () => T | Promise<T>,
  ): Promise<{ observed: readonly ObservedDbOperation[]; result: T }>;
  diagnostics(): DbVerificationDiagnostic[];
  observed: readonly ObservedDbOperation[];
  wrap<Db>(db: Db): Db;
}

function diagnosticsForObservations(
  observed: readonly ObservedDbOperation[],
  touchGraph: CoreGraph.TouchGraph,
): DbVerificationDiagnostic[];

function assertObservedWritesCovered(
  observed: readonly ObservedDbOperation[],
  touchGraph: CoreGraph.TouchGraph,
  config: DbVerificationConfig,
  touchGraphKey?: string,
): void;

function assertObservedReadsCovered(
  observed: readonly ObservedDbOperation[],
  domains: readonly string[],
  config: DbVerificationConfig,
): void;

function diagnosticMessage(code: DiagnosticCode, detail: string): string;

type DiagnosticCode =
  | 'KV201'
  | 'KV210'
  | 'KV211'
  | 'KV212'
  | 'KV220'
  | 'KV221'
  | 'KV222'
  | 'KV223'
  | 'KV224'
  | 'KV225'
  | 'KV226'
  | 'KV227'
  | 'KV228'
  | 'KV230'
  | 'KV231'
  | 'KV232'
  | 'KV233'
  | 'KV234'
  | 'KV235'
  | 'KV236'
  | 'KV237'
  | 'KV238'
  | 'KV239'
  | 'KV240'
  | 'KV241'
  | 'KV242'
  | 'KV301'
  | 'KV302'
  | 'KV303'
  | 'KV304'
  | 'KV310'
  | 'KV311'
  | 'KV320'
  | 'KV330'
  | 'KV402'
  | 'KV403'
  | 'KV404'
  | 'KV405'
  | 'KV406'
// … truncated (5 more lines); see the package source for the full declaration.

interface DbVerificationDiagnostic {
  branch?: string;
  code: DiagnosticCode;
  domain: string;
  message: string;
  severity: DiagnosticSeverity;
  site?: string;
}

function parseSqlOperations(statement: string): ParsedSqlOperation[];

type ParsedSqlOperation = Pick<
  ObservedDbOperation,
  'kind' | 'mutationRead' | 'rowKey' | 'table'
>;