From 245305a1f2085a15eae97b5b5905fae770f90dea Mon Sep 17 00:00:00 2001
From: Ian Johnson <ian.phillip.johnson@gmail.com>
Date: Tue, 8 Sep 2026 20:35:18 -0400
Subject: [PATCH 1/2] Pin every test parameter, and let a harness name the ones
 that drive

1.4.0 pinned only what an attribute declared, and that is the wrong default. A
parameter exists to be looked at: the test was handed it so it could assert on
it, or configure it and then assert on something else. Handing the test one
container's instance while the invocation runs against another makes the
assertion meaningless, and it is meaningless the same way for a plain
application class a handler appends to as for a [Mock]. The attribute is not
what makes it so.

The rule is two sentences now. A test parameter is one instance for the whole
test, unless it is something the harness supplies to drive the application. A
registration nothing holds is per container, unless the harness pins it by name.

IsolatedServices(MethodInfo) is the second half. A trigger facade, a test web
application, an HttpClient and a generated client build a container per call, so
pinning one pins the thing meant to be rebuilt and every call runs against one
container while the test believes otherwise. Only the harness supplying them can
know which they are, and it answers per test method because the answer is a
property of the signature rather than of the attribute. It wins over an explicit
[Shared], because that is correctness rather than preference.

IServiceProvider is never pinned. A test asking for one is asking which
container it is in.

Found by the first test a scaffolded project runs, which takes a plain class and
asserts on what the handler recorded. A rule that needs an attribute to work is
a rule most tests will not get.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  37 ++++++
 Directory.Build.props                         |   4 +-
 .../Interfaces/ISharedTestRegistration.cs     |  80 ++++++++++---
 .../Impl/SharedRegistrations.cs               |  90 ++++++++++----
 .../PublicApiTests.TestingApi.verified.txt    |   1 +
 .../TestingTests/SharedRegistrationsTests.cs  | 111 ++++++++++++++----
 .../TestingTests/TestContainerSourceTests.cs  |  38 +++++-
 7 files changed, 286 insertions(+), 75 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e403bd7..4052c88 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,43 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.0] - 2026-09-08
+
+### Changed
+
+- **A test parameter is now pinned without being asked.** 1.4.0 pinned only what an attribute
+  declared, and that is the wrong default: a parameter exists to be looked at, so handing the test
+  one container's instance while the invocation runs against another makes the assertion
+  meaningless. That is as true of a plain application class a handler appends to as it is of a
+  `[Mock]`, and no attribute is what makes it so.
+
+  1.4.0's rule failed on the first test a scaffolded project runs, which takes a plain class and
+  asserts on what the handler recorded. A rule that needs an attribute to work is a rule most tests
+  will not get.
+
+  The rule is now two sentences. A test parameter is one instance for the whole test, unless it is
+  something the harness supplies to drive the application. A registration nothing holds is per
+  container, unless the harness pins it by name.
+
+### Added
+
+- `ISharedTestRegistration.IsolatedServices(MethodInfo)`, which names the parameters that must *not*
+  be pinned because they build containers rather than live in one - a trigger façade, a test web
+  application, an `HttpClient`, a generated client. Only the harness supplying them can know which
+  they are, and it answers per test method because the answer is a property of the signature. It
+  wins over every other answer, including an explicit `[Shared]`: pinning one of these is not a
+  preference, it turns the isolation off while the test believes it is on.
+
+  A default implementation returning empty, so it is additive.
+
+- `IServiceProvider` is never pinned. A test asking for one is asking which container it is in,
+  which is the one question pinning cannot answer.
+
+### Note
+
+1.4.0 was released the same day and is superseded by this. Its only difference is the default above,
+and nothing consumed it.
+
 ## [1.4.0] - 2026-09-08
 
 ### Added
diff --git a/Directory.Build.props b/Directory.Build.props
index e1d9362..7f3b71f 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -6,7 +6,7 @@
         local and CI builds fall back to the values below.
     -->
     <PropertyGroup>
-        <VersionPrefix>1.4.0</VersionPrefix>
+        <VersionPrefix>1.5.0</VersionPrefix>
         <!--
             Empty at 1.0.0. Set it again to cut a prerelease of the next version; the file version
             carries no prerelease part, so it stays put until the version it does carry changes.
@@ -22,7 +22,7 @@
             depend on. It moves at 2.0.0.
         -->
         <AssemblyVersion>1.0.0.0</AssemblyVersion>
-        <FileVersion>1.4.0.0</FileVersion>
+        <FileVersion>1.5.0.0</FileVersion>
     </PropertyGroup>
 
     <!--
diff --git a/src/DependencyModules.Testing/Attributes/Interfaces/ISharedTestRegistration.cs b/src/DependencyModules.Testing/Attributes/Interfaces/ISharedTestRegistration.cs
index 223186e..bb99c00 100644
--- a/src/DependencyModules.Testing/Attributes/Interfaces/ISharedTestRegistration.cs
+++ b/src/DependencyModules.Testing/Attributes/Interfaces/ISharedTestRegistration.cs
@@ -1,23 +1,36 @@
+using System.Reflection;
 namespace DependencyModules.Testing.Attributes.Interfaces;
 
 /// <summary>
-/// Declares that what an attribute registered is pinned for the whole test, rather than rebuilt
-/// with every container the test creates.
+/// Adjusts which objects survive a test's container being rebuilt.
 /// </summary>
 /// <remarks>
 /// <para>
-/// A test that builds a container per invocation needs some things to survive the rebuild. A mock is
-/// the clear case: a substitute resolved fresh per container is one the test can assert nothing
-/// about, because the invocation recorded onto a different object. Implementing this is how an
-/// attribute says so once, in its own definition, rather than every use site remembering
-/// <c>[Shared]</c>.
+/// The default needs no attribute, and is two sentences:
 /// </para>
 /// <para>
-/// <b>The bar is narrow.</b> Implement this only where isolated would be <em>broken</em> for the
-/// attribute rather than merely unusual. Hiding a decision from the reader of a test is a cost;
-/// hiding a non-decision is not. <see cref="MockAttribute"/> clears the bar because an isolated mock
-/// has no coherent reading at all. <see cref="TestExportAttribute"/> does not, which is why it
-/// implements this with <c>Shared</c> defaulting to false and leaves the choice at the use site.
+/// <b>A test parameter is one instance for the whole test, unless it is something the harness
+/// supplies to drive the application. A registration nothing holds is per container, unless the
+/// harness pins it by name.</b>
+/// </para>
+/// <para>
+/// A parameter exists to be looked at - the test was handed it so it could assert on it, or
+/// configure it and then assert on something else - so handing the test one container's instance
+/// while the invocation runs against another makes the assertion meaningless. That is true of a
+/// <c>[Mock]</c>, of a plain application class a handler appends to, and of a registry a test
+/// registers a filter on, and no attribute is what makes it so.
+/// </para>
+/// <para>
+/// <b>This interface is for the two exceptions.</b> <see cref="IsolatedServices"/> names the
+/// parameters that must <em>not</em> be pinned because they build containers rather than live in
+/// one, and <see cref="SharedServices"/> names services no parameter holds that should be kept
+/// anyway. <see cref="Shared"/> answering false declines the default for one parameter.
+/// </para>
+/// <para>
+/// An earlier version of this pinned only what an attribute declared. It failed on the first thing
+/// a new user runs: a scaffolded test taking a plain application class and asserting on what the
+/// handler recorded, which was rebuilt with the container the send ran on. A rule that needs an
+/// attribute to work is a rule most tests will not get.
 /// </para>
 /// </remarks>
 public interface ISharedTestRegistration {
@@ -27,18 +40,49 @@ public interface ISharedTestRegistration {
     /// </summary>
     /// <remarks>
     /// A <c>bool</c> rather than a bare marker interface, so an attribute whose answer depends on how
-    /// it was constructed can say so. The default suits an attribute that is always shared.
+    /// it was constructed can say so. On a parameter attribute this is only worth answering to
+    /// decline, since a parameter is pinned without being asked.
     /// </remarks>
     bool Shared => true;
 
     /// <summary>
-    /// The services to pin, for an attribute that registers one without naming a parameter.
+    /// Services to pin that no test parameter holds.
     /// </summary>
     /// <remarks>
-    /// Empty means the harness already knows what to pin, which is the parameter's type for an
-    /// attribute sitting on one. An <see cref="ITestServiceSetupAttribute"/> has no parameter to read,
-    /// so it answers here - which is also what lets an implementation outside this assembly join in
-    /// without the runner knowing about it.
+    /// The second exception. A parameter is pinned because the test holds it; something nothing holds
+    /// needs naming, which is how a harness keeps its own per-test services - a cancellation token, an
+    /// environment - one object across every container, and how
+    /// <c>[TestExport(Shared = true)]</c> keeps a fake a handler resolves and the test never sees.
     /// </remarks>
     IReadOnlyList<Type> SharedServices => [];
+
+    /// <summary>
+    /// Parameters this attribute supplies that must <em>not</em> be pinned, because they build
+    /// containers rather than live in one.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The exception to the rule that a test parameter is one instance. A trigger façade, a test web
+    /// application, an <c>HttpClient</c> and a generated client are handed to a test so it can drive
+    /// the application, and each builds a container per call - so pinning one would pin the very
+    /// thing that is supposed to be rebuilt, and every call would run against one container while
+    /// the test believed otherwise.
+    /// </para>
+    /// <para>
+    /// Named by the attribute that supplies them, because nothing else can know. They are ordinary
+    /// types in an ordinary signature, indistinguishable from a service the application registered
+    /// until you know which harness put them there.
+    /// </para>
+    /// <para>
+    /// Takes the test method, unlike <see cref="SharedServices"/>, because the answer is a property
+    /// of the signature: an attribute supplies a façade for <em>this</em> test's parameters and has
+    /// no fixed list of its own.
+    /// </para>
+    /// <para>
+    /// This wins over every other answer here, including an explicit <c>[Shared]</c>. Pinning one of
+    /// these is not a preference that could go either way; it silently turns the isolation off.
+    /// </para>
+    /// </remarks>
+    /// <param name="testMethod">The test whose parameters are being supplied.</param>
+    IReadOnlyList<Type> IsolatedServices(MethodInfo testMethod) => [];
 }
diff --git a/src/DependencyModules.Testing/Impl/SharedRegistrations.cs b/src/DependencyModules.Testing/Impl/SharedRegistrations.cs
index 90601e0..ff21654 100644
--- a/src/DependencyModules.Testing/Impl/SharedRegistrations.cs
+++ b/src/DependencyModules.Testing/Impl/SharedRegistrations.cs
@@ -4,7 +4,7 @@
 namespace DependencyModules.Testing.Impl;
 
 /// <summary>
-/// Works out which services are pinned for one test.
+/// Works out which services survive a test's container being rebuilt.
 /// </summary>
 /// <remarks>
 /// Shared by every integration, because the rule is the same one wherever the test runs and only the
@@ -12,22 +12,44 @@ namespace DependencyModules.Testing.Impl;
 /// </remarks>
 public static class SharedRegistrations {
 
+    /// <summary>
+    /// Types the harness itself can never pin, whatever anything else says.
+    /// </summary>
+    /// <remarks>
+    /// <see cref="IServiceProvider"/> is the container. A test asking for one is asking which
+    /// container it is in, which is the one question pinning cannot answer.
+    /// </remarks>
+    private static readonly Type[] NeverPinned = [typeof(IServiceProvider)];
+
     /// <summary>
     /// The service types to keep across every container the test builds.
     /// </summary>
     /// <remarks>
     /// <para>
-    /// Two sources, and the difference is only in how each names what it registered. An attribute on
-    /// the method, the class or the assembly registers a service without naming a parameter, so it
-    /// answers <see cref="ISharedTestRegistration.SharedServices"/> - <c>[TestExport]</c> names the
-    /// service it exported. An attribute on a parameter has one by definition, so an empty
-    /// <c>SharedServices</c> is read as that parameter's type, which is what keeps <c>[Mock]</c> to a
-    /// single interface on the class and nothing else.
+    /// The rule, in the order it is applied:
+    /// </para>
+    /// <para>
+    /// <b>Every parameter the test is handed is pinned.</b> A parameter exists to be looked at, so
+    /// handing the test one container's instance while the invocation runs against another makes the
+    /// assertion meaningless. That is as true of a plain application class the handler appends to as
+    /// it is of a <c>[Mock]</c>, which is why no attribute is required and why an earlier version of
+    /// this that required one failed on the first test a scaffolded project runs.
+    /// </para>
+    /// <para>
+    /// <b>Except the ones that drive the application.</b> A façade, a test web application, an
+    /// <c>HttpClient</c> and a generated client build a container per call, so pinning one pins the
+    /// thing meant to be rebuilt. Only the harness that supplies them knows which they are, so it
+    /// names them through <see cref="ISharedTestRegistration.IsolatedServices"/>, and that answer
+    /// wins over everything else here - it is correctness rather than preference.
     /// </para>
     /// <para>
-    /// An attribute answering <c>Shared</c> false contributes nothing rather than un-pinning what
-    /// something else pinned. Two attributes naming one service disagreeing is a use site asking for
-    /// both, and pinning is the answer that leaves the test able to see what it asked to see.
+    /// <b>Plus what no parameter holds but something asked for.</b> A harness's own per-test
+    /// services, and <c>[TestExport(Shared = true)]</c>.
+    /// </para>
+    /// <para>
+    /// A type nothing registered can end up in this set - a value from a data row, a concrete class
+    /// the resolver constructs - and that is inert rather than wrong. Pinning rewrites descriptors,
+    /// and there are none to rewrite.
     /// </para>
     /// </remarks>
     /// <param name="method">The test method, for its parameters.</param>
@@ -35,36 +57,52 @@ public static class SharedRegistrations {
     /// The attributes in scope for the test, widest first, as the runner collected them.
     /// </param>
     public static IReadOnlyCollection<Type> Collect(MethodInfo method, IEnumerable<Attribute> knownAttributes) {
-        var pinned = new HashSet<Type>();
+        var attributes = knownAttributes as IReadOnlyCollection<Attribute> ?? knownAttributes.ToArray();
 
-        foreach (var registration in knownAttributes.OfType<ISharedTestRegistration>()) {
-            if (!registration.Shared) {
-                continue;
-            }
+        var isolated = new HashSet<Type>(NeverPinned);
 
-            foreach (var service in registration.SharedServices) {
-                pinned.Add(service);
+        foreach (var registration in attributes.OfType<ISharedTestRegistration>()) {
+            foreach (var service in registration.IsolatedServices(method)) {
+                isolated.Add(service);
             }
         }
 
+        var pinned = new HashSet<Type>();
+
         foreach (var parameter in method.GetParameters()) {
-            foreach (var registration in parameter.GetCustomAttributes().OfType<ISharedTestRegistration>()) {
-                if (!registration.Shared) {
-                    continue;
-                }
+            var declarations = parameter.GetCustomAttributes()
+                .OfType<ISharedTestRegistration>()
+                .ToArray();
 
-                if (registration.SharedServices.Count == 0) {
-                    pinned.Add(parameter.ParameterType);
+            // Declining is the only thing worth saying on a parameter, since one is pinned without
+            // being asked. A second attribute asking cannot undo it: two attributes on one parameter
+            // disagreeing is a use site asking for both, and pinned is the answer that leaves the
+            // test able to see what it was asserting on.
+            if (declarations.Any(declaration => !declaration.Shared)) {
+                continue;
+            }
 
-                    continue;
-                }
+            pinned.Add(parameter.ParameterType);
 
-                foreach (var service in registration.SharedServices) {
+            foreach (var declaration in declarations) {
+                foreach (var service in declaration.SharedServices) {
                     pinned.Add(service);
                 }
             }
         }
 
+        foreach (var registration in attributes.OfType<ISharedTestRegistration>()) {
+            if (!registration.Shared) {
+                continue;
+            }
+
+            foreach (var service in registration.SharedServices) {
+                pinned.Add(service);
+            }
+        }
+
+        pinned.ExceptWith(isolated);
+
         return pinned;
     }
 }
diff --git a/tests/DependencyModules.Tests/Snapshots/PublicApiTests.TestingApi.verified.txt b/tests/DependencyModules.Tests/Snapshots/PublicApiTests.TestingApi.verified.txt
index 357883d..4e2d1c4 100644
--- a/tests/DependencyModules.Tests/Snapshots/PublicApiTests.TestingApi.verified.txt
+++ b/tests/DependencyModules.Tests/Snapshots/PublicApiTests.TestingApi.verified.txt
@@ -56,6 +56,7 @@ namespace DependencyModules.Testing.Attributes.Interfaces
     {
         bool Shared { get; }
         System.Collections.Generic.IReadOnlyList<System.Type> SharedServices { get; }
+        System.Collections.Generic.IReadOnlyList<System.Type> IsolatedServices(System.Reflection.MethodInfo testMethod);
     }
     public interface ITestContainerSource
     {
diff --git a/tests/DependencyModules.Tests/TestingTests/SharedRegistrationsTests.cs b/tests/DependencyModules.Tests/TestingTests/SharedRegistrationsTests.cs
index 84d6cf8..1109c48 100644
--- a/tests/DependencyModules.Tests/TestingTests/SharedRegistrationsTests.cs
+++ b/tests/DependencyModules.Tests/TestingTests/SharedRegistrationsTests.cs
@@ -10,6 +10,10 @@ namespace DependencyModules.Tests.TestingTests;
 /// <summary>
 /// Which services a test pins, decided without a container or a test framework in the way.
 /// </summary>
+/// <remarks>
+/// One test per row of the rule, because the rule has been wrong once already and the way it was
+/// wrong was a case nobody had written down.
+/// </remarks>
 public class SharedRegistrationsTests {
 
     private interface IThing;
@@ -18,11 +22,21 @@ private interface IOther;
 
     private class Thing : IThing;
 
-    /// <summary>An attribute that answers no, to prove declining is not the same as not implementing.</summary>
+    /// <summary>Stands for a façade or a client: something the harness supplies to drive with.</summary>
+    private interface IDriver;
+
+    /// <summary>An attribute that declines, which is the only thing worth saying on a parameter.</summary>
     private class NotSharedAttribute : Attribute, ISharedTestRegistration {
         public bool Shared => false;
+    }
 
-        public IReadOnlyList<Type> SharedServices => [typeof(IOther)];
+    /// <summary>A harness naming what it supplies, the way the trigger and web attributes do.</summary>
+    private class DrivenByAttribute : Attribute, ISharedTestRegistration {
+        public IReadOnlyList<Type> IsolatedServices(MethodInfo testMethod) =>
+            testMethod.GetParameters()
+                .Where(parameter => parameter.ParameterType == typeof(IDriver))
+                .Select(parameter => parameter.ParameterType)
+                .ToArray();
     }
 
     private static IReadOnlyCollection<Type> Collect(string method, params Attribute[] known) =>
@@ -32,72 +46,117 @@ private static IReadOnlyCollection<Type> Collect(string method, params Attribute
 
     private static void Plain(IThing thing) { }
 
+    private static void Bare(IThing thing, IOther other) { }
+
     private static void Marked([Shared] IThing thing) { }
 
     private static void Mocked([Mock] IThing thing) { }
 
     private static void Declined([NotShared] IThing thing) { }
 
-    private static void Several([Shared] IThing thing, [Mock] IOther other, string plain) { }
+    private static void Driving(IDriver driver, IThing thing) { }
+
+    private static void DrivingAndMarked([Shared] IDriver driver) { }
 
-    /// <summary>A parameter says nothing on its own, which is what keeps the default isolated.</summary>
+    private static void Container(IServiceProvider provider, IThing thing) { }
+
+    private static void None() { }
+
+    // ---------------------------------------------------------------- the default
+
+    /// <summary>
+    /// The row the first version of this rule got wrong, and the one a scaffolded project hits
+    /// first: a plain application service the handler writes to and the test reads.
+    /// </summary>
     [Fact]
-    public void AnUnmarkedParameterIsNotPinned() {
-        Assert.Empty(Collect(nameof(Plain)));
+    public void AnUnmarkedParameterIsPinned() {
+        Assert.Equal([typeof(IThing)], Collect(nameof(Plain)));
     }
 
     [Fact]
-    public void SharedPinsTheParametersType() {
-        Assert.Equal([typeof(IThing)], Collect(nameof(Marked)));
+    public void EveryParameterIsPinned() {
+        Assert.Equal([typeof(IThing), typeof(IOther)], Collect(nameof(Bare)));
     }
 
+    /// <summary>A mock needs no attribute to be pinned, which is what makes the rule general.</summary>
+    [Fact]
+    public void AMockIsPinnedLikeAnythingElse() {
+        Assert.Equal([typeof(IThing)], Collect(nameof(Mocked)));
+    }
+
+    /// <summary>Redundant now, and still allowed: it is how a driving parameter asks for reuse.</summary>
+    [Fact]
+    public void SharedOnAValueParameterChangesNothing() {
+        Assert.Equal(Collect(nameof(Plain)), Collect(nameof(Marked)));
+    }
+
+    [Fact]
+    public void ATestWithNoParametersPinsNothing() {
+        Assert.Empty(Collect(nameof(None)));
+    }
+
+    // ---------------------------------------------------------------- the exceptions
+
     /// <summary>
-    /// The point of the interface: [Mock] pins without the use site writing [Shared].
+    /// The parameter that drives the application is not pinned, because it builds the containers.
     /// </summary>
     [Fact]
-    public void MockPinsWithoutBeingAsked() {
-        Assert.Equal([typeof(IThing)], Collect(nameof(Mocked)));
+    public void AParameterTheHarnessDrivesWithIsNotPinned() {
+        var pinned = Collect(nameof(Driving), new DrivenByAttribute());
+
+        Assert.Equal([typeof(IThing)], pinned);
     }
 
+    /// <summary>
+    /// And it stays unpinned even asked to be. Pinning a driver is not a preference that could go
+    /// either way; it turns the isolation off while the test believes it is on.
+    /// </summary>
     [Fact]
-    public void AnAttributeAnsweringNoPinsNothing() {
+    public void IsolatedWinsOverAnExplicitShared() {
+        Assert.Empty(Collect(nameof(DrivingAndMarked), new DrivenByAttribute()));
+    }
+
+    [Fact]
+    public void AnAttributeDecliningUnpinsItsParameter() {
         Assert.Empty(Collect(nameof(Declined)));
     }
 
+    /// <summary>The container itself is the one question pinning cannot answer.</summary>
     [Fact]
-    public void EveryMarkedParameterIsCollected() {
-        Assert.Equal([typeof(IThing), typeof(IOther)], Collect(nameof(Several)));
+    public void TheServiceProviderIsNeverPinned() {
+        Assert.Equal([typeof(IThing)], Collect(nameof(Container)));
     }
 
+    // ---------------------------------------------------------------- what no parameter holds
+
     /// <summary>
-    /// An attribute with no parameter names what it registered, which is how [TestExport] joins in
-    /// from the method, the class or the assembly.
+    /// A harness keeps its own per-test services by naming them, since no parameter holds them.
     /// </summary>
     [Fact]
-    public void AnExportAskingToBeSharedNamesItsOwnService() {
-        var shared = new TestExportAttribute(typeof(IThing)) {
+    public void AnAttributeCanPinWhatNoParameterHolds() {
+        var shared = new TestExportAttribute(typeof(IOther)) {
             Implementation = typeof(Thing), Shared = true
         };
 
-        Assert.Equal([typeof(IThing)], Collect(nameof(Plain), shared));
+        Assert.Equal([typeof(IThing), typeof(IOther)], Collect(nameof(Plain), shared));
     }
 
-    /// <summary>The default, and the reason the default is what it is.</summary>
+    /// <summary>An export nothing holds stays per container until it asks.</summary>
     [Fact]
     public void AnExportIsNotPinnedUnlessItAsks() {
-        var isolated = new TestExportAttribute(typeof(IThing)) { Implementation = typeof(Thing) };
+        var isolated = new TestExportAttribute(typeof(IOther)) { Implementation = typeof(Thing) };
 
-        Assert.Empty(Collect(nameof(Plain), isolated));
+        Assert.Equal([typeof(IThing)], Collect(nameof(Plain), isolated));
     }
 
     /// <summary>
-    /// Two attributes naming one service and disagreeing is a use site asking for both. Pinning is
-    /// the answer that leaves the test able to see what it asked to see.
+    /// The parameter is the narrower statement and wins, which is how every other precedence in the
+    /// harness resolves. Isolating it would recreate the bug the rule exists to fix.
     /// </summary>
     [Fact]
-    public void OneAttributeAskingIsEnough() {
+    public void AnExportTheTestHoldsIsPinnedEvenWhenItDeclined() {
         var isolated = new TestExportAttribute(typeof(IThing)) { Implementation = typeof(Thing) };
 
-        Assert.Equal([typeof(IThing)], Collect(nameof(Marked), isolated));
+        Assert.Equal([typeof(IThing)], Collect(nameof(Plain), isolated));
     }
 }
diff --git a/tests/DependencyModules.Tests/TestingTests/TestContainerSourceTests.cs b/tests/DependencyModules.Tests/TestingTests/TestContainerSourceTests.cs
index 1818a18..603a051 100644
--- a/tests/DependencyModules.Tests/TestingTests/TestContainerSourceTests.cs
+++ b/tests/DependencyModules.Tests/TestingTests/TestContainerSourceTests.cs
@@ -39,10 +39,37 @@ public interface IAudit {
 [NSubstituteSupport]
 public class TestContainerSourceTests {
 
+    /// <summary>
+    /// A parameter the test holds crosses every container, with nothing said about it.
+    /// </summary>
+    /// <remarks>
+    /// The row an earlier rule got wrong, and the shape of the scaffolded test that caught it: a
+    /// plain application class a handler writes to and the test reads. Pinning it is the default
+    /// because a parameter exists to be looked at, and looking at one container's instance while the
+    /// work ran in another says nothing.
+    /// </remarks>
+    [ModuleTest(typeof(ContainerSourceModule))]
+    public async Task ABareParameterIsTheSameObjectInEveryContainer(
+        ITestContainerSource source, ICounter counter) {
+        var first = await source.CreateAsync();
+        var second = await source.CreateAsync();
+
+        first.GetRequiredService<ICounter>().Bump();
+        second.GetRequiredService<ICounter>().Bump();
+
+        Assert.Same(counter, first.GetRequiredService<ICounter>());
+        Assert.Equal(2, counter.Value);
+    }
+
     /// <summary>
     /// A singleton is a singleton inside one container and nothing more, which is the property the
     /// whole design turns on.
     /// </summary>
+    /// <remarks>
+    /// Asserted on a service the test does <em>not</em> take as a parameter, because taking one
+    /// pins it. That is the rule, and this is the test that would otherwise quietly stop testing
+    /// anything.
+    /// </remarks>
     [ModuleTest(typeof(ContainerSourceModule))]
     public async Task EachContainerGetsItsOwnApplicationSingleton(ITestContainerSource source) {
         var first = await source.CreateAsync();
@@ -104,11 +131,16 @@ public async Task EveryCallBuildsAContainer(ITestContainerSource source) {
     }
 
     /// <summary>
-    /// [Shared] does for anything what [Mock] does for a substitute, which is the escape hatch for a
-    /// value the test holds and asserts on.
+    /// [Shared] on a value parameter is redundant rather than wrong, and says the same thing the
+    /// default already says.
     /// </summary>
+    /// <remarks>
+    /// Kept working on purpose. The attribute earns its place on a parameter that drives the
+    /// application, where it asks for one container across the calls, and a reader should not have
+    /// to know which kind of parameter they are looking at before writing it.
+    /// </remarks>
     [ModuleTest(typeof(ContainerSourceModule))]
-    public async Task SharedPinsAPlainParameter(ITestContainerSource source, [Shared] ICounter counter) {
+    public async Task SharedOnAValueParameterIsRedundant(ITestContainerSource source, [Shared] ICounter counter) {
         var first = await source.CreateAsync();
         var second = await source.CreateAsync();
 

From a99b6f2d5b5932bb3d525efc06a1c89c253c3da5 Mon Sep 17 00:00:00 2001
From: Ian Johnson <ian.phillip.johnson@gmail.com>
Date: Tue, 8 Sep 2026 20:49:13 -0400
Subject: [PATCH 2/2] Leave a pinned service alone when the first container
 cannot produce it

Pinning is a statement about identity, not a reason to construct something the
test never asked for. The set is drawn from a signature, so it holds types
nothing registered - a value from a data row, a concrete class the resolver
builds on the spot - alongside the ones that matter.

The case that made this necessary is sharper than an absent registration. A
harness may register a deliberately failing factory for a parameter it cannot
supply, so that resolving it fails with a message naming the fix. Resolving
eagerly turned that message into a failure at container build for every test
that took such a parameter and never resolved it, which a data-driven test whose
row supplies a string does. Twenty-four tests in the consuming framework failed
that way, none of them about anything this feature touches.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../Impl/TestContainerSource.cs               | 73 ++++++++++++++++---
 .../TestContainerSourceUnitTests.cs           | 45 ++++++++++++
 2 files changed, 109 insertions(+), 9 deletions(-)

diff --git a/src/DependencyModules.Testing/Impl/TestContainerSource.cs b/src/DependencyModules.Testing/Impl/TestContainerSource.cs
index 005d021..147917a 100644
--- a/src/DependencyModules.Testing/Impl/TestContainerSource.cs
+++ b/src/DependencyModules.Testing/Impl/TestContainerSource.cs
@@ -104,15 +104,16 @@ private IServiceCollection Template(Composition composition) {
     /// </para>
     /// </remarks>
     private static IServiceCollection BuildTemplate(Composition composition) {
+        var instances = Resolve(composition);
+
         IServiceCollection template = new ServiceCollection();
         var taken = new HashSet<Type>();
 
         foreach (var descriptor in composition.Services) {
             var serviceType = descriptor.ServiceType;
 
-            if (!composition.PinnedServices.Contains(serviceType) ||
-                descriptor.ImplementationInstance != null ||
-                serviceType.IsGenericTypeDefinition) {
+            if (!instances.TryGetValue(serviceType, out var pinned) ||
+                descriptor.ImplementationInstance != null) {
                 template.Add(descriptor);
 
                 continue;
@@ -122,18 +123,72 @@ private static IServiceCollection BuildTemplate(Composition composition) {
                 continue;
             }
 
-            var sequence = typeof(IEnumerable<>).MakeGenericType(serviceType);
-
-            foreach (var instance in (IEnumerable)composition.Pinned.GetRequiredService(sequence)) {
-                if (instance != null) {
-                    template.Add(new ServiceDescriptor(serviceType, instance));
-                }
+            foreach (var instance in pinned) {
+                template.Add(new ServiceDescriptor(serviceType, instance));
             }
         }
 
         return template;
     }
 
+    /// <summary>
+    /// The instances to keep, for the pinned services the first container can actually produce.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>A service that cannot be produced is left alone rather than being an error.</b> Pinning is
+    /// a statement about identity, not a reason to construct something the test never asked for, and
+    /// a pinned set drawn from a signature holds types nothing registered - a value from a data row,
+    /// a concrete class the resolver builds on the spot - alongside the ones that matter.
+    /// </para>
+    /// <para>
+    /// The case that made this necessary is sharper than an absent registration. A harness may
+    /// register a <em>deliberately failing</em> factory for a parameter it cannot supply, so that
+    /// resolving it fails with a message naming the fix. Resolving eagerly here turned that message
+    /// into a failure at container build for every test that took such a parameter and never
+    /// resolved it - a data-driven test whose row supplies a string, for one. Leaving the descriptor
+    /// alone means the test either never resolves it, or resolves it and gets the error the harness
+    /// wrote.
+    /// </para>
+    /// <para>
+    /// Resolved through <c>IEnumerable&lt;T&gt;</c> rather than as a single service, so a type
+    /// registered more than once keeps every registration and its order. Taking the single service
+    /// would collapse the set to its last member and leave anything injecting the sequence one
+    /// element long.
+    /// </para>
+    /// <para>
+    /// An open generic is skipped, having no closed type to resolve.
+    /// </para>
+    /// </remarks>
+    private static Dictionary<Type, object[]> Resolve(Composition composition) {
+        var instances = new Dictionary<Type, object[]>();
+
+        foreach (var serviceType in composition.PinnedServices) {
+            if (serviceType.IsGenericTypeDefinition || serviceType.IsByRef || serviceType.IsPointer) {
+                continue;
+            }
+
+            object[] resolved;
+
+            try {
+                var sequence = typeof(IEnumerable<>).MakeGenericType(serviceType);
+
+                resolved = ((IEnumerable)composition.Pinned.GetRequiredService(sequence))
+                    .Cast<object>()
+                    .Where(instance => instance != null)
+                    .ToArray();
+            } catch (Exception) {
+                continue;
+            }
+
+            if (resolved.Length > 0) {
+                instances[serviceType] = resolved;
+            }
+        }
+
+        return instances;
+    }
+
     private sealed record Composition(
         IServiceCollection Services,
         IServiceProvider Pinned,
diff --git a/tests/DependencyModules.Tests/TestingTests/TestContainerSourceUnitTests.cs b/tests/DependencyModules.Tests/TestingTests/TestContainerSourceUnitTests.cs
index 30f1f32..316e833 100644
--- a/tests/DependencyModules.Tests/TestingTests/TestContainerSourceUnitTests.cs
+++ b/tests/DependencyModules.Tests/TestingTests/TestContainerSourceUnitTests.cs
@@ -148,4 +148,49 @@ public async Task AnUninitializedSourceRefuses() {
 
         Assert.Contains("never initialized", refused.Message);
     }
+
+    /// <summary>
+    /// A pinned service the first container cannot produce is left alone rather than failing the
+    /// build.
+    /// </summary>
+    /// <remarks>
+    /// The case that made this necessary: a harness registers a deliberately failing factory for a
+    /// parameter it cannot supply, so resolving it fails with a message naming the fix. Resolving
+    /// eagerly here turned that message into a failure at container build for every test that took
+    /// such a parameter and never resolved it.
+    /// </remarks>
+    [Fact]
+    public async Task APinnedServiceThatCannotBeBuiltIsLeftAlone() {
+        var harness = new Harness(
+            services => {
+                services.AddSingleton<IThing, Thing>();
+                services.AddSingleton<string>(_ => throw new InvalidOperationException("name the fix"));
+            },
+            typeof(IThing), typeof(string));
+
+        var built = await harness.Source.CreateAsync();
+
+        Assert.NotNull(built.GetRequiredService<IThing>());
+
+        var refused = Assert.Throws<InvalidOperationException>(() => built.GetRequiredService<string>());
+
+        Assert.Equal("name the fix", refused.Message);
+    }
+
+    /// <summary>
+    /// A pinned type nothing registered is inert, which is what lets the set be drawn from a
+    /// signature without filtering it first.
+    /// </summary>
+    [Fact]
+    public async Task APinnedTypeNothingRegisteredIsInert() {
+        var harness = new Harness(
+            services => services.AddSingleton<IThing, Thing>(),
+            typeof(IThing), typeof(int), typeof(Uri));
+
+        var built = await harness.Source.CreateAsync();
+
+        Assert.NotNull(built.GetRequiredService<IThing>());
+        Assert.Null(built.GetService<Uri>());
+    }
 }
+