@crab-dev/wake 0.1.21 → 0.1.22

package/test-react.cjs

@@ -0,0 +1,60 @@
+'use strict'
+
+const core = require('./test.cjs')
+
+function contextError() {
+  const error = new Error('@crab-dev/wake/test/react can only be used inside wake test')
+  error.name = 'WakeError'
+  error.code = 'WAKE_TEST_CONTEXT'
+  return error
+}
+
+function unavailable() {
+  throw contextError()
+}
+
+const screenEntries = { debug: unavailable }
+for (const family of [
+  'Role',
+  'Text',
+  'LabelText',
+  'DisplayValue',
+  'PlaceholderText',
+  'AltText',
+  'Title',
+  'TestId',
+]) {
+  for (const prefix of ['getBy', 'getAllBy', 'queryBy', 'queryAllBy', 'findBy', 'findAllBy']) {
+    screenEntries[`${prefix}${family}`] = unavailable
+  }
+}
+const screen = Object.freeze(screenEntries)
+
+const userEvent = Object.freeze({ setup: unavailable })
+
+const fireEvent = Object.freeze(Object.assign(
+  (...args) => unavailable(...args),
+  {
+    change: unavailable,
+    click: unavailable,
+    input: unavailable,
+    keyDown: unavailable,
+    keyUp: unavailable,
+    submit: unavailable,
+  },
+))
+
+module.exports = Object.freeze({
+  ...core,
+  act: unavailable,
+  cleanup: unavailable,
+  fireEvent,
+  prettyDOM: unavailable,
+  render: unavailable,
+  renderHook: unavailable,
+  screen,
+  userEvent,
+  waitFor: unavailable,
+  waitForElementToBeRemoved: unavailable,
+  within: unavailable,
+})

package/test-react.d.ts

@@ -0,0 +1,162 @@
+import type { ReactElement, ReactNode } from 'react'
+
+export * from '@crab-dev/wake/test'
+
+export interface RenderOptions {
+  container?: HTMLElement
+  baseElement?: HTMLElement
+  hydrate?: boolean
+  strict?: boolean
+  wrapper?: (props: { children: ReactNode }) => ReactElement
+  identifierPrefix?: string
+  onCaughtError?: (error: unknown, info: { componentStack: string }) => void
+  onUncaughtError?: (error: unknown, info: { componentStack: string }) => void
+  onRecoverableError?: (error: unknown, info: { componentStack: string }) => void
+}
+
+export interface RenderResult {
+  readonly container: HTMLElement
+  readonly baseElement: HTMLElement
+  rerender(ui: ReactElement): Promise<void>
+  unmount(): Promise<void>
+  asFragment(): DocumentFragment
+  debug(element?: Element | DocumentFragment): string
+}
+
+export interface RenderHookOptions<Props> {
+  initialProps?: Props
+  wrapper?: (props: { children: ReactNode }) => ReactElement
+  strict?: boolean
+}
+
+export interface RenderHookResult<Result, Props> {
+  readonly result: { readonly current: Result }
+  rerender(props?: Props): Promise<void>
+  unmount(): Promise<void>
+}
+
+export type TextMatcher = string | RegExp | ((content: string, element: Element) => boolean)
+
+export interface RoleQueryOptions {
+  name?: TextMatcher
+  description?: TextMatcher
+  hidden?: boolean
+  selected?: boolean
+  checked?: boolean
+  pressed?: boolean
+  expanded?: boolean
+  level?: number
+}
+
+export interface QueryOptions {
+  exact?: boolean
+  timeout?: number
+}
+
+export interface Queries {
+  getByRole(role: string, options?: RoleQueryOptions): HTMLElement
+  getAllByRole(role: string, options?: RoleQueryOptions): HTMLElement[]
+  queryByRole(role: string, options?: RoleQueryOptions): HTMLElement | null
+  queryAllByRole(role: string, options?: RoleQueryOptions): HTMLElement[]
+  findByRole(role: string, options?: RoleQueryOptions & QueryOptions): Promise<HTMLElement>
+  findAllByRole(role: string, options?: RoleQueryOptions & QueryOptions): Promise<HTMLElement[]>
+  getByText(text: TextMatcher, options?: QueryOptions): HTMLElement
+  getAllByText(text: TextMatcher, options?: QueryOptions): HTMLElement[]
+  queryByText(text: TextMatcher, options?: QueryOptions): HTMLElement | null
+  queryAllByText(text: TextMatcher, options?: QueryOptions): HTMLElement[]
+  findByText(text: TextMatcher, options?: QueryOptions): Promise<HTMLElement>
+  findAllByText(text: TextMatcher, options?: QueryOptions): Promise<HTMLElement[]>
+  getByLabelText(text: TextMatcher, options?: QueryOptions): HTMLElement
+  getAllByLabelText(text: TextMatcher, options?: QueryOptions): HTMLElement[]
+  queryByLabelText(text: TextMatcher, options?: QueryOptions): HTMLElement | null
+  queryAllByLabelText(text: TextMatcher, options?: QueryOptions): HTMLElement[]
+  findByLabelText(text: TextMatcher, options?: QueryOptions): Promise<HTMLElement>
+  findAllByLabelText(text: TextMatcher, options?: QueryOptions): Promise<HTMLElement[]>
+  getByDisplayValue(text: TextMatcher, options?: QueryOptions): HTMLElement
+  getAllByDisplayValue(text: TextMatcher, options?: QueryOptions): HTMLElement[]
+  queryByDisplayValue(text: TextMatcher, options?: QueryOptions): HTMLElement | null
+  queryAllByDisplayValue(text: TextMatcher, options?: QueryOptions): HTMLElement[]
+  findByDisplayValue(text: TextMatcher, options?: QueryOptions): Promise<HTMLElement>
+  findAllByDisplayValue(text: TextMatcher, options?: QueryOptions): Promise<HTMLElement[]>
+  getByPlaceholderText(text: TextMatcher, options?: QueryOptions): HTMLElement
+  getAllByPlaceholderText(text: TextMatcher, options?: QueryOptions): HTMLElement[]
+  queryByPlaceholderText(text: TextMatcher, options?: QueryOptions): HTMLElement | null
+  queryAllByPlaceholderText(text: TextMatcher, options?: QueryOptions): HTMLElement[]
+  findByPlaceholderText(text: TextMatcher, options?: QueryOptions): Promise<HTMLElement>
+  findAllByPlaceholderText(text: TextMatcher, options?: QueryOptions): Promise<HTMLElement[]>
+  getByAltText(text: TextMatcher, options?: QueryOptions): HTMLElement
+  getAllByAltText(text: TextMatcher, options?: QueryOptions): HTMLElement[]
+  queryByAltText(text: TextMatcher, options?: QueryOptions): HTMLElement | null
+  queryAllByAltText(text: TextMatcher, options?: QueryOptions): HTMLElement[]
+  findByAltText(text: TextMatcher, options?: QueryOptions): Promise<HTMLElement>
+  findAllByAltText(text: TextMatcher, options?: QueryOptions): Promise<HTMLElement[]>
+  getByTitle(text: TextMatcher, options?: QueryOptions): HTMLElement
+  getAllByTitle(text: TextMatcher, options?: QueryOptions): HTMLElement[]
+  queryByTitle(text: TextMatcher, options?: QueryOptions): HTMLElement | null
+  queryAllByTitle(text: TextMatcher, options?: QueryOptions): HTMLElement[]
+  findByTitle(text: TextMatcher, options?: QueryOptions): Promise<HTMLElement>
+  findAllByTitle(text: TextMatcher, options?: QueryOptions): Promise<HTMLElement[]>
+  getByTestId(id: TextMatcher, options?: QueryOptions): HTMLElement
+  getAllByTestId(id: TextMatcher, options?: QueryOptions): HTMLElement[]
+  queryByTestId(id: TextMatcher, options?: QueryOptions): HTMLElement | null
+  queryAllByTestId(id: TextMatcher, options?: QueryOptions): HTMLElement[]
+  findByTestId(id: TextMatcher, options?: QueryOptions): Promise<HTMLElement>
+  findAllByTestId(id: TextMatcher, options?: QueryOptions): Promise<HTMLElement[]>
+  debug(element?: Element | DocumentFragment): string
+}
+
+export interface UserEventOptions {
+  delayMs?: number
+  document?: Document
+}
+
+export interface UserEventController {
+  click(element: Element): Promise<void>
+  dblClick(element: Element): Promise<void>
+  type(element: Element, text: string): Promise<void>
+  clear(element: Element): Promise<void>
+  keyboard(input: string): Promise<void>
+  tab(options?: { shift?: boolean }): Promise<void>
+  hover(element: Element): Promise<void>
+  unhover(element: Element): Promise<void>
+  selectOptions(element: Element, values: string | readonly string[] | Element | readonly Element[]): Promise<void>
+  upload(element: HTMLInputElement, files: File | readonly File[]): Promise<void>
+}
+
+export interface UserEventApi {
+  setup(options?: UserEventOptions): UserEventController
+}
+
+export interface FireEventApi {
+  (element: Element, event: Event): Promise<boolean>
+  change(element: Element, init?: EventInit & { target?: Record<string, unknown> }): Promise<boolean>
+  click(element: Element, init?: MouseEventInit): Promise<boolean>
+  input(element: Element, init?: InputEventInit & { target?: Record<string, unknown> }): Promise<boolean>
+  keyDown(element: Element, init?: KeyboardEventInit): Promise<boolean>
+  keyUp(element: Element, init?: KeyboardEventInit): Promise<boolean>
+  submit(element: Element, init?: SubmitEventInit): Promise<boolean>
+}
+
+export interface WaitForOptions {
+  container?: HTMLElement
+  timeout?: number
+  interval?: number
+}
+
+export function render(ui: ReactElement, options?: RenderOptions): Promise<RenderResult>
+export function renderHook<Result, Props = void>(
+  callback: (props: Props) => Result,
+  options?: RenderHookOptions<Props>,
+): Promise<RenderHookResult<Result, Props>>
+export function cleanup(): Promise<void>
+export function act<T>(callback: () => T | PromiseLike<T>): Promise<Awaited<T>>
+export function waitFor<T>(callback: () => T | PromiseLike<T>, options?: WaitForOptions): Promise<T>
+export function waitForElementToBeRemoved(
+  callback: () => Element | readonly Element[] | null,
+  options?: WaitForOptions,
+): Promise<void>
+export function prettyDOM(element?: Element | DocumentFragment, maxLength?: number): string
+export function within(element: HTMLElement): Queries
+export const screen: Queries
+export const userEvent: UserEventApi
+export const fireEvent: FireEventApi

package/test-react.mjs

@@ -0,0 +1,29 @@
+import api from './test-react.cjs'
+
+export {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  clock,
+  describe,
+  expect,
+  it,
+  mock,
+  network,
+  test,
+} from './test.mjs'
+
+export const {
+  act,
+  cleanup,
+  fireEvent,
+  prettyDOM,
+  render,
+  renderHook,
+  screen,
+  userEvent,
+  waitFor,
+  waitForElementToBeRemoved,
+  within,
+} = api

package/test.cjs

@@ -0,0 +1,98 @@
+'use strict'
+
+function contextError() {
+  const error = new Error('@crab-dev/wake/test can only be used inside wake test')
+  error.name = 'WakeError'
+  error.code = 'WAKE_TEST_CONTEXT'
+  return error
+}
+
+function unavailable() {
+  throw contextError()
+}
+
+function callable(properties) {
+  const entry = (...args) => unavailable(...args)
+  return Object.freeze(Object.assign(entry, properties))
+}
+
+function testApi() {
+  const entry = (...args) => unavailable(...args)
+  entry.only = entry
+  entry.skip = entry
+  entry.todo = unavailable
+  entry.each = unavailable
+  return Object.freeze(entry)
+}
+
+function describeApi() {
+  const entry = (...args) => unavailable(...args)
+  entry.only = entry
+  entry.skip = entry
+  entry.each = unavailable
+  return Object.freeze(entry)
+}
+
+const test = testApi()
+const describe = describeApi()
+
+const expect = callable({
+  extend: unavailable,
+  addEqualityTesters: unavailable,
+  addSnapshotSerializer: unavailable,
+  assertions: unavailable,
+  hasAssertions: unavailable,
+  getState: unavailable,
+  setState: unavailable,
+  any: unavailable,
+  anything: unavailable,
+  arrayContaining: unavailable,
+  objectContaining: unavailable,
+  stringContaining: unavailable,
+  stringMatching: unavailable,
+  closeTo: unavailable,
+})
+
+const mock = Object.freeze({
+  fn: unavailable,
+  spyOn: unavailable,
+  replaceProperty: unavailable,
+  module: unavailable,
+  import: unavailable,
+  actual: unavailable,
+  isolate: unavailable,
+  clearAll: unavailable,
+  resetAll: unavailable,
+  restoreAll: unavailable,
+})
+
+const clock = Object.freeze({
+  fake: unavailable,
+  restore: unavailable,
+  advanceBy: unavailable,
+  advanceTo: unavailable,
+  runNext: unavailable,
+  runAll: unavailable,
+  flushMicrotasks: unavailable,
+})
+
+const network = Object.freeze({
+  route: unavailable,
+  allow: unavailable,
+  requests: unavailable,
+  reset: unavailable,
+})
+
+module.exports = Object.freeze({
+  afterAll: unavailable,
+  afterEach: unavailable,
+  beforeAll: unavailable,
+  beforeEach: unavailable,
+  clock,
+  describe,
+  expect,
+  it: test,
+  mock,
+  network,
+  test,
+})

package/test.d.ts

@@ -0,0 +1,265 @@
+export type Awaitable<T> = T | PromiseLike<T>
+export type TestCallback = () => Awaitable<void>
+
+export interface TestCaseOptions {
+  timeout: number
+}
+
+export interface Each {
+  <T extends readonly unknown[]>(table: readonly T[]): (
+    name: string,
+    callback: (...values: T) => Awaitable<void>,
+    options?: TestCaseOptions,
+  ) => void
+  <T>(table: readonly T[]): (
+    name: string,
+    callback: (value: T) => Awaitable<void>,
+    options?: TestCaseOptions,
+  ) => void
+}
+
+export interface TestApi {
+  (name: string, callback: TestCallback, options?: TestCaseOptions): void
+  readonly only: TestApi
+  readonly skip: TestApi
+  todo(name: string): void
+  readonly each: Each
+}
+
+export interface DescribeApi {
+  (name: string, callback: () => void): void
+  readonly only: DescribeApi
+  readonly skip: DescribeApi
+  readonly each: Each
+}
+
+export interface AsymmetricMatcher {
+  asymmetricMatch(value: unknown): boolean
+  toString(): string
+}
+
+export interface MatcherResult {
+  pass: boolean
+  message(): string
+}
+
+export type MatcherFunction = (
+  received: unknown,
+  ...expected: unknown[]
+) => Awaitable<MatcherResult>
+
+/** Augment this interface to type matchers registered through `expect.extend()`. */
+export interface CustomMatchers {}
+
+export interface Matchers<R = void> extends CustomMatchers {
+  readonly not: Matchers<R>
+  readonly resolves: Matchers<Promise<void>>
+  readonly rejects: Matchers<Promise<void>>
+  toBe(expected: unknown): R
+  toEqual(expected: unknown): R
+  toStrictEqual(expected: unknown): R
+  toBeDefined(): R
+  toBeUndefined(): R
+  toBeNull(): R
+  toBeTruthy(): R
+  toBeFalsy(): R
+  toBeNaN(): R
+  toBeGreaterThan(expected: number | bigint): R
+  toBeGreaterThanOrEqual(expected: number | bigint): R
+  toBeLessThan(expected: number | bigint): R
+  toBeLessThanOrEqual(expected: number | bigint): R
+  toBeCloseTo(expected: number, digits?: number): R
+  toContain(expected: unknown): R
+  toContainEqual(expected: unknown): R
+  toHaveLength(expected: number): R
+  toMatch(expected: string | RegExp): R
+  toMatchObject(expected: object): R
+  toHaveProperty(path: string | readonly (string | number)[], expected?: unknown): R
+  toBeInstanceOf(expected: Function): R
+  toThrow(expected?: string | RegExp | Function | Error): R
+  toHaveBeenCalled(): R
+  toHaveBeenCalledTimes(count: number): R
+  toHaveBeenCalledWith(...expected: unknown[]): R
+  toHaveBeenLastCalledWith(...expected: unknown[]): R
+  toHaveBeenNthCalledWith(call: number, ...expected: unknown[]): R
+  toHaveReturned(): R
+  toHaveReturnedTimes(count: number): R
+  toHaveReturnedWith(expected: unknown): R
+  toHaveLastReturnedWith(expected: unknown): R
+  toHaveNthReturnedWith(call: number, expected: unknown): R
+  toMatchSnapshot(propertyMatchers?: object, hint?: string): R
+  /** Browser-only exact visual snapshot for the current viewport or received Element. */
+  toMatchScreenshot(hint?: string): Promise<void>
+  toBeInTheDocument(): R
+  toContainElement(element: Element | null): R
+  toContainHTML(html: string): R
+  toBeEmptyDOMElement(): R
+  toBeVisible(): R
+  toBeEnabled(): R
+  toBeDisabled(): R
+  toHaveAttribute(name: string, value?: string | RegExp): R
+  toHaveClass(...classNames: string[]): R
+  toHaveStyle(style: string | Record<string, string | number>): R
+  toHaveTextContent(text: string | RegExp, options?: { normalizeWhitespace?: boolean }): R
+  toHaveValue(value?: string | number | readonly string[]): R
+  toHaveDisplayValue(value: string | RegExp | readonly (string | RegExp)[]): R
+  toHaveFormValues(values: Record<string, unknown>): R
+  toHaveFocus(): R
+  toBeChecked(): R
+  toBePartiallyChecked(): R
+  toBeRequired(): R
+  toBeInvalid(): R
+  toBeValid(): R
+  toHaveAccessibleName(name?: string | RegExp): R
+  toHaveAccessibleDescription(description?: string | RegExp): R
+  toHaveAccessibleErrorMessage(message?: string | RegExp): R
+  toHaveRole(role: string): R
+  toHaveSelection(selection: string): R
+}
+
+export interface Expect {
+  <T>(received: T): Matchers
+  extend(matchers: Readonly<Record<string, MatcherFunction>>): void
+  addEqualityTesters(testers: readonly ((left: unknown, right: unknown) => boolean | undefined)[]): void
+  addSnapshotSerializer(serializer: {
+    test(value: unknown): boolean
+    print(value: unknown, serialize: (value: unknown) => string): string
+  }): void
+  assertions(count: number): void
+  hasAssertions(): void
+  getState(): Readonly<Record<string, unknown>>
+  setState(state: Readonly<Record<string, unknown>>): void
+  anything(): AsymmetricMatcher
+  any(constructor: Function): AsymmetricMatcher
+  arrayContaining(sample: readonly unknown[]): AsymmetricMatcher
+  objectContaining(sample: object): AsymmetricMatcher
+  stringContaining(sample: string): AsymmetricMatcher
+  stringMatching(sample: string | RegExp): AsymmetricMatcher
+  closeTo(sample: number, digits?: number): AsymmetricMatcher
+}
+
+export type AnyFunction = (...args: any[]) => any
+
+export interface MockResult {
+  type: 'return' | 'throw' | 'incomplete'
+  value: unknown
+}
+
+export interface MockState<T extends AnyFunction> {
+  calls: Parameters<T>[]
+  contexts: unknown[]
+  instances: unknown[]
+  invocationCallOrder: number[]
+  results: MockResult[]
+  lastCall?: Parameters<T>
+}
+
+export interface MockFunction<T extends AnyFunction = AnyFunction> {
+  (...args: Parameters<T>): ReturnType<T>
+  readonly isMockFunction: true
+  readonly calls: Readonly<MockState<T>>
+  clear(): this
+  reset(): this
+  restore(): void
+  implement(implementation: T): this
+  implementOnce(implementation: T): this
+  return(value: ReturnType<T>): this
+  returnOnce(value: ReturnType<T>): this
+  resolve(value: Awaited<ReturnType<T>>): this
+  resolveOnce(value: Awaited<ReturnType<T>>): this
+  reject(reason: unknown): this
+  rejectOnce(reason: unknown): this
+  named(name: string): this
+  readonly name: string
+}
+
+export interface ReplacedProperty<T> {
+  replace(value: T): void
+  restore(): void
+}
+
+export interface MockApi {
+  fn<T extends AnyFunction = AnyFunction>(implementation?: T): MockFunction<T>
+  spyOn<T extends object, K extends keyof T>(
+    object: T,
+    key: K,
+    accessType?: 'get' | 'set',
+  ): T[K] extends AnyFunction ? MockFunction<T[K]> : MockFunction
+  replaceProperty<T extends object, K extends keyof T>(object: T, key: K, value: T[K]): ReplacedProperty<T[K]>
+  module<T = unknown>(specifier: string, factory: () => Awaitable<T>): void
+  import<T = unknown>(specifier: string): Promise<T>
+  actual<T = unknown>(specifier: string): Promise<T>
+  isolate<T>(callback: () => Awaitable<T>): Promise<T>
+  clearAll(): void
+  resetAll(): void
+  restoreAll(): void
+}
+
+export interface FakeClockOptions {
+  now?: number | Date
+  timerLimit?: number
+  exclude?: readonly ('date' | 'performance' | 'timeout' | 'interval' | 'immediate' | 'microtask' | 'animationFrame' | 'idleCallback')[]
+}
+
+export interface ClockApi {
+  fake(options?: FakeClockOptions): Promise<ClockApi>
+  restore(): Promise<ClockApi>
+  advanceBy(milliseconds: number): Promise<void>
+  advanceTo(timestamp: number | Date): Promise<void>
+  runNext(): Promise<boolean>
+  runAll(): Promise<void>
+  flushMicrotasks(): Promise<void>
+}
+
+export interface NetworkRequest {
+  readonly id: string
+  readonly url: URL
+  readonly method: string
+  readonly headers: Headers
+  readonly body: Uint8Array | null
+}
+
+export interface NetworkResponse {
+  status?: number
+  statusText?: string
+  headers?: HeadersInit
+  body?: BodyInit | object | null
+  delayMs?: number
+}
+
+export type NetworkMatcher =
+  | string
+  | URL
+  | RegExp
+  | {
+      method?: string
+      url?: string | URL | RegExp
+    }
+  | ((request: NetworkRequest) => boolean)
+
+export type NetworkHandler = (
+  request: NetworkRequest,
+) => Awaitable<NetworkResponse | Response>
+
+export interface NetworkDisposer {
+  (): void
+}
+
+export interface NetworkApi {
+  route(matcher: NetworkMatcher, handler: NetworkHandler): NetworkDisposer
+  allow(matcher: NetworkMatcher): NetworkDisposer
+  requests(): readonly NetworkRequest[]
+  reset(): void
+}
+
+export const test: TestApi
+export const it: TestApi
+export const describe: DescribeApi
+export const beforeAll: (callback: TestCallback, options?: TestCaseOptions) => void
+export const beforeEach: (callback: TestCallback, options?: TestCaseOptions) => void
+export const afterAll: (callback: TestCallback, options?: TestCaseOptions) => void
+export const afterEach: (callback: TestCallback, options?: TestCaseOptions) => void
+export const expect: Expect
+export const mock: MockApi
+export const clock: ClockApi
+export const network: NetworkApi

package/test.mjs

@@ -0,0 +1,15 @@
+import api from './test.cjs'
+
+export const {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  clock,
+  describe,
+  expect,
+  it,
+  mock,
+  network,
+  test,
+} = api