From abe92833b3fcb15626684e697c193d9db65194d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Jare=C5=A1?= <me@jakubjares.com>
Date: Sat, 5 Sep 2026 10:03:41 +0200
Subject: [PATCH 1/3] Apply Pester.BeforeContainer.ps1 when only discovery runs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Run.SkipRun returns the discovered tree without executing anything, which is the path
the VS Code Test Explorer uses to populate. It goes through Discover-Test, a batch
discovery over all containers, and that function never took the BeforeContainer map,
so it called Invoke-ContainerDiscovery without -BeforeContainerFile. A file whose
discovery depends on the setup discovered fine in a normal run and came back empty
when only discovery was requested.

Discover-Test now takes the same map the interleaved discover -> run path gets, and
resolves it per container, because which files apply depends on where the container is
after #2993. Find-Test forwards it too.

The per container lookup was written inline in Invoke-Test and is now a function that
both paths call, so they cannot drift apart again. That also removes the case-insensitive
variable name trap the inline version needed a comment to explain.

Fix #3008

🤖
---
 docs/NEXT-RELEASE.md             |  7 ++++-
 src/Pester.Runtime.ps1           | 47 +++++++++++++++++++++-----------
 tst/Pester.RSpec.Parallel.ts.ps1 | 40 +++++++++++++++++++++++++++
 3 files changed, 77 insertions(+), 17 deletions(-)

diff --git a/docs/NEXT-RELEASE.md b/docs/NEXT-RELEASE.md
index d7f02882f..7a8a69781 100644
--- a/docs/NEXT-RELEASE.md
+++ b/docs/NEXT-RELEASE.md
@@ -1,4 +1,4 @@
-<!--
+<!--
   Release notes for the version in development.
 
   These are written once, for the first alpha, which is usually already close to feature
@@ -437,6 +437,11 @@ Three of these come with the `Pester.BeforeContainer.ps1` cascade above.
 
 ## <a id="6.2.0-other-improvements-and-fixes"></a>Other improvements and fixes
 
+- `Pester.BeforeContainer.ps1` is applied when only discovery runs, `Run.SkipRun`. That is the
+  path the VS Code Test Explorer uses to populate, and it went through a batch discovery that
+  never got the per container map, so a file whose discovery depends on the setup, one that
+  calls a helper to build `-ForEach` data for example, came back with no tests or failed with
+  `The term '...' is not recognized`.
 - The `Run.Parallel` help no longer claims that enabling `CodeCoverage` falls back to a
   sequential run. It has not since workers started measuring their own file and the parent
   started merging the hits. The fallback that was actually missing from the list is now there,
diff --git a/src/Pester.Runtime.ps1 b/src/Pester.Runtime.ps1
index 6ae355fb1..6f97e91ad 100644
--- a/src/Pester.Runtime.ps1
+++ b/src/Pester.Runtime.ps1
@@ -1,4 +1,4 @@
-# PESTER_BUILD
+# PESTER_BUILD
 if (-not (Get-Variable -Name "PESTER_BUILD" -ValueOnly -ErrorAction Ignore)) {
     . "$PSScriptRoot/Pester.Utility.ps1"
     . "$PSScriptRoot/functions/Pester.SafeCommands.ps1"
@@ -126,7 +126,8 @@ function Find-Test {
         [PSObject[]] $BlockContainer,
         $Filter,
         [Parameter(Mandatory = $true)]
-        [Management.Automation.SessionState] $SessionState
+        [Management.Automation.SessionState] $SessionState,
+        [System.Collections.IDictionary] $BeforeContainerInit
     )
 
     if ($PesterPreference.Debug.WriteDebugMessages.Value) {
@@ -140,7 +141,7 @@ function Find-Test {
         $state = New-PesterState
     }
 
-    $found = Discover-Test -BlockContainer $BlockContainer -Filter $Filter -SessionState $SessionState
+    $found = Discover-Test -BlockContainer $BlockContainer -Filter $Filter -SessionState $SessionState -BeforeContainerInit $BeforeContainerInit
 
     foreach ($f in $found) {
         ConvertTo-DiscoveredBlockContainer -Block $f
@@ -1240,6 +1241,25 @@ function Invoke-ContainerRun {
     $result
 }
 
+function Get-BeforeContainerFile {
+    # Which Pester.BeforeContainer.ps1 files apply to this container, outermost first. The map is
+    # keyed by container path and built once per run by Get-PesterBeforeContainerMap, because which
+    # files apply depends on where the container is. A non-file container (a scriptblock) keys on ''.
+    [CmdletBinding()]
+    param (
+        [Parameter(Mandatory = $true)]
+        $Container,
+        [System.Collections.IDictionary] $BeforeContainerInit
+    )
+
+    if ($null -eq $BeforeContainerInit) {
+        return @()
+    }
+
+    $containerKey = if ('File' -eq $Container.Type) { $Container.Item.FullName } else { '' }
+    @($BeforeContainerInit[$containerKey])
+}
+
 function Discover-Test {
     [CmdletBinding()]
     param (
@@ -1247,7 +1267,10 @@ function Discover-Test {
         [PSObject[]] $BlockContainer,
         [Parameter(Mandatory = $true)]
         [Management.Automation.SessionState] $SessionState,
-        $Filter
+        $Filter,
+        # Pester.BeforeContainer.ps1 files per container, keyed by container path. Same map the
+        # interleaved discover -> run path uses, see Invoke-Test.
+        [System.Collections.IDictionary] $BeforeContainerInit
     )
     $totalDiscoveryDuration = [Diagnostics.Stopwatch]::StartNew()
 
@@ -1265,7 +1288,8 @@ function Discover-Test {
 
     $state.Discovery = $true
     $found = foreach ($container in $BlockContainer) {
-        Invoke-ContainerDiscovery -Container $container -Filter $Filter -SessionState $SessionState
+        $containerSetupFiles = Get-BeforeContainerFile -Container $container -BeforeContainerInit $BeforeContainerInit
+        Invoke-ContainerDiscovery -Container $container -Filter $Filter -SessionState $SessionState -BeforeContainerFile $containerSetupFiles
     }
 
     $steps = $state.Plugin.DiscoveryEnd
@@ -2179,7 +2203,7 @@ function Invoke-Test {
         # Discovery-only mode (e.g. populating the VS Code Test Explorer). Run a full
         # batch discovery over all containers and return the discovered tree without
         # executing anything.
-        $found = Discover-Test -BlockContainer $BlockContainer -Filter $Filter -SessionState $SessionState
+        $found = Discover-Test -BlockContainer $BlockContainer -Filter $Filter -SessionState $SessionState -BeforeContainerInit $BeforeContainerInit
 
         foreach ($f in $found) {
             ConvertTo-DiscoveredBlockContainer -Block $f
@@ -2218,16 +2242,7 @@ function Invoke-Test {
     $executedContainers = foreach ($container in $BlockContainer) {
         $containerIndex++
 
-        # Named apart from the $BeforeContainerInit parameter on purpose. PowerShell variable names
-        # are case-insensitive, so a local $beforeContainerInit would assign onto the typed
-        # [IDictionary] parameter and fail to convert.
-        $containerSetupFiles = if ($null -ne $BeforeContainerInit) {
-            $containerKey = if ('File' -eq $container.Type) { $container.Item.FullName } else { '' }
-            @($BeforeContainerInit[$containerKey])
-        }
-        else {
-            @()
-        }
+        $containerSetupFiles = Get-BeforeContainerFile -Container $container -BeforeContainerInit $BeforeContainerInit
 
         # --- discover this container ---
         $state.Discovery = $true
diff --git a/tst/Pester.RSpec.Parallel.ts.ps1 b/tst/Pester.RSpec.Parallel.ts.ps1
index 47ad6dad2..52b2aefbc 100644
--- a/tst/Pester.RSpec.Parallel.ts.ps1
+++ b/tst/Pester.RSpec.Parallel.ts.ps1
@@ -151,6 +151,23 @@ Describe 'Docs' {
     $root
 }
 
+function New-DiscoveryTimeBeforeContainerFolder {
+    # The setup defines the -ForEach data in BeforeDiscovery, so the file discovers 3 tests only
+    # when the chain was applied. Without it discovery finds 0, which is what #3008 was about.
+    $root = Join-Path ([IO.Path]::GetTempPath()) ([Guid]::NewGuid().Guid)
+    $tests = Join-Path $root 'tests'
+    $null = New-Item -ItemType Directory -Path $tests -Force
+
+    Set-Content -Path (Join-Path $root 'Pester.BeforeContainer.ps1') -Value 'BeforeDiscovery { $script:Cases = 1..3 }'
+    Set-Content -Path (Join-Path $tests 'Some.Tests.ps1') -Value @'
+Describe 'd' {
+    It 'case <_>' -ForEach $Cases { }
+}
+'@
+
+    $root
+}
+
 i -PassThru:$PassThru {
     b "Run.Parallel configuration option" {
         t "exists and defaults to disabled" {
@@ -439,6 +456,29 @@ Describe 'Second' {
             finally { Remove-Item -Path $folder -Recurse -Force }
         }
 
+        t "applies the chain when only discovery runs, so Run.SkipRun sees the same tests as a run" {
+            # Run.SkipRun is the path the VS Code Test Explorer uses to populate. It went through
+            # a batch discovery that never got the map, so a file whose discovery depends on the
+            # setup came back empty. (#3008)
+            $folder = New-DiscoveryTimeBeforeContainerFolder
+            try {
+                $c = [PesterConfiguration]::Default
+                $c.Run.Path = $folder
+                $c.Run.RepoRoot = $folder
+                $c.Run.SkipRun = $true
+                $c.Run.PassThru = $true
+                $c.Output.Verbosity = 'None'
+                $discoveryOnly = Invoke-Pester -Configuration $c
+
+                $c.Run.SkipRun = $false
+                $normal = Invoke-Pester -Configuration $c
+
+                $discoveryOnly.Tests.Count | Verify-Equal 3
+                $discoveryOnly.Tests.Count | Verify-Equal $normal.Tests.Count
+            }
+            finally { Remove-Item -Path $folder -Recurse -Force }
+        }
+
         t "does not overwrite a Run.RepoRoot the user set" {
             # A real directory. Resolving the chain runs the value through GetFullPath, and a made
             # up path is not portable: on Windows something like 'TestDrive:whatever' reads as a

From 85d37c8e1bf51e102b7ebd777f5f30536459ddad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Jare=C5=A1?= <me@jakubjares.com>
Date: Sat, 5 Sep 2026 10:37:45 +0200
Subject: [PATCH 2/3] Drop the release note entry, notes are written in one
 pass now
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

See #3026. This PR appending to the shared list is what causes the conflicts.

🤖
---
 docs/NEXT-RELEASE.md | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/docs/NEXT-RELEASE.md b/docs/NEXT-RELEASE.md
index cab66f6fd..40d85d43b 100644
--- a/docs/NEXT-RELEASE.md
+++ b/docs/NEXT-RELEASE.md
@@ -449,11 +449,6 @@ Three of these come with the `Pester.BeforeContainer.ps1` cascade above.
   `Cannot convert "PesterConfigurationDeserializer" from String to Type`. The reference is on
   7.4.0 now, the baseline of the 7.4 line, so it loads on every 7.4.x. This affected 6.0.0 and
   6.1.0.
-- `Pester.BeforeContainer.ps1` is applied when only discovery runs, `Run.SkipRun`. That is the
-  path the VS Code Test Explorer uses to populate, and it went through a batch discovery that
-  never got the per container map, so a file whose discovery depends on the setup, one that
-  calls a helper to build `-ForEach` data for example, came back with no tests or failed with
-  `The term '...' is not recognized`.
 - The `Run.Parallel` help no longer claims that enabling `CodeCoverage` falls back to a
   sequential run. It has not since workers started measuring their own file and the parent
   started merging the hits. The fallback that was actually missing from the list is now there,

From 1498975f678265f1d048b1a6650564a7ad0bee80 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Jare=C5=A1?= <me@jakubjares.com>
Date: Sat, 5 Sep 2026 10:49:36 +0200
Subject: [PATCH 3/3] Report which Pester.BeforeContainer.ps1 files applied to
 a container

A container's setup comes from every Pester.BeforeContainer.ps1 between Run.RepoRoot and
the test file's own folder, and nothing in the result said which ones were used. That
makes "where did this function come from" unanswerable from the outside: opening
tests/unit/Foo.Tests.ps1 shows no BeforeAll and gives no sign that two folder setups ran
before it. Reading the directory tree is not enough either, because #pester:no-inherit
can cut the chain short.

The applied files are on the container now, outermost first, matching the order they ran
in. On the container rather than the block, because it is a property of the file being
run, and post-processors already walk containers.

Fix #3007
---
 src/Pester.Runtime.ps1           |  5 ++++
 src/csharp/Pester/Block.cs       |  4 +++
 src/csharp/Pester/Container.cs   |  6 +++-
 tst/Pester.RSpec.Parallel.ts.ps1 | 48 ++++++++++++++++++++++++++++++++
 4 files changed, 62 insertions(+), 1 deletion(-)

diff --git a/src/Pester.Runtime.ps1 b/src/Pester.Runtime.ps1
index 6f97e91ad..bfee2b8d2 100644
--- a/src/Pester.Runtime.ps1
+++ b/src/Pester.Runtime.ps1
@@ -1029,6 +1029,11 @@ function Invoke-ContainerDiscovery {
     # set correctly as if we provided -Data to New-Block
     $root.Data = $Container.Data
 
+    # Record which Pester.BeforeContainer.ps1 files applied, so the result says where a
+    # container's setup came from. The folder tree alone does not answer it, #pester:no-inherit
+    # can cut the chain short.
+    $root.BeforeContainerFile = [System.Collections.Generic.List[string]]@($BeforeContainerFile)
+
     Reset-PerContainerState -RootBlock $root
 
     $steps = $state.Plugin.ContainerDiscoveryStart
diff --git a/src/csharp/Pester/Block.cs b/src/csharp/Pester/Block.cs
index a6b50f609..764db6386 100644
--- a/src/csharp/Pester/Block.cs
+++ b/src/csharp/Pester/Block.cs
@@ -57,6 +57,10 @@ public Block()
         public string ItemType { get; } = "Block";
 
         public ContainerInfo BlockContainer { get; set; }
+        // Every Pester.BeforeContainer.ps1 that applied to this container, outermost first.
+        // Reading the folder tree is not enough to work this out, because #pester:no-inherit can
+        // cut the chain short.
+        public List<string> BeforeContainerFile { get; set; } = new List<string>();
         public object Root { get; set; }
         public bool IsRoot { get; set; }
         public object Parent { get; set; }
diff --git a/src/csharp/Pester/Container.cs b/src/csharp/Pester/Container.cs
index b3532fe11..2a1ec46c2 100644
--- a/src/csharp/Pester/Container.cs
+++ b/src/csharp/Pester/Container.cs
@@ -34,7 +34,8 @@ public static Container CreateFromBlock (Block block) {
                 Item = block.BlockContainer.Item,
                 Blocks = block.Blocks,
                 Data = block.Data,
-                StandardOutput = block.StandardOutput
+                StandardOutput = block.StandardOutput,
+                BeforeContainerFile = block.BeforeContainerFile
         };
         }
 
@@ -56,6 +57,9 @@ public string Type
         }
         public object Item { get; set; }
         public object Data { get; set; }
+        // Every Pester.BeforeContainer.ps1 that applied to this container, outermost first, so
+        // "where did this function come from" is answerable from the result object.
+        public List<string> BeforeContainerFile { get; set; } = new List<string>();
         public List<Block> Blocks { get; set; } = new List<Block>();
         public string Result { get; set; } = "NotRun";
         public TimeSpan Duration { get => DiscoveryDuration + UserDuration + FrameworkDuration; }
diff --git a/tst/Pester.RSpec.Parallel.ts.ps1 b/tst/Pester.RSpec.Parallel.ts.ps1
index 52b2aefbc..ffd635079 100644
--- a/tst/Pester.RSpec.Parallel.ts.ps1
+++ b/tst/Pester.RSpec.Parallel.ts.ps1
@@ -479,6 +479,54 @@ Describe 'Second' {
             finally { Remove-Item -Path $folder -Recurse -Force }
         }
 
+        t "reports which Pester.BeforeContainer.ps1 files applied to each container" {
+            # The folder tree alone does not answer this, #pester:no-inherit can cut the chain
+            # short, so the applied files are on the container. (#3007)
+            $folder = New-CascadingBeforeContainerFolder
+            try {
+                $c = [PesterConfiguration]::Default
+                $c.Run.Path = $folder
+                $c.Run.RepoRoot = $folder
+                $c.Run.PassThru = $true
+                $c.Output.Verbosity = 'None'
+                $r = Invoke-Pester -Configuration $c
+
+                $r.FailedCount | Verify-Equal 0
+
+                $unit = $r.Containers | Where-Object { $_.Item.FullName -like '*unit*' }
+                $integration = $r.Containers | Where-Object { $_.Item.FullName -like '*integration*' }
+
+                # unit sees root + tests + unit, integration sees root + tests, outermost first.
+                $unit.BeforeContainerFile.Count | Verify-Equal 3
+                $integration.BeforeContainerFile.Count | Verify-Equal 2
+                (Split-Path $unit.BeforeContainerFile[0] -Parent) | Verify-Equal $folder
+            }
+            finally { Remove-Item -Path $folder -Recurse -Force }
+        }
+
+        t "reports only the files that survived #pester:no-inherit" {
+            $folder = New-NoInheritBeforeContainerFolder
+            try {
+                $c = [PesterConfiguration]::Default
+                $c.Run.Path = $folder
+                $c.Run.RepoRoot = $folder
+                $c.Run.PassThru = $true
+                $c.Output.Verbosity = 'None'
+                $r = Invoke-Pester -Configuration $c
+
+                $r.FailedCount | Verify-Equal 0
+
+                $docs = $r.Containers | Where-Object { $_.Item.FullName -like '*docs*' }
+                $normal = $r.Containers | Where-Object { $_.Item.FullName -notlike '*docs*' }
+
+                # docs cut the chain, so it reports only its own file, not the root one.
+                $docs.BeforeContainerFile.Count | Verify-Equal 1
+                $normal.BeforeContainerFile.Count | Verify-Equal 1
+                (Split-Path $docs.BeforeContainerFile[0] -Parent) | Verify-Equal (Join-Path $folder 'docs')
+            }
+            finally { Remove-Item -Path $folder -Recurse -Force }
+        }
+
         t "does not overwrite a Run.RepoRoot the user set" {
             # A real directory. Resolving the chain runs the value through GetFullPath, and a made
             # up path is not portable: on Windows something like 'TestDrive:whatever' reads as a