Introduce the smallest behavior-preserving seam needed to test a specific C#\nbehavior, then add deterministic tests that prove both the behavior and the seam.\nThe production edit is a means to the requested test, not an invitation to\nredesign adjacent code.
\ncode-testing-agent.detect-static-dependencies.generate-testability-wrappers.migrate-static-to-wrapper, then generate tests separately.| Input | \nRequired | \nDescription | \n
|---|---|---|
| Behavior to test | \nYes | \nThe method/workflow and expected observable behavior | \n
| Target scope | \nNo | \nDiscover the narrowest relevant file/project when omitted | \n
| Allowed production changes | \nNo | \nDefault to the minimum internal/constructor seam | \n
Read the target production path and its existing tests. Identify the exact ambient\noperation preventing a deterministic test and the behavior that must remain\nunchanged. Do not run a repository-wide static scan for a single-class request.
\nIf an adequate seam already exists, stop refactoring and use it. This skill adds\nno value when a fake can already be supplied.
\nChoose by dependency and repository constraints:
\n| Dependency | \nPreferred seam | \n
|---|---|
| Current time / timers | \nInject TimeProvider; use FakeTimeProvider in tests | \n
| Filesystem | \nExisting repository file abstraction; otherwise the smallest interface or System.IO.Abstractions when already used/accepted | \n
| HTTP | \nExisting typed HttpClient/handler or IHttpClientFactory seam | \n
| Randomness | \nInject Random or a minimal generator interface | \n
| Environment/console/process | \nMinimal interface containing only members used by the target | \n
The scoped AsyncLocal<T> rule applies to every static API that must retain its\npublic static shape — clocks, filesystem access, environment lookups, identity\ngeneration, and randomness. The scope captures and restores the previous value;\nnever implement Dispose() as an unconditional assignment to null.
Constructor injection is the default for instance classes. Reuse the repository's\nDI and naming conventions, but do not add a DI container to a class library just\nto satisfy this workflow.
\nFor a static class or a public API that cannot change, use a scoped ambient seam\nonly when constructor/parameter injection is impossible. The override must:
\nawait (AsyncLocal<T>, not [ThreadStatic]);IDisposable and restore the previous value, including nested scopes;Use built-in fake-time-aware overloads instead of inventing an IDelay wrapper:
| Ambient operation | \nReplacement | \n
|---|---|
Task.Delay(delay, token) | \nTask.Delay(delay, timeProvider, token) | \n
new CancellationTokenSource(delay) | \nnew CancellationTokenSource(delay, timeProvider) | \n
PeriodicTimer(period) | \nnew PeriodicTimer(period, timeProvider) when the target framework provides it | \n
Test delayed behavior by starting the operation, proving it is incomplete,\nadvancing FakeTimeProvider, then awaiting it. Never wait for wall-clock time.
For a nested ambient override, disposing the inner scope must restore the outer\nvalue, not clear the slot. Capture the previous value per scope:
\npublic static IDisposable OverrideClock(Func<DateTimeOffset> clock)\n{\n var previous = s_clock.Value;\n s_clock.Value = clock;\n return new Scope(() => s_clock.Value = previous);\n}\nAdd tests for both nesting and parallel async flows; parallel-only tests do not\ncatch the common \"dispose sets null\" bug.
\nKeep the production change mechanical:
\nDateTime.Kind.For time replacements:
\nDateTime.UtcNow -> timeProvider.GetUtcNow().UtcDateTimeDateTime.Now -> timeProvider.GetLocalNow().LocalDateTimeDateTimeOffset.UtcNow -> timeProvider.GetUtcNow()DateTimeOffset.Now -> timeProvider.GetLocalNow()Update every composition root or constructor call affected by the seam. Production\nmust still use real time/filesystem/etc. by default. If the project uses DI,\nregister the default implementation with the lifetime matching repository\nconventions. If it does not use DI, compose explicitly; do not introduce a\ncontainer.
\nBuild the affected production project before writing tests. A compile failure here\nis a seam problem, not a test problem.
\nUse the repository's existing test project. If none exists, invoke\nscaffold-dotnet-test-project first.
Tests must supply controlled dependencies:
\nAssert the requested business result and at least one interaction/state observable\nthat proves the fake dependency drove the path. Include a production-default test\nonly when it can remain deterministic; never touch the real filesystem merely to\nprove the adapter delegates.
\nRun the affected production build, targeted test project, and repository-level\ntest command. Re-read the diff and confirm:
\nProvide a compact Requirement | Evidence table. Cite the production seam,\nproduction default wiring, exact test names, and passing commands. If a package\nrestore or build blocks validation, report that blocker rather than claiming the\ntests pass.
DateTime.Kind semantics.| Pitfall | \nCorrective action | \n
|---|---|
| Refactoring before proving a blocker | \nReuse an existing seam and write the test directly | \n
| Wrapping an entire static API | \nExpose only members exercised by the target | \n
Converting UtcNow with .DateTime | \nUse .UtcDateTime to preserve DateTimeKind.Utc | \n
| Mutable static fake shared by tests | \nUse constructor injection or a scoped AsyncLocal<T> override | \n
| Adding DI to a library with no container | \nCompose the dependency explicitly | \n
| Using temp files as a shortcut | \nSupply an in-memory fake; the scenario requires no real I/O | \n
| Stopping after the refactor builds | \nWrite and run the behavior tests that justified the seam | \n