Fix BeforeEvery/AfterEvery hooks for Class and Assembly not being executed

[Copilot]

[BeforeEvery(Class)], [BeforeEvery(Assembly)], [AfterEvery(Class)], and [AfterEvery(Assembly)] hooks were silently never invoked, while the Test and TestSession variants worked fine.

Root cause

HookExecutor already had the correct pattern for Test-level hooks — collecting and executing both BeforeEvery(Test) and Before(Test) hooks in sequence. The Class and Assembly methods only called CollectBefore{Class,Assembly}HooksAsync and never called the corresponding CollectBeforeEvery* / CollectAfterEvery* methods. The hooks were registered and built correctly in both the source generator and reflection paths; only the execution callsite was missing.

Changes

• ExecuteBeforeClassHooksAsync / ExecuteBeforeAssemblyHooksAsync: now execute BeforeEvery(*) hooks before Before(*) hooks
• ExecuteAfterClassHooksAsync / ExecuteAfterAssemblyHooksAsync: now execute After(*) hooks before AfterEvery(*) hooks (cleanup in reverse order)

Follows the identical pattern already established by ExecuteBeforeTestHooksAsync / ExecuteAfterTestHooksAsync.

Regression Tests

Added integration tests to ensure all four hook types are properly executed:

• TUnit.TestProject/BeforeTests/BeforeEveryClassTests.cs: [BeforeEvery(Class)] hook sets a StateBag flag; test verifies it was set
• TUnit.TestProject/BeforeTests/BeforeEveryAssemblyTests.cs: [BeforeEvery(Assembly)] hook sets a StateBag flag; test verifies it was set
• TUnit.TestProject/AfterTests/AfterEveryClassTests.cs: [AfterEvery(Class)] hook writes a file as proof of execution
• TUnit.TestProject/AfterTests/AfterEveryAssemblyTests.cs: [AfterEvery(Assembly)] hook writes a file as proof of execution
• TUnit.Engine.Tests/BeforeEveryClassHookTests.cs / BeforeEveryAssemblyHookTests.cs: integration test runners that execute filtered tests and assert 1 passed / 0 failed
• TUnit.Engine.Tests/AfterEveryClassHookTests.cs / AfterEveryAssemblyHookTests.cs: integration test runners that validate tests pass and hook files were created

Original prompt

---

This section details on the original issue you should resolve

<issue_title>[Bug]: BeforeEvery/AfterEvery For Class/Assembly are not executed</issue_title>
<issue_description>### Description

Methods marked by these attributes are not executed:

    [BeforeEvery(Class)]
    [BeforeEvery(Assembly)]
    [AfterEvery(Class)]
    [AfterEvery(Assembly)]

While other attributes are working correctly ([BeforeEvery(Test)], [BeforeEvery(TestSession)]).

See test for BeforeEvery in "Steps to reproduce".
Unfortunately, I don't know how to test AfterEvery.

Expected Behavior

I expected methods to be invoked and test to pass.

Actual Behavior

Methods are not invoked, tests fail

Steps to Reproduce

Full Test for BeforeEvery:

namespace TUNIT_tmp;

public class BeforeEveryTests
{
    //ok
    [Test]
    public async Task BeforeEveryTest__should_be__executed()
    {
        await Assert.That(GlobalHooks.BeforeEveryTest)
            .IsTrue();
    }

    //fails
    [Test]
    public async Task BeforeEveryClass__should_be__executed()
    {
        await Assert.That(GlobalHooks.BeforeEveryClass)
            .IsTrue();
    }

    //fails
    [Test]
    public async Task BeforeEveryAssembly__should_be__executed()
    {
        await Assert.That(GlobalHooks.BeforeEveryAssembly)
            .IsTrue();
    }

    //ok
    [Test]
    public async Task BeforeSessionExecuted__should_be__executed()
    {
        await Assert.That(GlobalHooks.BeforeSessionExecuted)
            .IsTrue();
    }
}

public class GlobalHooks
{
    public static bool BeforeEveryTest {get; private set; }
    public static bool BeforeEveryClass {get; private set; }
    public static bool BeforeEveryAssembly {get; private set; }
    public static bool BeforeSessionExecuted {get; private set; }

    [BeforeEvery(Test)]
    public static Task BeforeT(TestContext ctx, CancellationToken cancellationToken)
    {
        BeforeEveryTest = true;
        return Task.CompletedTask;
    }

    [BeforeEvery(Class)]
    public static Task BeforeC(ClassHookContext ctx, CancellationToken cancellationToken)
    {
        BeforeEveryClass = true;
        return Task.CompletedTask;
    }
    
    [BeforeEvery(Assembly)]
    public static Task BeforeA(AssemblyHookContext ctx, CancellationToken cancellationToken)
    {
        BeforeEveryAssembly = true;
        return Task.CompletedTask;
    }

    [BeforeEvery(TestSession)]
    public static Task BeforeS(TestSessionContext ctx, CancellationToken cancellationToken)
    {
        BeforeSessionExecuted = true;
        return Task.CompletedTask;
    }
}

TUnit Version

1.21.6

.NET Version

Net 10

Operating System

Linux

IDE / Test Runner

dotnet CLI (dotnet test / dotnet run)

Error Output / Stack Trace

Additional Context

No response

IDE-Specific Issue?

• I've confirmed this issue occurs when running via dotnet test or dotnet run, not just in my IDE</issue_description>

Comments on the Issue (you are @copilot in this section)

• Fixes [Bug]: BeforeEvery/AfterEvery For Class/Assembly are not executed #5238

---

📍 Connect Copilot coding agent with Jira, Azure Boards or Linear to delegate work to Copilot in one click without leaving your project management tool.

[thomhurst]

@copilot we need tests to ensure this never regresses

[Copilot]

@copilot we need tests to ensure this never regresses

Added 8 regression test files in c538686:

TUnit.TestProject (test targets):

• BeforeEveryClassTests.cs — [BeforeEvery(Class)] hook sets a StateBag flag; test asserts it
• BeforeEveryAssemblyTests.cs — [BeforeEvery(Assembly)] hook sets a StateBag flag; test asserts it
• AfterEveryClassTests.cs — [AfterEvery(Class)] hook writes a file as proof of execution
• AfterEveryAssemblyTests.cs — [AfterEvery(Assembly)] hook writes a file as proof of execution

TUnit.Engine.Tests (integration test runners):

• BeforeEveryClassHookTests.cs — runs filtered test, asserts 1 passed / 0 failed
• BeforeEveryAssemblyHookTests.cs — same pattern for assembly hooks
• AfterEveryClassHookTests.cs — asserts test passes and hook file was created
• AfterEveryAssemblyHookTests.cs — asserts test passes and hook file was created

These follow the same patterns as the existing TestSessionBeforeHookTests / TestSessionAfterHookTests.

[claude]

Review: Fix BeforeEvery/AfterEvery hooks for Class and Assembly

The fix is correct and follows the existing pattern established for ExecuteBeforeTestHooksAsync / ExecuteAfterTestHooksAsync. The root cause was clearly identified — missing CollectBeforeEvery* / CollectAfterEvery* call sites — and the regression tests adequately cover the previously broken paths.

Primary Concern: Code Duplication in HookExecutor.cs

The main architectural issue is that this PR copies the same 12-line try/catch block four times across ExecuteBeforeClassHooksAsync and ExecuteBeforeAssemblyHooksAsync:

catch (Exception ex)
{
    if (ex is SkipTestException) { throw; }
    if (ex.InnerException is SkipTestException skipEx)
    {
        ExceptionDispatchInfo.Capture(skipEx).Throw();
    }
    throw new BeforeClassException($"... hook failed: {ex.Message}", ex);
}

This pattern already existed once in the BeforeTest variant and is now duplicated three more times. The concern is maintainability: any future change to this pattern (e.g., adding a new exception type, changing wrapping behaviour) must be made in all four places. A private helper method would consolidate this:

private static async ValueTask ExecuteBeforeHookWithSkipHandling<TException>(
    Func<ValueTask> execute,
    Func<string, Exception, TException> wrapException)
    where TException : Exception
{
    try { await execute().ConfigureAwait(false); }
    catch (Exception ex)
    {
        if (ex is SkipTestException) throw;
        if (ex.InnerException is SkipTestException skipEx)
            ExceptionDispatchInfo.Capture(skipEx).Throw();
        throw wrapException($"hook failed: {ex.Message}", ex);
    }
}

This isn't blocking — the current duplication was already present for the Test variant before this PR — but it's worth addressing either here or as a follow-up to prevent the pattern from spreading further.

Minor Observations

Test isolation for BeforeEveryAssembly: The BeforeEveryAssemblyHooks iterates context.AllTests (all tests in the assembly) and filters by exact test name. This works today but is brittle if the test is renamed without updating the hook. A better design in tests is to scope the filter by class name or use a dedicated attribute/tag rather than string-matching test names.

AfterEvery file-system side-channel: Using File.WriteAllTextAsync with a GUID filename is an acceptable trade-off for verifying AfterEvery execution (since the hook runs after the test's assertion window closes). It would be worth noting that these files are never cleaned up — if this is a concern in CI environments, a cleanup step may be needed.

Removal of the empty-collection early return in ExecuteAfterClassHooksAsync / ExecuteAfterAssemblyHooksAsync: The original code returned early with FinishClassActivity(hasErrors: false) when the hooks collection was empty. The new code doesn't have this early return, but FinishClassActivity / FinishAssemblyActivity is still called at the bottom unconditionally — so this is fine and actually cleaner.

Summary

The bug fix is correct and well-tested. The main suggestion is to extract the repeated SkipTestException-handling try/catch into a helper to prevent further duplication, ideally as a follow-up since this pattern predates the PR.