Woby Chk

https://github.com/wobyjs/chk
Admin
Woby Chk is a powerful and flexible testing toolkit for TypeScript projects, offering a...
Tokens:32,405
Snippets:199
Trust Score:3.2
Update:11 months ago
Show doc for...
Tokens:
Raw
### Install @woby/chk with npm

Source: https://github.com/wobyjs/chk/blob/main/README.md

Installs the @woby/chk package as a development dependency in your project using npm.

```bash
npm install @woby/chk --save-dev
```

--------------------------------

### Component Story Example in HTML

Source: https://github.com/wobyjs/chk/blob/main/README.md

Demonstrates how to create HTML files for component story testing with WobyJS Chk. These files showcase components in various states and are combined by the testPlugin.

```html
<!DOCTYPE html>
<html>
<head>
    <title>Component Stories</title>
</head>
<body>
    <h1>MyComponent Stories</h1>
    
    <h2>Default State</h2>
    <woby-chk>
        <my-component message="Hello World" count={1} timestamp={new Date()}></my-component>
    </woby-chk>
    
    <h2>With Custom Message</h2>
    <woby-chk>
        <my-component message="Custom Message" count={10} timestamp={new Date()}></my-component>
    </woby-chk>
</body>
</html>
```

--------------------------------

### Test Numeric Comparisons (JavaScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This example showcases various numeric comparison assertions like `toBeGreaterThan`, `toBeLessThan`, `toBeGreaterThanOrEqual`, and `toBeLessThanOrEqual`. It also includes tests using string operators for comparisons and `expect.anything`.

```javascript
test('numeric comparisons', () => {
    expect(10).toBeGreaterThan(5)
    expect(10).not.toBeGreaterThan(15)
    expect(10).toBeGreaterThanOrEqual(10)
    expect(10).not.toBeGreaterThanOrEqual(11)
    expect(5).toBeLessThan(10)
    expect(15).not.toBeLessThan(10)
    expect(10).toBeLessThanOrEqual(10)
    expect(10).not.toBeLessThanOrEqual(9)
    expect(10)['>'](5)
    expect(10)['>='](10)
    expect(5)['<'](10)
    expect(10)['<='](10)

    expect(10)['>'](expect.anything)
    expect(10)['>='](expect.anything)
    expect(5)['<'](expect.anything)
    expect(10)['<='](expect.anything)
})
```

--------------------------------

### Custom Element Test Example in HTML

Source: https://github.com/wobyjs/chk/blob/main/README.md

Shows how to test custom elements directly using HTML files with WobyJS Chk. The testPlugin serves these files, and snapshotPlugin can capture rendered component states.

```html
<!DOCTYPE html>
<html>
<head>
    <title>Custom Element Test</title>
</head>
<body>
    <h1>AnotherComponent Test</h1>
    <woby-chk>
        <another-component></another-component>
    </woby-chk>
    
    <h1>MyComponent2 Test</h1>
    <woby-chk>
        <my-component2 message="Hello Custom Element"></my-component2>
    </woby-chk>
</body>
</html>
```

--------------------------------

### Basic Test with @woby/chk in TypeScript

Source: https://github.com/wobyjs/chk/blob/main/README.md

A fundamental example of writing a test using the @woby/chk testing framework in TypeScript. It demonstrates importing testing utilities and making a simple assertion.

```typescript
// src/example.test.ts
import { expect, test } from '@woby/chk';

function sum(a: number, b: number) {
  return a + b;
}

test('should sum two numbers', () => {
  expect(sum(1, 2)).toBe(3);
});
```

--------------------------------

### Test Function Return Value (JavaScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This example shows how to test if a function returns a specific value using `toHaveReturnedWith`. It defines a simple function and an object, then asserts the function's output.

```javascript
test('drink returns La Croix', () => {
    const beverage = { name: 'La Croix', toString }
    const drink = fn((beverage: { name: string }) => beverage.name)

    drink(beverage)

    expect(drink).toHaveReturnedWith('La Croix')
})
```

--------------------------------

### Test Object Property Existence and Value (JavaScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This example illustrates the `toHaveProperty` assertion for checking if an object has a specific property, optionally verifying its value. It also shows how to assert the absence of a property or a specific value for a property.

```javascript
test('toHaveProperty', () => {
    const obj = { a: 1, b: 'hello', toString }
    expect(obj).toHaveProperty('a')
    expect(obj).toHaveProperty('b', 'hello')
    expect(obj).not.toHaveProperty('c')
    expect(obj).not.toHaveProperty('a', 2)
})
```

--------------------------------

### Assert Custom Predicate with `toSatisfy`

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

Shows how to use the `toSatisfy` matcher to check if a value satisfies a custom predicate function. This example verifies if a number is odd.

```typescript
const isOdd = (value: number) => value % 2 !== 0
    expect(1).toSatisfy(isOdd)
```

--------------------------------

### Using .toBe() for Strict Equality

Source: https://github.com/wobyjs/chk/blob/main/docs/expect.md

Demonstrates the use of the .toBe() matcher for strict equality (===) comparisons. It's effective for primitive types and exact object references. This example showcases basic assertions, checking for expected values, and handling undefined properties.

```typescript
test('Sample 1', {}, ({ }) => {
    expect(1 + 1)["==="](2)
    expect(1 + 10)["==="](expect.anything)
})

test('Sample 2', {}, ({ }) => {
    const a = { b: 1 }
    expect(a.b)["==="](1)
    expect((a as any).c)["==="](expect.anything)
})

test('Sample 3 fail', {}, ({ }) => {
    const a = { b: 1 }
    expect(a.b)["==="](2) //fail case
})
```

--------------------------------

### Creating Mock Objects from Modules with TypeScript

Source: https://github.com/wobyjs/chk/blob/main/docs/mock.md

Explains the `createMockFromModule()` function, which generates a mock object by automatically mocking all exports of a given module. This provides a convenient starting point for custom mock configurations.

```typescript
const example = createMockFromModule(exampleModule)

test('createMockFromModule should run example code', (/* { expect } */) => {
    // creates a new mocked function with no formal arguments.
    expect(example.function.name).toBe('square')
    expect(example.function).toHaveLength(0)

    // async functions get the same treatment as standard synchronous functions.
    expect(example.asyncFunction.name).toBe('asyncSquare')
    expect(example.asyncFunction).toHaveLength(0)

    // creates a new class with the same interface, member functions and properties are mocked.
    expect(example.class.constructor.name).toBe('Bar')
    expect(example.class.foo.name).toBe('foo')
    expect(example.class.array).toHaveLength(0)

    // creates a deeply cloned version of the original object.
    expect(example.object).toEqual({
        baz: 'foo',
        bar: {
            fiz: 1,
            buzz: [],
        },
    })

    // creates a new empty array, ignoring the original array.
    expect(example.array).toHaveLength(0)

    // creates a new property with the same primitive value as the original property.
    expect(example.number).toBe(123)
    expect(example.string).toBe('baz')
    expect(example.boolean).toBe(true)
    expect(example.symbol).toEqual(Symbol.for('a.b.c'))
})
```

--------------------------------

### Test Membership in a List of Values (JavaScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This example illustrates the `toBeOneOf` assertion for checking if a value exists within a provided array of possible values. It simplifies checking against multiple options.

```javascript
test('toBeOneOf', () => {
    expect('apple').toBeOneOf(['apple', 'banana', 'orange'])
    expect('grape').not.toBeOneOf(['apple', 'banana', 'orange'])
})
```

--------------------------------

### Test Truthy Values (JavaScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This example illustrates the `toBeTruthy` assertion, which checks if a value is considered truthy in JavaScript (any value that is not falsy). It also includes examples of asserting that a value is not truthy.

```javascript
test('toBeTruthy', () => {
    expect(true).toBeTruthy()
    expect(1).toBeTruthy()
    expect('hello').toBeTruthy()
    expect({}).toBeTruthy()
    expect([]).toBeTruthy()
    expect(false).not.toBeTruthy()
})
```

--------------------------------

### Write Native TSX/TS Tests with @woby/chk

Source: https://github.com/wobyjs/chk/blob/main/README.md

Example of a native TypeScript/TSX test file using the @woby/chk testing framework. It demonstrates importing `expect` and `test` and creating a basic test case for a React component.

```tsx
import { expect, test } from '@woby/chk'
import { MyComponent } from './MyComponent'

test('MyComponent should render with correct message', async () => {
  const component = <MyComponent message="Hello World" count={5} timestamp={new Date()} />
  // Add your assertions here
  expect(component).toBeDefined()
})
```

--------------------------------

### Test Floating-Point Number Proximity (JavaScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This snippet demonstrates the `toBeCloseTo` assertion for comparing floating-point numbers within a certain precision. It includes examples of successful comparisons, expected failures, and using `expect.anything`.

```javascript
test('toBeCloseTo', () => {
    expect(0.1 + 0.2).toBeCloseTo(0.3, 5)
    expect(0.1 + 0.2).not.toBeCloseTo(0.3, 10) //fail case
    expect(0.1 + 0.2).toBeCloseTo(expect.anything)
})
```

--------------------------------

### Spy on Property Getters (TypeScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/spyOn.md

This example demonstrates how to spy on a getter property of an object in TypeScript using `spyOn`. It verifies that the getter was called and that the accessed property returned its expected value. The `'get'` argument specifies that a getter should be spied on.

```typescript
test('plays video', () => {

    const video = {
        // it's a getter!
        get play() {
            return true
        },
    }
    const spy = spyOn(video, 'play', 'get') // we pass 'get'
    const isPlaying = video.play

    expect(spy).toHaveBeenCalled()
    expect(isPlaying).toBe(true)
})
```

--------------------------------

### Configure Vite for @woby/chk Testing

Source: https://github.com/wobyjs/chk/blob/main/README.md

Configures Vite to use @woby/chk testing utilities, including snapshot and test plugins. This setup is necessary for leveraging the toolkit's testing capabilities within a Vite-based project.

```typescript
// vite.config.mts
import { defineConfig } from 'vite'
import { snapshotPlugin } from 'vite-plugin-snapshot'
import { testPlugin } from '@woby/vite-plugin-test'

export default defineConfig({
  plugins: [
    snapshotPlugin(),
    testPlugin()
  ]
  /// other settings
})
```

--------------------------------

### Spying on Object Getters with spyOn

Source: https://github.com/wobyjs/chk/blob/main/docs/expect.md

Demonstrates how to use `spyOn` to track calls to a getter property on an object. This is useful for verifying that a getter has been accessed as expected during testing. It requires the object property and the type of access ('get' or 'set').

```javascript
const video = {
    // it's a getter!
    get play() {
        return true
    },
}
const spy = spyOn(video, 'play', 'get') // we pass 'get'
const isPlaying = video.play

expect(spy).toHaveBeenCalled()
expect(isPlaying).toBe(true)
```

--------------------------------

### Test Array and String Content Inclusion (JavaScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This example showcases the `toContain` assertion for checking if an array contains a specific element or if a string contains a substring. It also demonstrates `not.toContain` and using `anything`.

```javascript
test('toContain', () => {
    expect([1, 2, 3]).toContain(2)
    expect([1, 2, 3]).not.toContain(4)
    expect('hello world').toContain('world')
    expect('hello world').not.toContain('foo')

    expect('hello world').toContain(anything)
    expect([1, 2, 3]).not.toContain(anything)
})
```

--------------------------------

### Test for Undefined Values (JavaScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This example illustrates the `toBeUndefined` assertion for checking if a value is strictly `undefined`. It also includes tests for asserting that a value is not undefined.

```javascript
test('toBeUndefined', () => {
    let x
    expect(x).toBeUndefined()
    expect(null).not.toBeUndefined()
    expect(0).not.toBeUndefined()
})
```

--------------------------------

### Test Value Definition (JavaScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This example shows the `toBeDefined` assertion for checking if a variable or property has a defined value, and its negation `not.toBeDefined` for checking `undefined` values.

```javascript
test('toBeDefined', () => {
    const x = 1
    const y: any = undefined
    expect(x).toBeDefined()
    expect(y).not.toBeDefined()
})
```

--------------------------------

### Test Object Subset Matching (JavaScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This example illustrates the `toMatchObject` assertion for checking if an object contains a subset of properties matching the expected values. It can recursively match nested objects.

```javascript
test('toMatchObject', () => {
    const obj = { a: 1, b: { c: 2, d: 3, toString }, toString }
    expect(obj).toMatchObject({ a: 1, toString })
    expect(obj).toMatchObject({ b: { c: 2, toString }, toString })
    expect(obj).not.toMatchObject({ a: 2, toString })
    expect(obj).not.toMatchObject({ b: { e: 4, toString }, toString })
})
```

--------------------------------

### Mock Function `fn` with `mockName`, `mockReturnThis`, and `mockReturnValue`

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

Covers various configuration options for mock functions (`fn`). It demonstrates setting a mock name, returning the mock instance itself using `mockReturnThis`, and setting a specific return value with `mockReturnValue`, including updating it.

```typescript
const mockFn = fn().mockName('mockedFunction')
expect(mockFn).toHaveBeenCalled()

const obj = {}
const mockReturnThisFn = fn().mockReturnThis()
expect(mockReturnThisFn()).toBe(mockReturnThisFn)

const mockReturnValueFn = fn().mockReturnValue(42)
expect(mockReturnValueFn()).toBe(42)
mockReturnValueFn.mockReturnValue(43)
expect(mockReturnValueFn()).toBe(43)
```

--------------------------------

### Mock Function `fn` with `mock.instances`

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

Shows how to use a mock function (`fn`) to track instances of classes created from it. It verifies that the correct instances `a` and `b` are recorded in `mockFn.mock.instances`.

```typescript
const mockFn = fn()
const a = new (mockFn as any)()
const b = new (mockFn as any)()
expect(mockFn.mock.instances[0]).toBe(a)
expect(mockFn.mock.instances[1]).toBe(b)
```

--------------------------------

### Test Deep Equality of Values (JavaScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This example demonstrates the `toEqual` assertion for checking if two values are deeply equal. It works for primitive types, arrays, and objects.

```javascript
test('toEqual', () => {
    expect({ a: 1, b: 2, toString }).toEqual({ a: 1, b: 2, toString })
    expect([1, 2, 3]).toEqual([1, 2, 3])
    expect({ a: 1, b: 2 }).not.toEqual({ a: 1, b: 3 })
})
```

--------------------------------

### Mock Function `fn` with `mockImplementationOnce`

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

Illustrates sequential custom return values for a mock function using `mockImplementationOnce`. It shows how the mock behaves on consecutive calls, falling back to a default implementation after all `mockImplementationOnce` calls are exhausted.

```typescript
const mockFn = fn(() => 'default')
    .mockImplementationOnce(() => 'first call')
    .mockImplementationOnce(() => 'second call')

expect(mockFn()).toBe('first call')
expect(mockFn()).toBe('second call')
expect(mockFn()).toBe('default')
expect(mockFn()).toBe('default')
```

--------------------------------

### Assert Negated Custom Predicate with `not.toSatisfy`

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

Demonstrates using `not.toSatisfy` to assert that a value does not satisfy a given predicate function. This example checks if a number is not odd (i.e., even).

```typescript
const isOdd = (value: number) => value % 2 !== 0
    expect(2).not.toSatisfy(isOdd)
```

--------------------------------

### Mock Module with Custom Implementation

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

Demonstrates how to use the `mock` function to replace a module with a custom implementation, allowing for specific return values or functions for the mocked module and its exports.

```typescript
const mod = mock('../moduleName', () => {
        return fn(() => 42)
    })

    const moduleName = req('../moduleName') as () => number
    expect(moduleName()).toBe(42)
    expect(mod.default).toBeUndefined()

    const { default: moduleName2, foo } = mock('../moduleName', () => {
        return {
            __esModule: true,
            default: fn(() => 42),
            foo: fn(() => 43),
        }
    })

    expect(moduleName2())['==='](42)
    expect(foo())['==='](43)
```

--------------------------------

### Create and Test Mock Functions with `fn()` in TypeScript

Source: https://github.com/wobyjs/chk/blob/main/docs/fn.md

Demonstrates the creation of mock functions using `fn()` and various assertion methods to test function calls and return values in TypeScript. This includes checking if a function was called, the arguments it received, and its return values.

```typescript
function drinkAll<T>(callback: (a: T) => void, flavour: T) {
    if (flavour !== 'octopus') {
        callback(flavour)
    }
}

test('drinkAll', () => {
    test('drinks something lemon-flavoured', ({ }) => {
        const drink = fn()
        drinkAll(drink, 'lemon')
        expect(drink).toHaveBeenCalled()
    })

    test('does not drink something octopus-flavoured', ({ }) => {
        const drink = fn()
        drinkAll(drink, 'octopus')
        expect(drink).not.toHaveBeenCalled()
    })
})

test('drinkEach drinks each drink', () => {
    const drink = fn()
    drink('lemon')
    drink('octopus')
    expect(drink).toHaveBeenCalledTimes(2)
    expect(drink).toHaveBeenCalledTimes(expect.anything)
})

test('toHaveBeenCalledWith', () => {
    const drink = fn()
    drink('lemon', 'juice')
    expect(drink).toHaveBeenCalledWith('lemon', 'juice')
    expect(drink).not.toHaveBeenCalledWith('orange')

    expect(drink).toHaveBeenCalledWith(expect.anything)
    expect(drink).not.toHaveBeenCalledWith(expect.anything)
})

test('toHaveBeenCalledLastCalledWith', () => {
    const drink = fn()
    drink('lemon')
    drink('orange')
    expect(drink).toHaveBeenCalledLastCalledWith('orange')
    expect(drink).not.toHaveBeenCalledLastCalledWith('lemon')

    expect(drink).toHaveBeenCalledLastCalledWith(expect.anything)
    expect(drink).not.toHaveBeenCalledLastCalledWith(expect.anything)
})

test('toHaveBeenCalledNthCalledWith', () => {
    const drink = fn()
    drink('lemon')
    drink('orange')
    drink('apple')
    expect(drink).toHaveBeenCalledNthCalledWith(1, 'lemon')
    expect(drink).toHaveBeenCalledNthCalledWith(2, 'orange')
    expect(drink).not.toHaveBeenCalledNthCalledWith(3, 'lemon')
    expect(drink).not.toHaveBeenCalledNthCalledWith(3, expect.anything)
})

test('toHaveReturnedTimes', () => {
    const func = fn()
    func()
    func()
    expect(func).toHaveReturnedTimes(2)
    expect(func).not.toHaveReturnedTimes(1)
    expect(func).toHaveReturnedTimes(expect.anything)
    expect(func).not.toHaveReturnedTimes(expect.anything)
})

test('toHaveReturnedWith', () => {
    const func = fn(() => 'lemon')
    func()
    expect(func).toHaveReturnedWith('lemon')
    expect(func).not.toHaveReturnedWith('orange')
    expect(func).toHaveReturnedWith(expect.anything)
    expect(func).not.toHaveReturnedWith(expect.anything)
})

test('toHaveLastReturnedWith', () => {
    let callCount = 0
    const func = fn(() => {
        callCount++
        if (callCount === 1) return 'lemon'
        if (callCount === 2) return 'orange'
    })

    func()
    func()
    expect(func).toHaveLastReturnedWith('orange')
    expect(func).not.toHaveLastReturnedWith('lemon')
    expect(func).toHaveLastReturnedWith(expect.anything)
    expect(func).not.toHaveLastReturnedWith(expect.anything)
})

test('toHaveNthReturnedWith', () => {
    let callCount = 0
    const func = fn(() => {
        callCount++
        if (callCount === 1) return 'lemon'
        if (callCount === 2) return 'orange'
        if (callCount === 3) return 'apple'
    })

    func()
    func()
    func()
    expect(func).toHaveNthReturnedWith(1, 'lemon')
    expect(func).toHaveNthReturnedWith(2, 'orange')
    expect(func).toHaveNthReturnedWith(3, 'apple')
    expect(func).not.toHaveNthReturnedWith(3, expect.anything)
})

test('drink returns La Croix', () => {
    const beverage = { name: 'La Croix', toString }
    const drink = fn((beverage: { name: string }) => beverage.name)

    drink(beverage)

    expect(drink).toHaveReturnedWith('La Croix')
})

test('map calls its argument with a non-null argument', () => {
    const mock = fn();
    [1].map(x => mock(x))
    expect(mock).toHaveBeenCalledWith(expect.anything)
})

class Cat { }

function getCat(fn: <T>(t: T) => T) {
    return fn(new Cat())
}

test('randocall calls its callback with a class instance', () => {
    const mock = fn()
    getCat(mock)
    expect(mock).toHaveBeenCalledWith(expect.any(Cat))
})

function randocall(fn: <T>(t: T) => T) {
    return fn(Math.floor(Math.random() * 6 + 1))
}

test('randocall calls its callback with a number', () => {
    const mock = fn()
    randocall(mock)
    expect(mock).toHaveBeenCalledWith(expect.any(Number))
})
```

--------------------------------

### Replacing Modules with Custom Mocks using JavaScript

Source: https://github.com/wobyjs/chk/blob/main/docs/mock.md

Demonstrates the `mock()` function for replacing a module with a user-defined mock implementation. This grants full control over the module's exports and their behavior, shown with both default and named exports.

```javascript
test('mock module', () => {

    const mod = mock('../moduleName', () => {
        return fn(() => 42)
    })

    const moduleName = req('../moduleName') as () => number
    expect(moduleName()).toBe(42)
    expect(mod.default).toBeUndefined()

    const { default: moduleName2, foo } = mock('../moduleName', () => {
        return {
            __esModule: true,
            default: fn(() => 42),
            foo: fn(() => 43),
        }
    })

    expect(moduleName2())['==='](42)
    expect(foo())['==='](43)
})
```

--------------------------------

### Test Mocking Function Calls and Return Values (JavaScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This snippet demonstrates testing a function that is called multiple times and verifies its return values for each call using `toHaveNthReturnedWith`. It also includes a check for unexpected return values.

```javascript
test('func returns values', () => {
    let callCount = 0
    const func = fn(() => {
        if (callCount === 0) {
            callCount++
            return 'lemon'
        }
        if (callCount === 1) {
            callCount++
            return 'orange'
        }
        if (callCount === 2) {
            callCount++
            return 'apple'
        }
    })

    func()
    func()
    func()
    expect(func).toHaveNthReturnedWith(1, 'lemon')
    expect(func).toHaveNthReturnedWith(2, 'orange')
    expect(func).toHaveNthReturnedWith(3, 'apple')
    expect(func).not.toHaveNthReturnedWith(3, expect.anything)
})
```

--------------------------------

### Auto-Mock Modules with `createMockFromModule()`

Source: https://context7.com/wobyjs/chk/llms.txt

The `createMockFromModule()` utility automatically generates mock objects for all exports of a given module. It handles functions, classes, objects, arrays, and primitives, providing a convenient way to mock entire modules for testing purposes. Mocked functions and class methods will have no formal arguments and will be empty implementations.

```typescript
import { expect, test, createMockFromModule } from '@woby/chk'

const exampleModule = {
    function: function square(a: number) { return a * a },
    asyncFunction: async function asyncSquare(a: number) { return a * a },
    class: class Bar {
        foo() { return 'bar' }
        array = [1, 2, 3]
    },
    object: {
        baz: 'foo',
        bar: {
            fiz: 1,
            buzz: [],
        },
    },
    array: [1, 2, 3],
    number: 123,
    string: 'baz',
    boolean: true,
    symbol: Symbol.for('a.b.c')
}

const example = createMockFromModule(exampleModule)

test('createMockFromModule auto-mocking', () => {
    // Mocked functions with no formal arguments
    expect(example.function.name).toBe('square')
    expect(example.function).toHaveLength(0)

    // Async functions mocked
    expect(example.asyncFunction.name).toBe('asyncSquare')
    expect(example.asyncFunction).toHaveLength(0)

    // Classes mocked with same interface
    expect(example.class.constructor.name).toBe('Bar')
    expect(example.class.foo.name).toBe('foo')
    expect(example.class.array).toHaveLength(0)

    // Objects deeply cloned
    expect(example.object).toEqual({
        baz: 'foo',
        bar: {
            fiz: 1,
            buzz: [],
        },
    })

    // Primitives preserved
    expect(example.number).toBe(123)
    expect(example.string).toBe('baz')
    expect(example.boolean).toBe(true)
    expect(example.symbol).toEqual(Symbol.for('a.b.c'))
})
```

--------------------------------

### Mocking Object Structure with .toBe()

Source: https://github.com/wobyjs/chk/blob/main/docs/expect.md

Shows how `createMockFromModule` can be used to mock functions, classes, and properties from a module. The `.toBe()` matcher is used to verify the names, lengths, and primitive values of the mocked components.

```typescript
test('createMockFromModule should run example code', (/* { expect } */) => {
    // creates a new mocked function with no formal arguments.
    expect(example.function.name).toBe('square')
    expect(example.function).toHaveLength(0)

    // async functions get the same treatment as standard synchronous functions.
    expect(example.asyncFunction.name).toBe('asyncSquare')
    expect(example.asyncFunction).toHaveLength(0)

    // creates a new class with the same interface, member functions and properties are mocked.
    expect(example.class.constructor.name).toBe('Bar')
    expect(example.class.foo.name).toBe('foo')
    expect(example.class.array).toHaveLength(0)

    // creates a new property with the same primitive value as the original property.
    expect(example.number).toBe(123)
    expect(example.string).toBe('baz')
    expect(example.boolean).toBe(true)
})
```

--------------------------------

### Mock Function `fn` with `mockReturnValueOnce`

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

Shows how to define a sequence of return values for a mock function (`fn`) using `mockReturnValueOnce`. It verifies that the mock returns values in the specified order for each call, then reverts to a default return value.

```typescript
const mockFn = fn()
    .mockReturnValue('default')
    .mockReturnValueOnce('first call')
    .mockReturnValueOnce('second call')

expect(mockFn()).toBe('first call')
expect(mockFn()).toBe('second call')
expect(mockFn()).toBe('default')
expect(mockFn()).toBe('default')
```

--------------------------------

### Spy on Function Resolution with `fn` and `toHaveLastResolvedWith`

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

Demonstrates how to use the `fn` utility to create a mock function that returns a promise. It then shows how to assert the last resolved value of this mock function using `toHaveLastResolvedWith`.

```typescript
const sell = fn((product: string) => Promise.resolve({ product }))

    await sell('apples')
    await sell('bananas')

    expect(sell).toHaveLastResolvedWith({ product: 'bananas' })
```

--------------------------------

### fn() - Create and Use Mock Functions

Source: https://context7.com/wobyjs/chk/llms.txt

The fn() function generates mock functions that track their usage, including the number of calls, arguments passed, and return values. This is crucial for isolating units of code and verifying interactions between different parts of an application during testing. Mock functions can also be configured with custom return values.

```typescript
import { expect, test, fn } from '@woby/chk'

function drinkAll<T>(callback: (a: T) => void, flavour: T) {
    if (flavour !== 'octopus') {
        callback(flavour)
    }
}

test('fn basic mocking', () => {
    const drink = fn()
    drink('lemon', 'juice')

    expect(drink).toHaveBeenCalled()
    expect(drink).toHaveBeenCalledTimes(1)
    expect(drink).toHaveBeenCalledWith('lemon', 'juice')
    expect(drink).not.toHaveBeenCalledWith('orange')
})

test('fn with implementation', () => {
    const beverage = { name: 'La Croix' }
    const drink = fn((beverage: { name: string }) => beverage.name)

    drink(beverage)

    expect(drink).toHaveReturnedWith('La Croix')
})

test('fn tracking calls', () => {
    const drink = fn()
    drink('lemon')
    drink('orange')
    drink('apple')

    expect(drink).toHaveBeenCalledNthCalledWith(1, 'lemon')
    expect(drink).toHaveBeenCalledNthCalledWith(2, 'orange')
    expect(drink).toHaveBeenCalledLastCalledWith('apple')
})
```

--------------------------------

### Using expect.any(Constructor) Matcher in TypeScript

Source: https://github.com/wobyjs/chk/blob/main/docs/expect.md

The expect.any(Constructor) matcher verifies if a value is an instance of a specific constructor, such as Number, String, or Array. This is valuable for type checking without needing to know the exact value. The examples show checking for class instances and primitive types.

```typescript
class Cat { }

function getCat(fn: <T>(t: T) => T) {
    return fn(new Cat())
}

test('randocall calls its callback with a class instance', () => {
    const mock = fn()
    getCat(mock)
    expect(mock).toHaveBeenCalledWith(expect.any(Cat))
})

function randocall(fn: <T>(t: T) => T) {
    return fn(Math.floor(Math.random() * 6 + 1))
}

test('randocall calls its callback with a number', () => {
    const mock = fn()
    randocall(mock)
    expect(mock).toHaveBeenCalledWith(expect.any(Number))
})
```

--------------------------------

### Mock Module with `createMockFromModule`

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

Explains how to use `createMockFromModule` to generate mocks for various types including functions, classes, objects, and primitives, ensuring their interfaces and properties are mocked or cloned.

```typescript
const example = createMockFromModule(exampleModule)

    // creates a new mocked function with no formal arguments.
    expect(example.function.name).toBe('square')
    expect(example.function).toHaveLength(0)

    // async functions get the same treatment as standard synchronous functions.
    expect(example.asyncFunction.name).toBe('asyncSquare')
    expect(example.asyncFunction).toHaveLength(0)

    // creates a new class with the same interface, member functions and properties are mocked.
    expect(example.class.constructor.name).toBe('Bar')
    expect(example.class.foo.name).toBe('foo')
    expect(example.class.array).toHaveLength(0)

    // creates a deeply cloned version of the original object.
    expect(example.object).toEqual({
        baz: 'foo',
        bar: {
            fiz: 1,
            buzz: [],
        },
    })

    // creates a new empty array, ignoring the original array.
    expect(example.array).toHaveLength(0)

    // creates a new property with the same primitive value as the original property.
    expect(example.number).toBe(123)
    expect(example.string).toBe('baz')
    expect(example.boolean).toBe(true)
    expect(example.symbol).toEqual(Symbol.for('a.b.c'))
```

--------------------------------

### Assert Nth Call Arguments of Mock Function (.toHaveBeenCalledNthCalledWith)

Source: https://github.com/wobyjs/chk/blob/main/docs/expect.md

The `.toHaveBeenCalledNthCalledWith()` matcher verifies that the Nth call to a mock function was made with specified arguments. This provides precise control over verifying arguments for each call in a sequence. It requires the call index (starting from 1) and the arguments to match.

```typescript
test('toHaveBeenCalledNthCalledWith', () => {
    const drink = fn()
    drink('lemon')
    drink('orange')
    drink('apple')
    expect(drink).toHaveBeenCalledNthCalledWith(1, 'lemon')
    expect(drink).toHaveBeenCalledNthCalledWith(2, 'orange')
    expect(drink).not.toHaveBeenCalledNthCalledWith(3, 'lemon')
    expect(drink).not.toHaveBeenCalledNthCalledWith(3, expect.anything)
})
```

--------------------------------

### Inspect Mock Calls and Instances with `.mock` Properties

Source: https://context7.com/wobyjs/chk/llms.txt

The `.mock` property of a mock function provides access to detailed call information. `.mock.calls` returns an array of all arguments passed to each call, `.mock.instances` tracks instances created by the mock, and `.mock.lastCall` is a shortcut to the arguments of the most recent call. These are invaluable for verifying mock interactions.

```typescript
import { expect, test, fn } from '@woby/chk'

test('mockFn.mock.calls inspection', () => {
    const mockFn = fn()
    mockFn(1, 2)
    mockFn(3)

    expect(mockFn.mock.calls).toEqual([[1, 2], [3]])
})

test('mockFn.mock.instances constructor tracking', () => {
    const mockFn = fn()
    const a = new (mockFn as any)()
    const b = new (mockFn as any)()

    expect(mockFn.mock.instances[0]).toBe(a)
    expect(mockFn.mock.instances[1]).toBe(b)
})

test('mockFn.mock.lastCall shortcut', () => {
    const mockFn = fn()
    mockFn(1, 2)
    mockFn(3, 4)

    expect(mockFn.mock.lastCall).toEqual([3, 4])
})
```

--------------------------------

### fn().mockReturnValue() / .mockReturnValueOnce() - Configure Synchronous Return Values

Source: https://context7.com/wobyjs/chk/llms.txt

These methods configure the return values of mock functions. `mockReturnValue()` sets a persistent return value for all calls, while `mockReturnValueOnce()` sets a return value for a specific, subsequent call. This allows for precise control over mock function output in tests.

```typescript
import { expect, test, fn } from '@woby/chk'

test('mockReturnValue persistent returns', () => {
    const mockFn = fn().mockReturnValue(42)

    expect(mockFn()).toBe(42)
    expect(mockFn()).toBe(42)

    mockFn.mockReturnValue(100)
    expect(mockFn()).toBe(100)
})

test('mockReturnValueOnce sequential returns', () => {
    const mockFn = fn()
        .mockReturnValue('default')
        .mockReturnValueOnce('first call')
        .mockReturnValueOnce('second call')

    expect(mockFn()).toBe('first call')
    expect(mockFn()).toBe('second call')
    expect(mockFn()).toBe('default')
    expect(mockFn()).toBe('default')
})

test('mockReturnThis for chaining', () => {
    const mockReturnThisFn = fn().mockReturnThis()
    expect(mockReturnThisFn()).toBe(mockReturnThisFn)
})
```

--------------------------------

### Advanced Matchers: toBeCloseTo(), toSatisfy(), toThrow(), toBeInstanceOf()

Source: https://context7.com/wobyjs/chk/llms.txt

Provides specialized matchers for comparing floating-point numbers with precision, validating custom predicates, handling errors in asynchronous operations, and checking object types.

```typescript
import { expect, test } from '@woby/chk'

test('toBeCloseTo floating point comparison', () => {
    expect(0.1 + 0.2).toBeCloseTo(0.3, 5)
    expect(0.1 + 0.2).not.toBeCloseTo(0.3, 10)
})

test('toSatisfy custom predicate', () => {
    const isOdd = (value: number) => value % 2 !== 0

    expect(1).toSatisfy(isOdd)
    expect(2).not.toSatisfy(isOdd)
})

test('toThrow error handling', async ({ expect }) => {
    (await expect(Promise.reject(new Error('octopus'))).rejects).toThrow('octopus');
    (await expect(Promise.reject(new Error('octopus'))).rejects).not.toThrow('lemon');
})

test('toBeInstanceOf type checking', () => {
    class Foo { }

    expect(new Foo()).toBeInstanceOf(Foo)
    expect([]).toBeInstanceOf(Array)
    expect({}).not.toBeInstanceOf(Array)
})
```

--------------------------------

### Mock Function `fn` with `withImplementation` for Sync and Async Callbacks

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

Illustrates temporary custom implementations for a mock function (`fn`) using `withImplementation`. It shows how to define inline synchronous and asynchronous callback functions that modify the mock's behavior only during the provided callback's execution.

```typescript
const mock = fn(() => 'outside callback')

mock.withImplementation(
    () => 'inside callback',
    () => {
        expect(mock()).toBe('inside callback')
    },
)

expect(mock()).toBe('outside callback')

// Async callback
await mock.withImplementation(
    () => 'inside async callback',
    async () => {
        expect(mock()).toBe('inside async callback')
    },
)

expect(mock()).toBe('outside callback')
```

--------------------------------

### Test Array and String Length (JavaScript)

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This snippet demonstrates the `toHaveLength` assertion, which can be used to check the length of arrays and strings. It also shows how to assert that a length is not a specific value or is anything.

```javascript
test('toHaveLength', () => {
    expect([1, 2, 3]).toHaveLength(3)
    expect('abc').toHaveLength(3)
    expect([]).not.toHaveLength(1)
    expect('abc').toHaveLength(expect.anything)
})
```

--------------------------------

### Define Basic Assertions with test() - TypeScript

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

This snippet demonstrates defining basic test cases using the `test()` function. It includes various assertion methods like `===`, `expect.anything`, and `not` for verifying expected outcomes. These tests are synchronous and check primitive values and object properties.

```typescript
test('Sample Test', ({ }) => {
    test('Sample 1', {}, ({ }) => {
        expect(1 + 1)("===")(2)
        expect(1 + 10)("===")(expect.anything)
    })

    test('Sample 2', {}, ({ }) => {
        const a = { b: 1 }
        expect(a.b)("===")(1)
        expect((a as any).c)("===")(expect.anything)
    })

    test('Sample 3 fail', {}, ({ }) => {
        const a = { b: 1 }
        expect(a.b)("===")(2) //fail case
    })

    test('Sample 4 not', {}, ({ }) => {
        expect(1).not.eq(2)
        expect(1).not.eq(1) // This should fail
        expect(1).not.eq(expect.anything)
    })

    test({ a: 1, b: 2, toString: () => '{ a: 1, b: 2,}' }, {}, ({ subject }) => {
        expect(subject.a)("===")(1)
        expect(subject.b)("===")(2)
    })
})
```

--------------------------------

### Async Testing with .resolves and .rejects Matchers

Source: https://context7.com/wobyjs/chk/llms.txt

The .resolves and .rejects matchers are used to test asynchronous code that returns Promises. They allow assertions on the resolved value of a Promise or the rejection reason. These matchers are essential for verifying the behavior of asynchronous operations within tests.

```typescript
import { expect, test, fn } from '@woby/chk'

test('Async operations', ({ expect }) => {
    test('resolves successful promises', async ({ }) => {
        (await expect(Promise.resolve('lemon')).resolves).toBe('lemon');
        (await expect(Promise.resolve('lemon')).resolves).not.toBe('octopus');
    })

    test('rejects failed promises', async ({ }) => {
        (await expect(Promise.reject(new Error('octopus'))).rejects).toThrow('octopus');
        (await expect(Promise.reject(new Error('octopus'))).rejects).not.toThrow('lemon');
    })
})

test('mockFn async methods', async ({ expect }) => {
    const asyncMock = fn()
        .mockResolvedValue('default')
        .mockResolvedValueOnce('first call')
        .mockResolvedValueOnce('second call');

    (await expect(asyncMock()).resolves).toBe('first call');
    (await expect(asyncMock()).resolves).toBe('second call');
    (await expect(asyncMock()).resolves).toBe('default');
})
```

--------------------------------

### Mock Function Properties with .toBe()

Source: https://github.com/wobyjs/chk/blob/main/docs/expect.md

Shows how to use `.toBe()` with mock function properties like `mockName`, `mockReturnThis`, and `mockReturnValue`. It verifies the name of a mocked function, the return value of `mockReturnThis`, and the specific return value set by `mockReturnValue`.

```typescript
test('mockFn.mockName, mockReturnThis, mockReturnValue', () => {
    const mockFn = fn().mockName('mockedFunction')
    expect(mockFn).toHaveBeenCalled()

    const obj = {}
    const mockReturnThisFn = fn().mockReturnThis()
    expect(mockReturnThisFn()).toBe(mockReturnThisFn)

    const mockReturnValueFn = fn().mockReturnValue(42)
    expect(mockReturnValueFn()).toBe(42)
    mockReturnValueFn.mockReturnValue(43)
    expect(mockReturnValueFn()).toBe(43)
})
```

--------------------------------

### Mock Function `fn` with `toHaveBeenCalledWith`

Source: https://github.com/wobyjs/chk/blob/main/docs/test.md

Illustrates how to use a mock function (`fn`) to track calls and verify arguments. The `map` method is used to invoke the mock function, and `toHaveBeenCalledWith` asserts that it was called with `expect.anything()`.

```typescript
const mock = fn();
[1].map(x => mock(x))
expect(mock).toHaveBeenCalledWith(expect.anything)
```

--------------------------------

### Concise Numeric Comparisons with Operators in TypeScript

Source: https://github.com/wobyjs/chk/blob/main/docs/expect.md

This snippet demonstrates using direct comparison operators (>, >=, <, <=) as matchers for a more concise way to perform numeric comparisons. It supports comparison with specific values and expect.anything.

```typescript
test('numeric comparisons', () => {
    expect(10)['>'](5)
    expect(10)['>='](10)
    expect(5)['<'](10)
    expect(10)['<='](10)

    expect(10)['>'](expect.anything)
    expect(10)['>='](expect.anything)
    expect(5)['<'](expect.anything)
    expect(10)['<='](expect.anything)
})
```

--------------------------------

### Flexible Assertions with expect.anything and expect.any() in @woby/chk

Source: https://context7.com/wobyjs/chk/llms.txt

WobyJS Chk provides `expect.anything()` for assertions that match any non-null/undefined value, and `expect.any(Constructor)` for type checking against built-in or custom constructors. These are useful when the exact value is not critical, but its presence or type is.

```typescript
import { expect, test, fn } from '@woby/chk'

test('expect.anything matches non-null/undefined', () => {
    expect(1 + 10["==="])(expect.anything)
    expect('hello')["==="](expect.anything)

    const a = { b: 1 }
    expect((a as any).c)["==="](expect.anything) // undefined fails
})

test('expect.any(Constructor) type checking', () => {
    class Cat { }

    function getCat(fn: <T>(t: T) => T) {
        return fn(new Cat())
    }

    const mock = fn()
    getCat(mock)
    expect(mock).toHaveBeenCalledWith(expect.any(Cat))
})

test('expect.any with built-in types', () => {
    function randocall(fn: <T>(t: T) => T) {
        return fn(Math.floor(Math.random() * 6 + 1))
    }

    const mock = fn()
    randocall(mock)
    expect(mock).toHaveBeenCalledWith(expect.any(Number))
})
```

--------------------------------

### Collection Matchers: toContain(), toHaveLength(), toHaveProperty()

Source: https://context7.com/wobyjs/chk/llms.txt

Tests for containment, length, and property existence within arrays, strings, and objects. It asserts specific conditions using predefined matchers.

```typescript
import { expect, test } from '@woby/chk'

const toString = function() { return JSON.stringify(this) }

test('toContain for arrays and strings', () => {
    expect([1, 2, 3]).toContain(2)
    expect([1, 2, 3]).not.toContain(4)
    expect('hello world').toContain('world')
    expect('hello world').not.toContain('foo')
})

test('toHaveLength for collections', () => {
    expect([1, 2, 3]).toHaveLength(3)
    expect('abc').toHaveLength(3)
    expect([]).not.toHaveLength(1)
})

test('toHaveProperty object inspection', () => {
    const obj = { a: 1, b: 'hello', toString }

    expect(obj).toHaveProperty('a')
    expect(obj).toHaveProperty('b', 'hello')
    expect(obj).not.toHaveProperty('c')
    expect(obj).not.toHaveProperty('a', 2)
})

test('toBeOneOf value in list', () => {
    expect('apple').toBeOneOf(['apple', 'banana', 'orange'])
    expect('grape').not.toBeOneOf(['apple', 'banana', 'orange'])
})
```
Tokens:
Raw