Implement proper hook timeout functionality with event receiver pattern

- Fix TimeoutAttribute.OnHookRegistered to actually set timeout on context
- Extend HookRegisteredContext to support both static and instance hook methods
- Update hook method classes to use settable timeout property instead of direct attribute access
- Add hook registration event receiver infrastructure to EventReceiverOrchestrator
- Modify HookCollectionService to trigger hook registration events during delegate creation
- Reorder service initialization to inject EventReceiverOrchestrator into HookCollectionService

This implementation follows the established event receiver pattern used for tests,
ensuring that TimeoutAttribute and other hook attributes can modify hook properties
during registration rather than relying on direct attribute access.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: claude[bot]

TUnit.Core/Attributes/TestMetadata/TimeoutAttribute.cs

@@ -53,8 +53,7 @@ public ValueTask OnTestDiscovered(DiscoveredTestContext context)
     /// <inheritdoc />
     public ValueTask OnHookRegistered(HookRegisteredContext context)
     {
-        // Apply timeout to the hook method
-        // This will be used by the hook execution infrastructure
+        context.Timeout = Timeout;
         return default(ValueTask);
     }
 }

TUnit.Core/Contexts/HookRegisteredContext.cs

@@ -7,11 +7,32 @@ namespace TUnit.Core;
 /// </summary>
 public class HookRegisteredContext
 {
-    public StaticHookMethod HookMethod { get; }
-    public string HookName => HookMethod.Name;
+    private readonly object _hookMethod;
+    private readonly string _hookName;
+    private TimeSpan? _timeout;
+
+    public StaticHookMethod? StaticHookMethod => _hookMethod as StaticHookMethod;
+    public InstanceHookMethod? InstanceHookMethod => _hookMethod as InstanceHookMethod;
+    public string HookName => _hookName;
+    
+    /// <summary>
+    /// Gets or sets the timeout for this hook
+    /// </summary>
+    public TimeSpan? Timeout
+    {
+        get => _timeout;
+        set => _timeout = value;
+    }
 
     public HookRegisteredContext(StaticHookMethod hookMethod)
     {
-        HookMethod = hookMethod;
+        _hookMethod = hookMethod;
+        _hookName = hookMethod.Name;
+    }
+    
+    public HookRegisteredContext(InstanceHookMethod hookMethod)
+    {
+        _hookMethod = hookMethod;
+        _hookName = hookMethod.Name;
     }
 }

TUnit.Core/Hooks/InstanceHookMethod.cs

@@ -22,7 +22,11 @@ public record InstanceHookMethod : IExecutableHook<TestContext>
 
     public TAttribute? GetAttribute<TAttribute>() where TAttribute : Attribute => Attributes.OfType<TAttribute>().FirstOrDefault();
 
-    public TimeSpan? Timeout => GetAttribute<TimeoutAttribute>()?.Timeout ?? TimeSpan.FromMinutes(5);
+    /// <summary>
+    /// Gets or sets the timeout for this hook method. This will be set during hook registration
+    /// by the event receiver infrastructure, falling back to the default 5-minute timeout.
+    /// </summary>
+    public TimeSpan? Timeout { get; internal set; } = TimeSpan.FromMinutes(5);
 
     public required IHookExecutor HookExecutor { get; init; }
 

TUnit.Core/Hooks/StaticHookMethod.cs

@@ -32,7 +32,11 @@ public abstract record StaticHookMethod
 
     public TAttribute? GetAttribute<TAttribute>() where TAttribute : Attribute => Attributes.OfType<TAttribute>().FirstOrDefault();
 
-    public TimeSpan? Timeout => GetAttribute<TimeoutAttribute>()?.Timeout ?? TimeSpan.FromMinutes(5);
+    /// <summary>
+    /// Gets the timeout for this hook method. This will be set during hook registration
+    /// by the event receiver infrastructure, falling back to the default 5-minute timeout.
+    /// </summary>
+    public TimeSpan? Timeout { get; internal set; } = TimeSpan.FromMinutes(5);
 
     public required IHookExecutor HookExecutor { get; init; }
 

TUnit.Engine/Framework/TUnitServiceProvider.cs

@@ -86,14 +86,14 @@ public TUnitServiceProvider(IExtension extension,
 
         CancellationToken = Register(new EngineCancellationToken());
 
-        HookCollectionService = Register<IHookCollectionService>(new HookCollectionService());
+        EventReceiverOrchestrator = Register(new EventReceiverOrchestrator(Logger));
+        HookCollectionService = Register<IHookCollectionService>(new HookCollectionService(EventReceiverOrchestrator));
 
         ParallelLimitLockProvider = Register(new ParallelLimitLockProvider());
 
         ContextProvider = Register(new ContextProvider(this, TestSessionId, Filter?.ToString()));
 
         HookOrchestrator = Register(new HookOrchestrator(HookCollectionService, Logger, ContextProvider, this));
-        EventReceiverOrchestrator = Register(new EventReceiverOrchestrator(Logger));
 
         // Detect execution mode from command line or environment
         var useSourceGeneration = GetUseSourceGeneration(CommandLineOptions);

TUnit.Engine/Services/EventReceiverOrchestrator.cs

@@ -197,6 +197,58 @@ public async ValueTask InvokeTestDiscoveryEventReceiversAsync(TestContext contex
         }
     }
 
+    public async ValueTask InvokeHookRegistrationEventReceiversAsync(HookRegisteredContext hookContext, CancellationToken cancellationToken)
+    {
+        // Get event receivers from the hook method's attributes
+        IEnumerable<Attribute> attributes;
+        
+        if (hookContext.StaticHookMethod != null)
+        {
+            attributes = hookContext.StaticHookMethod.Attributes;
+        }
+        else if (hookContext.InstanceHookMethod != null)
+        {
+            attributes = hookContext.InstanceHookMethod.Attributes;
+        }
+        else
+        {
+            return; // No hook method to process
+        }
+
+        var eventReceivers = attributes
+            .OfType<IHookRegisteredEventReceiver>()
+            .OrderBy(r => r.Order)
+            .ToList();
+
+        // Filter scoped attributes to ensure only the highest priority one of each type is invoked
+        var filteredReceivers = ScopedAttributeFilter.FilterScopedAttributes(eventReceivers);
+
+        foreach (var receiver in filteredReceivers.OrderBy(r => r.Order))
+        {
+            try
+            {
+                await receiver.OnHookRegistered(hookContext);
+            }
+            catch (Exception ex)
+            {
+                await _logger.LogErrorAsync($"Error in hook registration event receiver: {ex.Message}");
+            }
+        }
+
+        // Apply the timeout from the context back to the hook method
+        if (hookContext.Timeout.HasValue)
+        {
+            if (hookContext.StaticHookMethod != null)
+            {
+                hookContext.StaticHookMethod.Timeout = hookContext.Timeout;
+            }
+            else if (hookContext.InstanceHookMethod != null)
+            {
+                hookContext.InstanceHookMethod.Timeout = hookContext.Timeout;
+            }
+        }
+    }
+
 
     // First/Last event methods with fast-path checks
     [MethodImpl(MethodImplOptions.AggressiveInlining)]

TUnit.Engine/Services/HookCollectionService.cs

@@ -9,6 +9,7 @@ namespace TUnit.Engine.Services;
 
 internal sealed class HookCollectionService : IHookCollectionService
 {
+    private readonly EventReceiverOrchestrator _eventReceiverOrchestrator;
     private readonly ConcurrentDictionary<Type, IReadOnlyList<Func<TestContext, CancellationToken, Task>>> _beforeTestHooksCache = new();
     private readonly ConcurrentDictionary<Type, IReadOnlyList<Func<TestContext, CancellationToken, Task>>> _afterTestHooksCache = new();
     private readonly ConcurrentDictionary<Type, IReadOnlyList<Func<TestContext, CancellationToken, Task>>> _beforeEveryTestHooksCache = new();
@@ -19,6 +20,48 @@ internal sealed class HookCollectionService : IHookCollectionService
     // Cache for complete hook chains to avoid repeated lookups
     private readonly ConcurrentDictionary<Type, CompleteHookChain> _completeHookChainCache = new();
 
+    // Cache for processed hooks to avoid re-processing event receivers
+    private readonly ConcurrentDictionary<object, bool> _processedHooks = new();
+
+    public HookCollectionService(EventReceiverOrchestrator eventReceiverOrchestrator)
+    {
+        _eventReceiverOrchestrator = eventReceiverOrchestrator;
+    }
+
+    private async Task ProcessHookRegistrationAsync(object hookMethod, CancellationToken cancellationToken = default)
+    {
+        // Only process each hook once
+        if (!_processedHooks.TryAdd(hookMethod, true))
+        {
+            return;
+        }
+
+        try
+        {
+            HookRegisteredContext context;
+            
+            if (hookMethod is StaticHookMethod staticHook)
+            {
+                context = new HookRegisteredContext(staticHook);
+            }
+            else if (hookMethod is InstanceHookMethod instanceHook)
+            {
+                context = new HookRegisteredContext(instanceHook);
+            }
+            else
+            {
+                return; // Unknown hook type
+            }
+
+            await _eventReceiverOrchestrator.InvokeHookRegistrationEventReceiversAsync(context, cancellationToken);
+        }
+        catch (Exception)
+        {
+            // Ignore errors during hook registration event processing to avoid breaking hook execution
+            // The EventReceiverOrchestrator already logs errors internally
+        }
+    }
+    
     private sealed class CompleteHookChain
     {
         public IReadOnlyList<Func<TestContext, CancellationToken, Task>> BeforeTestHooks { get; init; } = [
@@ -51,7 +94,7 @@ public ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Coll
                 {
                     foreach (var hook in sourceHooks)
                     {
-                        var hookFunc = CreateInstanceHookDelegate(hook);
+                        var hookFunc = await CreateInstanceHookDelegateAsync(hook);
                         typeHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
                     }
                 }
@@ -64,7 +107,7 @@ public ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Coll
                     {
                         foreach (var hook in openTypeHooks)
                         {
-                            var hookFunc = CreateInstanceHookDelegate(hook);
+                            var hookFunc = await CreateInstanceHookDelegateAsync(hook);
                             typeHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
                         }
                     }
@@ -111,7 +154,7 @@ public ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Coll
                 {
                     foreach (var hook in sourceHooks)
                     {
-                        var hookFunc = CreateInstanceHookDelegate(hook);
+                        var hookFunc = await CreateInstanceHookDelegateAsync(hook);
                         typeHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
                     }
                 }
@@ -124,7 +167,7 @@ public ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Coll
                     {
                         foreach (var hook in openTypeHooks)
                         {
-                            var hookFunc = CreateInstanceHookDelegate(hook);
+                            var hookFunc = await CreateInstanceHookDelegateAsync(hook);
                             typeHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
                         }
                     }
@@ -163,7 +206,7 @@ public ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Coll
             // Collect all global BeforeEvery hooks
             foreach (var hook in Sources.BeforeEveryTestHooks)
             {
-                var hookFunc = CreateStaticHookDelegate(hook);
+                var hookFunc = await CreateStaticHookDelegateAsync(hook);
                 allHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
             }
 
@@ -186,7 +229,7 @@ public ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Coll
             // Collect all global AfterEvery hooks
             foreach (var hook in Sources.AfterEveryTestHooks)
             {
-                var hookFunc = CreateStaticHookDelegate(hook);
+                var hookFunc = await CreateStaticHookDelegateAsync(hook);
                 allHooks.Add((hook.Order, hook.RegistrationIndex, hookFunc));
             }
 
@@ -513,8 +556,11 @@ public ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task
         return new ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task>>>(hooks);
     }
 
-    private static Func<TestContext, CancellationToken, Task> CreateInstanceHookDelegate(InstanceHookMethod hook)
+    private async Task<Func<TestContext, CancellationToken, Task>> CreateInstanceHookDelegateAsync(InstanceHookMethod hook)
     {
+        // Process hook registration event receivers
+        await ProcessHookRegistrationAsync(hook);
+        
         return async (context, cancellationToken) =>
         {
             var timeoutAction = HookTimeoutHelper.CreateTimeoutHookAction(
@@ -528,8 +574,11 @@ private static Func<TestContext, CancellationToken, Task> CreateInstanceHookDele
         };
     }
 
-    private static Func<TestContext, CancellationToken, Task> CreateStaticHookDelegate(StaticHookMethod<TestContext> hook)
+    private async Task<Func<TestContext, CancellationToken, Task>> CreateStaticHookDelegateAsync(StaticHookMethod<TestContext> hook)
     {
+        // Process hook registration event receivers
+        await ProcessHookRegistrationAsync(hook);
+        
         return async (context, cancellationToken) =>
         {
             var timeoutAction = HookTimeoutHelper.CreateTimeoutHookAction(