Function TestExecutorDispatchesToCustomHandler

pkg/hooks/handler_test.go:45–94

TestExecutorDispatchesToCustomHandler shows the smallest end-to-end use of the new pluggability: a custom HookType backed by an in-process Go Handler runs through the same executor pipeline as a "command" hook, and its pre-parsed Output (a deny verdict here) drives the aggregated Result.

(t *testing.T)

// and its pre-parsed Output (a deny verdict here) drives the aggregated
// Result.
func TestExecutorDispatchesToCustomHandler(t *testing.T) {
	t.Parallel()

	const customType HookType = "builtin-test"

	rec := &recordingHandler{
		out: &Output{
			Decision: "block",
			Reason:   "denied by builtin handler",
		},
	}

	registry := NewRegistry()
	registry.Register(customType, func(_ HandlerEnv, _ Hook) (Handler, error) {
		return rec, nil
	})

	config := &Config{
		PreToolUse: []MatcherConfig{
			{
				Matcher: "*",
				Hooks: []Hook{
					{Type: customType, Timeout: 5},
				},
			},
		},
	}

	exec := NewExecutorWithRegistry(config, t.TempDir(), nil, registry)
	input := &Input{
		SessionID: "test-session",
		ToolName:  "shell",
		ToolUseID: "test-id",
	}

	result, err := exec.Dispatch(t.Context(), EventPreToolUse, input)
	require.NoError(t, err)

	// The custom handler ran and saw a properly serialized Input on stdin.
	assert.Equal(t, int32(1), rec.calls.Load())
	var got Input
	require.NoError(t, json.Unmarshal(rec.capturedInput(), &got))
	assert.Equal(t, EventPreToolUse, got.HookEventName)
	assert.Equal(t, "shell", got.ToolName)

	// The pre-parsed Output drove the aggregated Result, so the call is
	// denied with the handler-supplied reason.
	assert.False(t, result.Allowed)
	assert.Contains(t, result.Message, "denied by builtin handler")
}

// TestExecutorUnregisteredTypeIsRejected ensures the registry is the only
// way to plug in a handler: an unknown HookType is surfaced as a hook