📖 3 min read (~ 600 words).

Roadmap

What’s next with this project?

timeline
    title Planned releases
    section Q4 2025
    ✅ v2.0 (Nov 2025) : Zero dependencies
                    : optional dependencies (YAML)
                    : modernized code (relint)
                    : JSONEqBytes
    section Q1 2026
    ✅ v2.1 (Jan 2026) : Generated assertions
                    : complete refactoring
                    : documentation site
                    : panic handling fixes
                    : removed deprecated
                    : go1.24+
    ✅ v2.2 (Fev 2026) : Generics
                    : Kind/NotKind
                    : SortedT, NotSortedT
                    : complete test refactoring
                    : more benchmarks. Perf improvements
                    : optional dependencies (colorized)
    ✅ v2.3 (Fev 2026) : Other extensions
                    : Extensible Assertion type
                    : JSON & YAML assertions: JSONMarshalsAs...
                    : NoGoRoutineLeak
                    : more documentation and examples
    ✅ v2.4 (Mar 2026) : Stabilize API (no more removals)
                    : NoFileDescriptorLeak (Linux)
                    : Eventually, Eventually (with context), Consistently
                    : Migration tool
    section Q2 2026
    ✅ v2.5 (May 2026) : synctest opt-in for Eventually, Never, Consistently, EventuallyWith
                    : NoFileDescriptorLeak (macOS)
                    : InEpsilonSymmetric, Blocked/NotBlocked
                    : redactor functons for JSON & YAML assertions
                    : export internal tools (spew, difflib)
                    : go1.25+
    🔍 v2.6 (June 2026) : (tentative)
                    : go build guards (codegen)
                    : ErrorAsType (go1.26+)

Dropped enveavors

For the moment, and after some research, we punt on the following features. We might reconsider these choices in the future, but for now, we are unsure about whether they are worth the added complexity.

  • Enrich CollectT (either as an interface or an extended type that wraps testing.TB) - for EventuallyWith (see also #1862).
  • Expose the internal go routine leak detection package as a drop-in replacement for go.uber.org/go-leak
  • Port NoFileDescriptorLeak to Windows OS
  • Consider hijacking [msgAndArgs …any] to pass options into assertions

Notes

  1. The first release comes with zero dependencies and an unstable API (see below our use case)
  2. This project is going to be injected as the main and sole test dependency of the go-openapi libraries
  3. Since we have leveled the go requirements to the rest of the go-openapi (currently go1.24) there is quite a bit of relinting lying ahead.
  4. Valuable pending pull requests from the original project could be merged (e.g. JSONEqBytes) or transformed as “enable” modules (e.g. colorized output)
  5. More testing and bug fixes (from upstream or detected during our testing)
  6. Introduces colorization (opt-in)
  7. Introduces generics
  8. Realign behavior re quirks, bugs, unexpected logics … (e.g. IsNonDecreasing, EventuallyWithT…)
  9. Unclear assertions might be provided an alternative verb (e.g. EventuallyWithT)

Adoption timeline at go-openapi

  1. Jan 2026: all go-openapi projects adopts the forked testify
  2. Feb 2026: all go-openapi projects transition to generics
  3. Mar 2026: go-swagger transitions to the forked testify

What won’t come anytime soon

  • mocks: we use mockery and prefer the simpler matryer mocking-style. testify-style mocks are thus not going to be supported anytime soon.
  • extra convoluted stuff in the like of InDeltaSlice (more likely to be removed)

Upstream Tracking

We actively monitor github.com/stretchr/testify for updates, new issues, and proposals.

Review frequency: Quarterly (next review: April 2026)

Processed items: 31 upstream PRs and issues have been reviewed, with 23 implemented/merged, 4 superseded by our implementation, 2 informational, and 2 currently under consideration.

For a complete catalog of all upstream PRs and issues we’ve processed (implemented, adapted, superseded, or monitoring), see the Upstream Tracking.