Function TestHumanInTheLoopMiddleware_Reject

pkg/middleware/hitl_test.go:146–204

TestHumanInTheLoopMiddleware_Reject 测试拒绝操作

(t *testing.T)

// TestHumanInTheLoopMiddleware_Reject 测试拒绝操作
func TestHumanInTheLoopMiddleware_Reject(t *testing.T) {
	ctx := context.Background()

	middleware, err := NewHumanInTheLoopMiddleware(&HumanInTheLoopMiddlewareConfig{
		InterruptOn: map[string]any{
			"dangerous_tool": map[string]any{
				"allowed_decisions": []any{"approve", "reject"},
			},
		},
		ApprovalHandler: func(ctx context.Context, request *ReviewRequest) ([]Decision, error) {
			// 拒绝操作
			return []Decision{
				{
					Type:   DecisionReject,
					Reason: "Too dangerous",
				},
			}, nil
		},
	})
	if err != nil {
		t.Fatalf("Failed to create middleware: %v", err)
	}

	req := &ToolCallRequest{
		ToolCallID: "test-reject",
		ToolName:   "dangerous_tool",
		ToolInput: map[string]any{
			"action": "delete_all",
		},
		Tool: &mockTool{name: "dangerous_tool"},
	}

	handler := func(ctx context.Context, req *ToolCallRequest) (*ToolCallResponse, error) {
		t.Error("Handler should not be called when operation is rejected")
		return nil, nil
	}

	resp, err := middleware.WrapToolCall(ctx, req, handler)
	if err != nil {
		t.Fatalf("WrapToolCall failed: %v", err)
	}

	resultMap, ok := resp.Result.(map[string]any)
	if !ok {
		t.Fatal("Result is not a map")
	}

	if resultMap["ok"].(bool) {
		t.Error("Expected ok=false for rejected operation")
	}

	if !resultMap["rejected"].(bool) {
		t.Error("Expected rejected=true")
	}

	if resultMap["reason"] != "Too dangerous" {
		t.Errorf("Expected reason='Too dangerous', got '%v'", resultMap["reason"])
	}