reactive/data-client / .agents/skills/data-client-react-testing
data-client-react-testing
VerifiedTest React code that uses @data-client/react: components and hooks that fetch or change data, with mocked responses for loading, error, mutation and polling cases. Covers renderDataHook, MockResolver and fixtures.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 7.0 KB |
| references.json | config | 502 B |
| references/Fixtures.md | markdown | 6.3 KB |
| references/MockResolver.md | markdown | 2.2 KB |
| references/makeRenderDataHook.md | markdown | 2.5 KB |
| references/mockInitialState.md | markdown | 1.7 KB |
| references/renderDataHook.md | markdown | 9.1 KB |
| references/unit-testing-components.md | markdown | 3.5 KB |
| references/unit-testing-hooks.md | markdown | 3.9 KB |
references/Fixtures.md
View on GitHub<!-- Generated by `yarn build:skills` from docs/core/api/Fixtures.md (react). Edit the source doc, not this file. -->
# Fixtures and Interceptors
Fixtures and Interceptors allow universal data mocking without the need for monkeypatching
fetch behaviors. Fixtures define static responses to specific endpoint arg combinations. This
allows them to be used in static contexts like [mockInitialState()](./mockInitialState.md).
Interceptors are functions run and match a fetch pattern. This restricts them to being used only
in dynamic response contexts like [MockResolver](./MockResolver.md).
## SuccessFixture
Represents a successful response
```ts
export interface SuccessFixture {
endpoint;
args;
response;
error?;
delay?;
}
```
```ts
export interface SuccessFixture<
E extends EndpointInterface = EndpointInterface,
> {
readonly endpoint: E;
readonly args: Readonly<Parameters<E>>;
readonly response:
| ResolveType<E>
| ((...args: Parameters<E>) => ResolveType<E>);
readonly error?: false;
/** Number of milliseconds to wait before resolving */
readonly delay?: number;
}
```
```ts
const countFixture = {
endpoint: new RestEndpoint({ path: '/api/count' }),
args: [],
response: { count: 0 },
};
```
## ErrorFixtures
Represents a failed/errored response
```ts
export interface ErrorFixture {
endpoint;
args;
response;
error;
delay?;
}
```
```ts
export interface ErrorFixture<E extends EndpointInterface = EndpointInterface> {
readonly endpoint: E;
readonly args: Readonly<Parameters<E>>;
readonly response: any;
readonly error: true;
/** Number of milliseconds to wait before resolving */
readonly delay?: number;
}
```
```ts
const countErrorFixture = {
endpoint: new RestEndpoint({ path: '/api/count' }),
args: [],
response: { message: 'Not found', status: 404 },
error: true,
};
```
## Interceptor
Interceptors will match a request based on its [`testKey()`](https://dataclient.io/rest/api/RestEndpoint#testKey) method, then
compute the response dynamically using the `response()` method.
```ts
interface ResponseInterceptor {
endpoint;
response(...args);
delay?;
delayCollapse?;
}
interface FetchInterceptor {
endpoint;
fetchResponse(input, init);
delay?;
delayCollapse?;
}
type Interceptor = ResponseInterceptor | FetchInterceptor;
```
```ts
interface ResponseInterceptor<
T = any,
E extends EndpointInterface & {
update?: Updater;
testKey(key: string): boolean;
} = EndpointInterface & { testKey(key: string): boolean },
> {
readonly endpoint: E;
response(this: T, ...args: Parameters<E>): ResolveType<E>;
/** Number of milliseconds (or function that returns) to wait before resolving */
readonly delay?: number | ((...args: Parameters<E>) => number);
/** Waits to run `response()` after `delay` time */
readonly delayCollapse?: boolean;
}
interface FetchInterceptor<
T = any,
E extends EndpointInterface & {
update?: Updater;
testKey(key: string): boolean;
fetchResponse(input: RequestInfo, init: RequestInit): Promise<Response>;
extend(options: any): any;
} = EndpointInterface & {
testKey(key: string): boolean;
fetchResponse(input: RequestInfo, init: RequestInit): Promise<Response>;
extend(options: any): any;
},
> {
readonly endpoint: E;
fetchResponse(this: T, input: RequestInfo, init: RequestInit): ResolveType<E>;
/** Number of milliseconds (or function that returns) to wait before resolving */
readonly delay?: number | ((...args: Parameters<E>) => number);
/** Waits to run `response()` after `delay` time */
readonly delayCollapse?: boolean;
}
type Interceptor<T, E> = ResponseInterceptor<T, E> | FetchInterceptor<T, E>;
```
```ts
const incrementInterceptor = {
endpoint: new RestEndpoint({
path: '/api/count/increment',
method: 'POST',
body: undefined,
}),
response() {
return {
count: (this.count = this.count + 1),
};
},
delay: () => 500 + Math.random() * 4500,
};
```
## Arguments
### endpoint
The endpoint to match.
### args
(Fixtures only) The args to match.
### response(...args) {#response}
Determines what the response for this mock should be. If a function it will be run.
Function running is called 'collapsing' after the mechanism in [Quantum Mechanics](https://www.wondriumdaily.com/copenhagen-interpretation-of-quantum-mechanics/)
`this` can be used to store simulated server-side data. It is initialized using [getInitialInterceptorData](./MockResolver.md#getinitialinterceptordata). It's important to not use arrow functions when using this as they disallow `this` binding.
### fetchResponse(input, init) {#fetchResponse}
When provided, will construct a response() method to be used based on overriding
(by calling [.extend](https://dataclient.io/rest/api/RestEndpoint#extend)) [fetchResponse](https://dataclient.io/rest/api/RestEndpoint#fetchResponse).
Simply return the value expected, rather than an actual HTTP [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response).
```ts
const incrementInterceptor = {
endpoint: new RestEndpoint({
path: '/api/count/increment',
method: 'POST',
body: undefined,
}),
fetchResponse(input, init) {
return {
count: (this.count = this.count + 1),
updatedAt: JSON.parse(init.body).updatedAt,
};
},
};
```
This can be useful when you want to use the body generated in a custom [getRequestInit()](https://dataclient.io/rest/api/RestEndpoint#getRequestInit)
It may return a promise, for example to simulate a slow server. `init.signal` is the fetch's
[AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) (the endpoint's `signal`), so the
interceptor can stop waiting when the fetch is aborted.
### delay: number {#delay}
This is the number of milliseconds to wait before resolving the promise. This can be useful
when simulating race conditions.
When a function is sent, its return value is used as the number of milliseconds.
Aborting the fetch's [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) during the delay
rejects it with an `AbortError`, as `fetch()` would.
### delayCollapse: boolean {#delayCollapse}
`true`: Runs response() after [delay](#delay) time
`false`: Runs response() immediately, then resolves it after [delay](#delay) time
This can be useful for simulating server-processing delays.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |