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 />
 publicValueTaskOnHookRegistered(HookRegisteredContextcontext)
 {
-// Apply timeout to the hook method
-// This will be used by the hook execution infrastructure
+context.Timeout=Timeout;
 returndefault(ValueTask);
 }
 }

TUnit.Core/Contexts/HookRegisteredContext.cs

@@ -7,11 +7,32 @@ namespace TUnit.Core;
 /// </summary>
 publicclassHookRegisteredContext
 {
-publicStaticHookMethodHookMethod{get;}
-publicstringHookName=>HookMethod.Name;
+privatereadonlyobject_hookMethod;
+privatereadonlystring_hookName;
+privateTimeSpan?_timeout;
+
+publicStaticHookMethod?StaticHookMethod=>_hookMethodasStaticHookMethod;
+publicInstanceHookMethod?InstanceHookMethod=>_hookMethodasInstanceHookMethod;
+publicstringHookName=>_hookName;
+
+/// <summary>
+/// Gets or sets the timeout for this hook
+/// </summary>
+publicTimeSpan?Timeout
+{
+get=>_timeout;
+set=>_timeout=value;
+}
 
 publicHookRegisteredContext(StaticHookMethodhookMethod)
 {
-HookMethod=hookMethod;
+_hookMethod=hookMethod;
+_hookName=hookMethod.Name;
+}
+
+publicHookRegisteredContext(InstanceHookMethodhookMethod)
+{
+_hookMethod=hookMethod;
+_hookName=hookMethod.Name;
 }
 }

TUnit.Core/Hooks/InstanceHookMethod.cs

@@ -22,7 +22,11 @@ public record InstanceHookMethod : IExecutableHook<TestContext>
 
 publicTAttribute?GetAttribute<TAttribute>()whereTAttribute:Attribute=>Attributes.OfType<TAttribute>().FirstOrDefault();
 
-publicTimeSpan?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>
+publicTimeSpan?Timeout{get;internalset;}=TimeSpan.FromMinutes(5);
 
 publicrequiredIHookExecutorHookExecutor{get;init;}
 

TUnit.Core/Hooks/StaticHookMethod.cs

@@ -32,7 +32,11 @@ public abstract record StaticHookMethod
 
 publicTAttribute?GetAttribute<TAttribute>()whereTAttribute:Attribute=>Attributes.OfType<TAttribute>().FirstOrDefault();
 
-publicTimeSpan?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>
+publicTimeSpan?Timeout{get;internalset;}=TimeSpan.FromMinutes(5);
 
 publicrequiredIHookExecutorHookExecutor{get;init;}
 

TUnit.Engine/Framework/TUnitServiceProvider.cs

@@ -86,14 +86,14 @@ public TUnitServiceProvider(IExtension extension,
 
 CancellationToken=Register(newEngineCancellationToken());
 
-HookCollectionService=Register<IHookCollectionService>(newHookCollectionService());
+EventReceiverOrchestrator=Register(newEventReceiverOrchestrator(Logger));
+HookCollectionService=Register<IHookCollectionService>(newHookCollectionService(EventReceiverOrchestrator));
 
 ParallelLimitLockProvider=Register(newParallelLimitLockProvider());
 
 ContextProvider=Register(newContextProvider(this,TestSessionId,Filter?.ToString()));
 
 HookOrchestrator=Register(newHookOrchestrator(HookCollectionService,Logger,ContextProvider,this));
-EventReceiverOrchestrator=Register(newEventReceiverOrchestrator(Logger));
 
 // Detect execution mode from command line or environment
 varuseSourceGeneration=GetUseSourceGeneration(CommandLineOptions);

TUnit.Engine/Services/EventReceiverOrchestrator.cs

@@ -197,6 +197,58 @@ public async ValueTask InvokeTestDiscoveryEventReceiversAsync(TestContext contex
 }
 }
 
+publicasyncValueTaskInvokeHookRegistrationEventReceiversAsync(HookRegisteredContexthookContext,CancellationTokencancellationToken)
+{
+// Get event receivers from the hook method's attributes
+IEnumerable<Attribute>attributes;
+
+if(hookContext.StaticHookMethod!=null)
+{
+attributes=hookContext.StaticHookMethod.Attributes;
+}
+elseif(hookContext.InstanceHookMethod!=null)
+{
+attributes=hookContext.InstanceHookMethod.Attributes;
+}
+else
+{
+return;// No hook method to process
+}
+
+vareventReceivers=attributes
+.OfType<IHookRegisteredEventReceiver>()
+.OrderBy(r =>r.Order)
+.ToList();
+
+// Filter scoped attributes to ensure only the highest priority one of each type is invoked
+varfilteredReceivers=ScopedAttributeFilter.FilterScopedAttributes(eventReceivers);
+
+foreach(varreceiverinfilteredReceivers.OrderBy(r =>r.Order))
+{
+try
+{
+awaitreceiver.OnHookRegistered(hookContext);
+}
+catch(Exceptionex)
+{
+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;
+}
+elseif(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;
 
 internalsealedclassHookCollectionService:IHookCollectionService
 {
+privatereadonlyEventReceiverOrchestrator_eventReceiverOrchestrator;
 privatereadonlyConcurrentDictionary<Type,IReadOnlyList<Func<TestContext,CancellationToken,Task>>>_beforeTestHooksCache=new();
 privatereadonlyConcurrentDictionary<Type,IReadOnlyList<Func<TestContext,CancellationToken,Task>>>_afterTestHooksCache=new();
 privatereadonlyConcurrentDictionary<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
 privatereadonlyConcurrentDictionary<Type,CompleteHookChain>_completeHookChainCache=new();
 
+// Cache for processed hooks to avoid re-processing event receivers
+privatereadonlyConcurrentDictionary<object,bool>_processedHooks=new();
+
+publicHookCollectionService(EventReceiverOrchestratoreventReceiverOrchestrator)
+{
+_eventReceiverOrchestrator=eventReceiverOrchestrator;
+}
+
+privateasyncTaskProcessHookRegistrationAsync(objecthookMethod,CancellationTokencancellationToken=default)
+{
+// Only process each hook once
+if(!_processedHooks.TryAdd(hookMethod,true))
+{
+return;
+}
+
+try
+{
+HookRegisteredContextcontext;
+
+if(hookMethodisStaticHookMethodstaticHook)
+{
+context=newHookRegisteredContext(staticHook);
+}
+elseif(hookMethodisInstanceHookMethodinstanceHook)
+{
+context=newHookRegisteredContext(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
+}
+}
+
 privatesealedclassCompleteHookChain
 {
 publicIReadOnlyList<Func<TestContext,CancellationToken,Task>>BeforeTestHooks{get;init;}=[
@@ -51,7 +94,7 @@ public ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Coll
 {
 foreach(varhookinsourceHooks)
 {
-varhookFunc=CreateInstanceHookDelegate(hook);
+varhookFunc=awaitCreateInstanceHookDelegateAsync(hook);
 typeHooks.Add((hook.Order,hook.RegistrationIndex,hookFunc));
 }
 }
@@ -64,7 +107,7 @@ public ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Coll
 {
 foreach(varhookinopenTypeHooks)
 {
-varhookFunc=CreateInstanceHookDelegate(hook);
+varhookFunc=awaitCreateInstanceHookDelegateAsync(hook);
 typeHooks.Add((hook.Order,hook.RegistrationIndex,hookFunc));
 }
 }
@@ -111,7 +154,7 @@ public ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Coll
 {
 foreach(varhookinsourceHooks)
 {
-varhookFunc=CreateInstanceHookDelegate(hook);
+varhookFunc=awaitCreateInstanceHookDelegateAsync(hook);
 typeHooks.Add((hook.Order,hook.RegistrationIndex,hookFunc));
 }
 }
@@ -124,7 +167,7 @@ public ValueTask<IReadOnlyList<Func<TestContext, CancellationToken, Task>>> Coll
 {
 foreach(varhookinopenTypeHooks)
 {
-varhookFunc=CreateInstanceHookDelegate(hook);
+varhookFunc=awaitCreateInstanceHookDelegateAsync(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(varhookinSources.BeforeEveryTestHooks)
 {
-varhookFunc=CreateStaticHookDelegate(hook);
+varhookFunc=awaitCreateStaticHookDelegateAsync(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(varhookinSources.AfterEveryTestHooks)
 {
-varhookFunc=CreateStaticHookDelegate(hook);
+varhookFunc=awaitCreateStaticHookDelegateAsync(hook);
 allHooks.Add((hook.Order,hook.RegistrationIndex,hookFunc));
 }
 
@@ -513,8 +556,11 @@ public ValueTask<IReadOnlyList<Func<AssemblyHookContext, CancellationToken, Task
 returnnewValueTask<IReadOnlyList<Func<AssemblyHookContext,CancellationToken,Task>>>(hooks);
 }
 
-privatestaticFunc<TestContext,CancellationToken,Task>CreateInstanceHookDelegate(InstanceHookMethodhook)
+privateasyncTask<Func<TestContext,CancellationToken,Task>>CreateInstanceHookDelegateAsync(InstanceHookMethodhook)
 {
+// Process hook registration event receivers
+awaitProcessHookRegistrationAsync(hook);
+
 returnasync(context,cancellationToken)=>
 {
 vartimeoutAction=HookTimeoutHelper.CreateTimeoutHookAction(
@@ -528,8 +574,11 @@ private static Func<TestContext, CancellationToken, Task> CreateInstanceHookDele
 };
 }
 
-privatestaticFunc<TestContext,CancellationToken,Task>CreateStaticHookDelegate(StaticHookMethod<TestContext>hook)
+privateasyncTask<Func<TestContext,CancellationToken,Task>>CreateStaticHookDelegateAsync(StaticHookMethod<TestContext>hook)
 {
+// Process hook registration event receivers
+awaitProcessHookRegistrationAsync(hook);
+
 returnasync(context,cancellationToken)=>
 {
 vartimeoutAction=HookTimeoutHelper.CreateTimeoutHookAction(