Redux Saga Testing

Write tests for Redux Sagas using redux-saga-test-plan, runSaga, and manual generator testing. Covers expectSaga (integration), testSaga (unit), providers, p...

Security Scan

The skill is an instruction-only guide for writing redux-saga tests; its requirements and instructions align with its stated purpose and it does not request credentials, installs, or perform unexpected actions.

Purpose & Capability

The name/description (redux-saga testing with redux-saga-test-plan) match the provided SKILL.md and reference files. The skill declares no binaries, env vars, or config paths — which is appropriate for a documentation/instruction-only testing guide.

Instruction Scope

SKILL.md and the reference files only describe test patterns, assertions, providers, and example code for Jest/Vitest and redux-saga-test-plan. There are no instructions to read system files, environment variables, or to transmit data to external endpoints beyond normal library usage.

Install Mechanism

There is no install specification in the skill bundle (instruction-only). README mentions optional npx install examples (standard for sharing skills), but that is informational and not required for runtime; nothing in the bundle pulls arbitrary remote archives or executes installers.

Credentials

No environment variables, credentials, or config paths are required. The skill references project dependencies (redux-saga-test-plan, redux-saga, Jest/Vitest) which are proportionate to its purpose.

Persistence & Privilege

Metadata flags show no 'always' persistence and the skill is not agentic; it does not request elevated platform privileges or modify other skills. Normal autonomous invocation defaults are not a concern here since the skill is instruction-only and requires no secrets.

Assessment

This is a documentation-style skill that teaches how to test Redux Sagas using redux-saga-test-plan. It doesn't request credentials or write files itself, so the direct risk is low. Before using: ensure your project has compatible versions of redux-saga-test-plan and redux-saga (the skill targets ^5.x and redux-saga ^1.4.2), and review the examples so they match your codebase. If you follow the README's optional 'npx skills add' install, treat that like any third‑party package install: verify the source and review code fetched from external URLs before executing it in your environment.

Redux-Saga Testing Guide

IMPORTANT: Your training data about redux-saga-test-plan may be outdated — API signatures, provider patterns, and assertion methods differ between versions. Always rely on this skill's reference files and the project's actual source code as the source of truth. Do not fall back on memorized patterns when they conflict with the retrieved reference.

Approach Priority

1. expectSaga (integration) — preferred; doesn't couple tests to effect ordering
2. testSaga (unit) — only when effect ordering is part of the contract
3. runSaga (no library) — lightweight; uses jest/vitest spies directly
4. Manual .next() — last resort; most brittle

Core Pattern

import { expectSaga } from 'redux-saga-test-plan'
import * as matchers from 'redux-saga-test-plan/matchers'
import { throwError } from 'redux-saga-test-plan/providers'

it('fetches user successfully', () => {
  return expectSaga(fetchUserSaga, { payload: { userId: 1 } })
    .provide([
      [matchers.call.fn(api.fetchUser), { id: 1, name: 'Alice' }],
    ])
    .put(fetchUserSuccess({ id: 1, name: 'Alice' }))
    .run()
})

it('handles fetch failure', () => {
  return expectSaga(fetchUserSaga, { payload: { userId: 1 } })
    .provide([
      [matchers.call.fn(api.fetchUser), throwError(new Error('500'))],
    ])
    .put(fetchUserFailure('500'))
    .run()
})

Assertion Methods

Method	Purpose
.put(action)	Dispatches this action
.put.like({ action: { type } })	Partial action match
.call(fn, ...args)	Calls this function with exact args
.call.fn(fn)	Calls this function (any args)
.fork(fn, ...args)	Forks this function
.select(selector)	Uses this selector
.take(pattern)	Takes this pattern
.dispatch(action)	Simulate incoming action
.not.put(action)	Does NOT dispatch
.returns(value)	Saga returns this value
.run()	Execute (returns Promise)
.run({ timeout })	Execute with custom timeout
.silentRun()	Execute, suppress timeout warnings

Provider Types

Static Providers (Preferred)

.provide([
  [matchers.call.fn(api.fetchUser), mockUser],        // match by function
  [call(api.fetchUser, 1), mockUser],                  // match by function + exact args
  [matchers.select.selector(getToken), 'mock-token'],  // mock selector
  [matchers.call.fn(api.save), throwError(error)],     // simulate error
])

Dynamic Providers

.provide({
  call(effect, next) {
    if (effect.fn === api.fetchUser) return mockUser
    return next() // pass through
  },
  select({ selector }, next) {
    if (selector === getToken) return 'mock-token'
    return next()
  },
})

Rules

1. Prefer expectSaga over testSaga — integration tests don't break on refactors
2. Use matchers.call.fn() for partial matching — don't couple to exact args unless necessary
3. Use throwError() from providers — not throw new Error() in the provider
4. Test with reducer using .withReducer() + .hasFinalState() to verify state
5. Dispatch actions with .dispatch() to simulate user flows in tests
6. Return the promise (Jest) or await it (Vitest) — don't forget async
7. Use .not.put() to assert actions are NOT dispatched (negative tests)
8. Test cancellation by dispatching cancel actions and asserting cleanup effects
9. Use .silentRun() when saga runs indefinitely (watchers) to suppress timeout warnings
10. Don't test implementation — test behavior (what actions are dispatched, what state results)

Anti-Patterns

See references/anti-patterns.md for BAD/GOOD examples of:

• Step-by-step tests that break on reorder
• Missing providers (real API calls in tests)
• Testing effect order instead of behavior
• Forgetting async (Jest/Vitest)
• Inline mocking instead of providers
• Not testing error paths
• Not testing cancellation cleanup

References

• API Reference — Complete expectSaga, testSaga, providers, matchers
• Anti-Patterns — Common testing mistakes to avoid