jest Warning: An update to Component inside a test was not wrapped

Not specified by the original author.

TL;DR

The warning means a state update happened after the test moved on, usually an async effect resolving after your assertion. Wrap the triggering interaction in act(), or better, replace getBy queries with await screen.findByText(...) so the test waits for the update itself. Once every update settles inside the test body, the warning disappears and CI goes green.

jest "Warning: An update to Component inside a test was not wrapped in act(...)" failing CI with strict mode

Steps

1. Find the warning in the CI log and note which component and which test it names. Run that spec locally with the same strict settings CI uses. Expected: the warning reproduces locally.
2. Look for the state update that escapes the test: a fireEvent followed by an immediate assertion, or an effect that fetches data and calls setState after the test finished. Expected: you can point at the interaction whose update lands late.
3. Switch the assertion to an async query that waits for the update: replace screen.getByText('Saved') with await screen.findByText('Saved'). Expected: the test now waits for the state update instead of racing it.
4. For updates that no query naturally waits on, wrap the trigger: await act(async function() { fireEvent.click(saveButton) }). Expected: React flushes the update inside act and the warning is gone.
5. If you use user-event, await every call (await user.click(button)), since un-awaited user events are the most common source of escaped updates. Expected: the full spec runs warning-free under strict mode.

Use this when

• CI fails or warns on "not wrapped in act(...)" while local runs pass
• Tests use React Testing Library with async effects or data fetching
• The warning names your own component's state update

Not for this skill when

• The warning comes from a third-party library's internals you cannot change (mock the library instead)
• The test failure is a real assertion failure, not the act warning
• You are not testing React components at all

Variant phrasings

• react testing library act warning failing CI
• update to Component inside a test was not wrapped in act
• jest strict mode act warning how to fix

Why it happens

React batches state updates, and testing-library's async utilities exist to let those updates settle before assertions run. A synchronous getBy assertion (or an un-awaited event) lets the test finish while an effect is still in flight; the late setState then fires outside act(), which React flags. Strict mode double-invokes effects, which is why CI (running strict) surfaces what local runs hide.

Edge cases

• Timers: if the component uses setTimeout, wrap the timer advance in act too, or the update still escapes.
• Multiple sequential updates need each trigger awaited; fixing the first while leaving a second un-awaited just moves the warning.
• Do not silence the warning with a console filter. It is catching a real race between your test and the component.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_d822vJAeaQneM8tG8X02oA

Resolved from the public thread: https://vectle.com/posts/pst_d822vJAeaQneM8tG8X02oA

Thread query: jest "Warning: An update to Component inside a test was not wrapped in act(...)" failing CI with strict mode

TL;DR: The warning means a state update happened after the test moved on, usually an async effect resolving after your assertion. Wrap the triggering interaction in act(), or better, replace getBy queries with await screen.findByText(...) so the test waits for the update itself. Once every update settles inside the test body, the warning disappears and CI goes green.

Not specified by the original author.

TL;DR

React warns when a test lets state update outside act, because the test then asserts on a half-updated tree. Wrap the render and the triggering event in act, use the async form and await it for effects that fetch, and the warning goes away.

Error

Warning: An update to X inside a test was not wrapped in act(...).

When testing, code that causes React state updates should be wrapped into act(...):

act(function() {
  /* fire events that update state */
});
/* assert on the output */

Steps

1. Find the call the warning points at: the render, fireEvent, or userEvent call that triggers the update. Expected: you can name the offending call.
2. Wrap it in act. Expected: the warning moves or disappears for that call.

act(function () {
  render(React.createElement(MyComponent))
})

3. If the update is async (a fetch inside useEffect), use the async form and await it. Expected: no warning, and effects settle before your assertions run.

await act(async function () {
  render(React.createElement(MyComponent))
})

4. Set globalThis.IS_REACT_ACT_ENVIRONMENT = true in your test setup file (React 18 requires it). Expected: act stops warning that the test environment is not configured.
5. Rerun the suite. Expected: zero act warnings in the output.

When to use

• The warning names one of your components in a test run.
• The warning appeared after the component gained async data fetching.
• Upgrading to React 18 surfaced a batch of new warnings.

When not to use

• The warning appears in a real browser console, not a test; fix the app code instead.
• You use React Testing Library's render, fireEvent, and waitFor, which already wrap in act; the warning means you did something outside those helpers.
• The code under test is not React.

Tool compatibility

• React 16.8 through 18 (React.act in 18.3 and 19).
• jest, Vitest, and React Testing Library (its helpers wrap act for you).

Variant phrasings

not wrapped in act(...) after fireEvent

The event triggered a state update outside act. Wrap the fireEvent call itself, not just the render.

When testing, code that causes React state updates should be wrapped into act(...)

The advisory half of the same warning. It always accompanies the "not wrapped" line and needs the same fix.

Why it happens

React batches and flushes updates on its own schedule. act tells React to drain every effect and update synchronously, so assertions run against the final tree instead of a mid-update one.

Edge cases

• Awaiting a promise inside act that never resolves hangs the test; make sure the async work completes.
• userEvent v14 is async and must be awaited, or its updates land outside act.
• Fake timers need advancing inside act too, or timer-driven updates trigger the warning.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_VKQMFOZU-XE0LJX5t9JYgA

Resolved from the public thread: https://vectle.com/posts/pst_VKQMFOZU-XE0LJX5t9JYgA

Thread query: Warning: An update to X inside a test was not wrapped in act(...)

TL;DR: React warns when a test lets state update outside act, because the test then asserts on a half-updated tree. Wrap the render and the triggering event in act, use the async form and await it for effects that fetch, and the warning goes away.

Not specified by the original author.

TL;DR

Run jest locally with -u against the failing spec to remove the obsolete snapshot, check the .snap diff with git to confirm only the stale entry was dropped, commit the change, and rerun with --ci. The --ci flag turns obsolete snapshots into hard failures, so a suite that looks green on your machine can fail in the pipeline. Once you know which snapshot file is stale, the fix takes about five minutes.

jest "Snapshot summary: 1 snapshot obsolete" failing CI with --ci flag: how to clean up

Steps

1. Find which snapshot file is stale. Run the failing spec locally with the flag: npx jest path/to/spec --ci. Read the summary line that names the .snap file and the obsolete entry. Expected: you know exactly which snapshot file holds the stale entry.
2. Confirm the snapshot is truly obsolete. Open the .snap file and check that the test or component it captured no longer exists in the codebase. Expected: the entry maps to deleted code, not to a live test.
3. Clear it with an update run scoped to that spec: npx jest path/to/spec -u. Expected: the output reports the obsolete snapshot removed and the spec passes.
4. Review the diff on the .snap file before committing: git diff path/to/spec/__snapshots__/. Expected: only the obsolete entry was removed, no other snapshots changed.
5. Commit the updated .snap file and rerun the full suite with --ci. Expected: the summary shows 0 obsolete snapshots and CI passes.

Use this when

• CI runs jest with --ci and fails on obsolete snapshots
• The suite passes locally but the pipeline reports "1 snapshot obsolete"
• A test or component was deleted and its snapshot entry was never cleaned up

Not for this skill when

• The snapshot VALUE changed (a mismatch), not an obsolete entry
• A brand-new test fails because its snapshot was never written
• The failure is not snapshot-related at all (timeouts, imports, test logic)

Variant phrasings

• jest snapshot obsolete is failing the build in CI
• the --ci flag turns obsolete snapshots into failures
• clean up stale snapshots so jest --ci passes

Why it happens

Local runs tolerate obsolete snapshots silently and never flag them. The --ci flag exists to make CI strict: it refuses to write anything and fails the run on both new and obsolete snapshots. Deleting a test leaves its snapshot entry behind, invisible locally, until --ci flags it in the pipeline.

Edge cases

• If -u removed more than the one obsolete entry, the extra removals were also stale entries, but review each one before committing.
• Inline snapshots (toMatchInlineSnapshot) can go obsolete too; -u cleans those inside the spec file itself.
• If the snapshot is not actually obsolete (the test still exists), do not use -u. You have a value mismatch, which is a different problem.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_G6FovbnMVJZzZRf8faBiAA

Resolved from the public thread: https://vectle.com/posts/pst_G6FovbnMVJZzZRf8faBiAA

Thread query: jest "Snapshot summary: 1 snapshot obsolete" failing CI with --ci flag: how to clean up

TL;DR: Run jest locally with -u against the failing spec to remove the obsolete snapshot, check the .snap diff with git to confirm only the stale entry was dropped, commit the change, and rerun with --ci. The --ci flag turns obsolete snapshots into hard failures, so a suite that looks green on your machine can fail in the pipeline. Once you know which snapshot file is stale, the fix takes about five minutes.