package chromeperf

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net"
	"net/http"
	"net/http/httptest"
	"net/url"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.skia.org/infra/go/skerr"
)

// mockRoundTripper allows you to define a function that will be called
// when the client's Do method (which uses RoundTrip) is invoked.
type mockRoundTripper struct {
	roundTripFunc   func(req *http.Request) (*http.Response, error)
	ReceivedRequest *http.Request // To store the request for inspection
}

// RoundTrip implements the http.RoundTripper interface.
func (m *mockRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
	m.ReceivedRequest = req // Store the request for later assertions
	return m.roundTripFunc(req)
}

func TestGenereateUrl_Bridge(t *testing.T) {
	api := "api_name"
	function := "func_name"
	direct := false
	urlOverride := ""

	url := generateTargetUrl(urlOverride, direct, api, function)
	assert.Equal(t, url, "https://skia-bridge-dot-chromeperf.appspot.com/api_name/func_name")
}

func TestGenereateUrl_Direct(t *testing.T) {
	api := "api_name"
	function := "func_name" // will be ignored
	direct := true
	urlOverride := ""

	url := generateTargetUrl(urlOverride, direct, api, function)
	assert.Equal(t, url, "https://chromeperf.appspot.com/api_name")
}

func TestGenereateUrl_Override(t *testing.T) {
	api := "api_name"       // will be ignored
	function := "func_name" // will be ignored
	direct := true          // will be ignored
	urlOverride := "override.url/someapi/andfunction"

	url := generateTargetUrl(urlOverride, direct, api, function)
	assert.Equal(t, url, urlOverride)
}

// NewChromePerfTestClient is a constructor for ChromePerfClient
func NewChromePerfTestClient(httpClient *http.Client, urlOverride string, directCallLegacy bool) ChromePerfClient {
	if httpClient == nil {
		httpClient = &http.Client{Timeout: 10 * time.Second} // Default client if none provided
	}
	return &chromePerfClientImpl{
		httpClient:       httpClient,
		urlOverride:      urlOverride,
		directCallLegacy: directCallLegacy,
	}
}

// For testing purpose only.
type getSheriffListResponse struct {
	SheriffList []string `json:"sheriff_list"`
	Error       string   `json:"error"`
}

// For testing purpose only.
type mockReadCloser struct {
	readErr  error
	closeErr error
	data     []byte
	readIdx  int
}

// For testing purpose only.
func (m *mockReadCloser) Read(p []byte) (n int, err error) {
	if m.readErr != nil {
		return 0, m.readErr
	}
	if m.readIdx >= len(m.data) {
		return 0, io.EOF
	}
	n = copy(p, m.data[m.readIdx:])
	m.readIdx += n
	return n, nil
}

// For testing purpose only.
func (m *mockReadCloser) Close() error { return m.closeErr }

func TestSendGetRequest(t *testing.T) {
	tests := []struct {
		name                string
		clientConfig        func() (urlOverride string, directCallLegacy bool) // Configure client properties
		apiName             string
		functionName        string
		queryParams         url.Values
		responseObjTemplate func() any
		roundTripFunc       func(t *testing.T, req *http.Request) (*http.Response, error) // Defines mock transport behavior
		expectError         bool
		expectedErrorMsg    string
		expectedResponse    any
	}{
		{
			name:                "Successful request",
			clientConfig:        func() (string, bool) { return "", false },
			apiName:             "sheriff_configs_skia",
			functionName:        "",
			queryParams:         url.Values{"key1": []string{"value1"}, "key2": []string{"value2"}},
			responseObjTemplate: func() any { return &getSheriffListResponse{} },
			roundTripFunc: func(t *testing.T, req *http.Request) (*http.Response, error) {
				assert.NotNil(t, req.Context())
				assert.Equal(t, http.MethodGet, req.Method)
				assert.Equal(t, "/sheriff_configs_skia/", req.URL.Path)
				assert.Equal(t, "key1=value1&key2=value2", req.URL.RawQuery)
				return &http.Response{
					StatusCode: http.StatusOK,
					Body:       io.NopCloser(strings.NewReader(`{"sheriff_list":["abc", "def"], "error":""}`)),
					Header:     make(http.Header),
				}, nil
			},
			expectError:      false,
			expectedResponse: &getSheriffListResponse{SheriffList: []string{"abc", "def"}},
		},
		{
			name:                "Successful request with URL override",
			clientConfig:        func() (string, bool) { return "http://mockserver.com/override", false },
			apiName:             "customApi",
			functionName:        "customFunc",
			queryParams:         url.Values{"k": []string{"v"}},
			responseObjTemplate: func() any { return &getSheriffListResponse{} },
			roundTripFunc: func(t *testing.T, req *http.Request) (*http.Response, error) {
				assert.Equal(t, "https://mockedserver/customApi/customFunc?k=v", req.URL.String()) // Full URL check
				assert.Equal(t, "k=v", req.URL.RawQuery)
				return &http.Response{
					StatusCode: http.StatusOK,
					Body:       io.NopCloser(strings.NewReader(`{"sheriff_list":["abc", "def"], "error":""}`)),
					Header:     make(http.Header),
				}, nil
			},
			expectError:      false,
			expectedResponse: &getSheriffListResponse{SheriffList: []string{"abc", "def"}},
		},
		{
			name:                "Successful request with direct call legacy",
			clientConfig:        func() (string, bool) { return "", true }, // directCallLegacy = true
			apiName:             "legacyApi",
			functionName:        "legacyFunc",
			queryParams:         nil,
			responseObjTemplate: func() any { return &getSheriffListResponse{} },
			roundTripFunc: func(t *testing.T, req *http.Request) (*http.Response, error) {
				assert.Equal(t, "https://mockedserver/legacyApi/legacyFunc?", req.URL.String())
				return &http.Response{
					StatusCode: http.StatusOK,
					Body:       io.NopCloser(strings.NewReader(`{"sheriff_list":["abc", "def"], "error":""}`)),
					Header:     make(http.Header),
				}, nil
			},
			expectError:      false,
			expectedResponse: &getSheriffListResponse{SheriffList: []string{"abc", "def"}},
		},
		{
			name:                "Network error from RoundTrip",
			clientConfig:        func() (string, bool) { return "", false },
			apiName:             "anyApi",
			functionName:        "anyFunc",
			responseObjTemplate: func() any { return &struct{}{} },
			roundTripFunc: func(t *testing.T, req *http.Request) (*http.Response, error) {
				return nil, errors.New("simulated network error from RoundTrip")
			},
			expectError:      true,
			expectedErrorMsg: "Failed to get chrome perf response", // Wrapped error
		},
		{
			name:                "Error reading response body (from RoundTrip's perspective)",
			clientConfig:        func() (string, bool) { return "", false },
			apiName:             "readErrorApi",
			functionName:        "readErrorFunc",
			responseObjTemplate: func() any { return &struct{}{} },
			roundTripFunc: func(t *testing.T, req *http.Request) (*http.Response, error) {
				return &http.Response{
					StatusCode: http.StatusOK,
					Body:       &mockReadCloser{readErr: errors.New("simulated read body error")},
					Header:     make(http.Header),
				}, nil
			},
			expectError:      true,
			expectedErrorMsg: "Failed to read body from chrome perf response",
		},
		{
			name:                "JSON unmarshal error",
			clientConfig:        func() (string, bool) { return "", false },
			apiName:             "jsonErrorApi",
			functionName:        "jsonErrorFunc",
			responseObjTemplate: func() any { return &struct{}{} },
			roundTripFunc: func(t *testing.T, req *http.Request) (*http.Response, error) {
				return &http.Response{
					StatusCode: http.StatusOK,
					Body:       io.NopCloser(strings.NewReader(`this is not valid json`)),
					Header:     make(http.Header),
				}, nil
			},
			expectError:      true,
			expectedErrorMsg: "Failed to parse chrome perf response body",
		},
		{
			name:                "Non-2xx HTTP status code (e.g., 400)",
			clientConfig:        func() (string, bool) { return "", false },
			apiName:             "statusErrorApi",
			functionName:        "statusErrorFunc",
			responseObjTemplate: func() any { return &struct{}{} },
			roundTripFunc: func(t *testing.T, req *http.Request) (*http.Response, error) {
				return &http.Response{
					StatusCode: http.StatusBadRequest, // 400
					Body:       io.NopCloser(strings.NewReader(`{"error": "bad input from roundtrip"}`)),
					Header:     make(http.Header),
				}, nil
			},
			expectError:      true,
			expectedErrorMsg: "chrome perf request failed", // Also check for status code and body in error
		},
		{
			name:                "Context cancelled during HTTP request",
			clientConfig:        func() (string, bool) { return "", false },
			apiName:             "contextApi",
			functionName:        "contextFunc",
			responseObjTemplate: func() any { return &struct{}{} },
			roundTripFunc: func(t *testing.T, req *http.Request) (*http.Response, error) {
				// The actual context cancellation is handled by client.Do if the context is passed correctly.
				// The RoundTripper itself might not always directly see the context unless the HTTP client
				// aborts the request due to context cancellation before RoundTrip is even called or while it's running.
				// For this test, we'll simulate the error that client.Do would return.
				select {
				case <-req.Context().Done():
					return nil, req.Context().Err() // e.g. context.Canceled or context.DeadlineExceeded
				default:
					// If context wasn't cancelled fast enough for this check
					time.Sleep(10 * time.Millisecond) // Give it a moment
					if req.Context().Err() != nil {
						return nil, req.Context().Err()
					}
					return nil, errors.New("context was not cancelled as expected by mock roundtrip")
				}
			},
			expectError:      true,
			expectedErrorMsg: "Failed to get chrome perf response", // Error from GetWithContext/client.Do will be wrapped
		},
		{
			name:                "Client with nil httpClient (setup error, not RoundTripper)",
			clientConfig:        func() (string, bool) { return "NIL_HTTP_CLIENT", false }, // Special marker
			apiName:             "nilClientApi",
			functionName:        "nilClientFunc",
			responseObjTemplate: func() any { return &struct{}{} },
			roundTripFunc: func(t *testing.T, req *http.Request) (*http.Response, error) {
				// This won't be called if httpClient is nil
				return nil, errors.New("roundTripFunc should not be called for nil httpClient test")
			},
			expectError:      true,
			expectedErrorMsg: "no such host",
		},
	}

	expectedURL := "https://mockedserver"
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			urlOverride, directCallLegacy := tt.clientConfig()

			var testHttpClient *http.Client
			var mockTransport *mockRoundTripper
			if urlOverride == "NIL_HTTP_CLIENT" {
				testHttpClient = &http.Client{
					Transport: &http.Transport{
						DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
							// Simulate "no such host" error
							return nil, &net.DNSError{Err: "no such host", Name: strings.Split(addr, ":")[0]}
						},
					},
				}
			} else {
				mockTransport = &mockRoundTripper{
					roundTripFunc: func(req *http.Request) (*http.Response, error) {
						// Pass `t` to the user-defined roundTripFunc for assertions
						return tt.roundTripFunc(t, req)
					},
				}
				testHttpClient = &http.Client{
					Transport: mockTransport,
				}
			}
			apiURL := fmt.Sprintf("%s/%s/%s", expectedURL, tt.apiName, tt.functionName)
			clientUnderTest := NewChromePerfTestClient(testHttpClient, apiURL, directCallLegacy)

			ctx := context.Background()
			if tt.name == "Context cancelled during HTTP request" {
				var cancel context.CancelFunc
				ctx, cancel = context.WithTimeout(context.Background(), 5*time.Millisecond) // Short timeout
				defer cancel()
			}

			responseTemplate := tt.responseObjTemplate()
			err := clientUnderTest.SendGetRequest(ctx, tt.apiName, tt.functionName, tt.queryParams, responseTemplate)

			if tt.expectError {
				require.Error(t, err, "Expected an error but got none")
				if tt.expectedErrorMsg != "" {
					assert.Contains(t, err.Error(), tt.expectedErrorMsg, "Error message mismatch: got %v", err)
				}
			} else {
				require.NoError(t, err, "Expected no error but got one: %v", err)
				if tt.expectedResponse != nil {
					assert.Equal(t, tt.expectedResponse, responseTemplate, "Response data mismatch")
				}
				assert.NotNil(t, mockTransport.ReceivedRequest, "mockTransport did not receive any request")
			}
		})
	}
}

// For testing purpose only.
type anomaly struct {
	Id            string `json:"id"`
	TestPath      string `json:"test_path"`
	BugId         int    `json:"bug_id"`
	StartRevision int    `json:"start_revision"`
	EndRevision   int    `json:"end_revision"`

	// The hashes below are needed for cases where the commit numbers are
	// different in chromeperf and in the perf instance. We can use these
	// hashes to look up the correct commit number from the database.
	StartRevisionHash string `json:"start_revision_hash,omitempty"`
	EndRevisionHash   string `json:"end_revision_hash,omitempty"`

	IsImprovement       bool     `json:"is_improvement"`
	Recovered           bool     `json:"recovered"`
	State               string   `json:"state"`
	Statistics          string   `json:"statistic"`
	Unit                string   `json:"units"`
	DegreeOfFreedom     float64  `json:"degrees_of_freedom"`
	MedianBeforeAnomaly float64  `json:"median_before_anomaly"`
	MedianAfterAnomaly  float64  `json:"median_after_anomaly"`
	PValue              float64  `json:"p_value"`
	SegmentSizeAfter    int      `json:"segment_size_after"`
	SegmentSizeBefore   int      `json:"segment_size_before"`
	StdDevBeforeAnomaly float64  `json:"std_dev_before_anomaly"`
	TStatistics         float64  `json:"t_statistic"`
	SubscriptionName    string   `json:"subscription_name"`
	BugComponent        string   `json:"bug_component"`
	BugLabels           []string `json:"bug_labels"`
	BugCcEmails         []string `json:"bug_cc_emails"`
	BisectIDs           []string `json:"bisect_ids"`
	Timestamp           string   `json:"timestamp,omitempty"`
}

// For testing purpose only.
type getAnomaliesResponse struct {
	Anomalies map[string][]anomaly `json:"anomalies"`
}

// For testing purpose only.
type getAnomaliesRequest struct {
	Tests           []string `json:"tests,omitempty"`
	MaxRevision     string   `json:"max_revision,omitempty"`
	MinRevision     string   `json:"min_revision,omitempty"`
	Revision        int      `json:"revision,omitempty"`
	NeedAggregation bool     `json:"need_aggregation,omitempty"`
}

type marshalErrorType struct{}

func (m *marshalErrorType) MarshalJSON() ([]byte, error) {
	return nil, fmt.Errorf("simulated marshal error")
}

func TestSendPostRequest(t *testing.T) {
	ctx := context.Background()
	anomaly1 := anomaly{
		Id:                  "101",
		TestPath:            "Master>Builder>Test>Subtest.Value",
		BugId:               12345,
		StartRevision:       10001,
		EndRevision:         10005,
		StartRevisionHash:   "abcdef123456",
		EndRevisionHash:     "fedcba654321",
		IsImprovement:       false,
		Recovered:           true,
		State:               "Closed",
		Statistics:          "mean",
		Unit:                "ms",
		DegreeOfFreedom:     10.5,
		MedianBeforeAnomaly: 150.2,
		MedianAfterAnomaly:  185.7,
		PValue:              0.001,
		SegmentSizeAfter:    50,
		SegmentSizeBefore:   48,
		StdDevBeforeAnomaly: 12.3,
		TStatistics:         -3.45,
		SubscriptionName:    "My Test Subscription",
		BugComponent:        "Blink>Performance",
		BugLabels:           []string{"Perf-Regression", "Mobile"},
		BugCcEmails:         []string{"user1@example.com", "user2@example.com"},
		BisectIDs:           []string{"bisect_run_001", "bisect_run_002"},
	}
	anomaly2 := anomaly{
		Id:                  "102",
		TestPath:            "Master>Builder>Test>AnotherSubtest.Score",
		BugId:               0,
		StartRevision:       10010,
		EndRevision:         10012,
		IsImprovement:       true,
		Recovered:           false,
		State:               "Investigating",
		Statistics:          "percentile_90",
		Unit:                "score",
		DegreeOfFreedom:     8.0,
		MedianBeforeAnomaly: 800.0,
		MedianAfterAnomaly:  750.5,
		PValue:              0.045,
		SegmentSizeAfter:    30,
		SegmentSizeBefore:   35,
		StdDevBeforeAnomaly: 25.0,
		TStatistics:         2.15,
		SubscriptionName:    "Performance Score Alerts",
		BugComponent:        "",
		BugLabels:           []string{"Perf-Improvement"},
		BugCcEmails:         []string{},
		BisectIDs:           []string{},
	}

	tests := []struct {
		name                string
		apiName             string
		functionName        string
		requestObj          any
		responseObjTemplate any
		acceptedStatusCodes []int
		mockServerHandler   http.HandlerFunc
		directCallLegacy    bool // For URL generation variance
		expectError         bool
		expectedErrorMsg    string                               // Substring to check in the error
		expectedResponse    any                                  // Expected state of responseObj after call
		checkRequestBody    func(t *testing.T, bodyBytes []byte) // Optional: to validate the sent body
	}{
		{
			name:         "Successful request",
			apiName:      "anomalies",
			functionName: "find",
			requestObj: getAnomaliesRequest{
				Tests:       []string{"foo/bar", "foo/baz"},
				MaxRevision: strconv.Itoa(987654321),
				MinRevision: strconv.Itoa(123456789),
			},
			responseObjTemplate: &getAnomaliesResponse{},
			acceptedStatusCodes: []int{http.StatusOK, http.StatusCreated},
			mockServerHandler: func(w http.ResponseWriter, r *http.Request) {
				assert.Equal(t, http.MethodPost, r.Method)
				assert.Equal(t, "application/json", r.Header.Get("Content-Type"))
				assert.Equal(t, "/anomalies/find", r.URL.Path) // Check generated URL path

				bodyBytes, err := io.ReadAll(r.Body)
				assert.NoError(t, err)
				var receivedReq getAnomaliesRequest
				assert.NoError(t, json.Unmarshal(bodyBytes, &receivedReq))
				assert.Equal(t, getAnomaliesRequest{Tests: []string{"foo/bar", "foo/baz"}, MaxRevision: "987654321", MinRevision: "123456789"}, receivedReq)

				w.Header().Set("Content-Type", "application/json")
				w.WriteHeader(http.StatusCreated)
				err = json.NewEncoder(w).Encode(getAnomaliesResponse{Anomalies: map[string][]anomaly{
					"foo/bar": {anomaly1},
					"foo/baz": {anomaly1, anomaly2},
				}})
				if err != nil {
					assert.Fail(t, "the Encode should always pass.")
				}
			},
			expectError: false,
			expectedResponse: &getAnomaliesResponse{Anomalies: map[string][]anomaly{
				"foo/bar": {anomaly1},
				"foo/baz": {anomaly1, anomaly2},
			}},
		},
		{
			name:                "Request marshalling error",
			apiName:             "data",
			functionName:        "upload",
			requestObj:          &marshalErrorType{}, // This type will cause json.Marshal to fail
			responseObjTemplate: &getAnomaliesResponse{},
			acceptedStatusCodes: []int{http.StatusOK},
			mockServerHandler: func(w http.ResponseWriter, r *http.Request) {
				t.Fatal("Server should not be called if marshalling fails")
			},
			expectError:      true,
			expectedErrorMsg: "json: error calling MarshalJSON for type *chromeperf.marshalErrorType: simulated marshal error",
		},
		{
			name:         "HTTP Post error (server down)",
			apiName:      "data",
			functionName: "upload",
			requestObj:   getAnomaliesRequest{Tests: []string{"foo/bar", "foo/baz"}, MaxRevision: "987654321", MinRevision: "123456789"},
			responseObjTemplate: &getAnomaliesResponse{Anomalies: map[string][]anomaly{
				"foo/bar": {anomaly1},
				"foo/baz": {anomaly1, anomaly2},
			}},
			acceptedStatusCodes: []int{http.StatusOK},
			mockServerHandler: func(w http.ResponseWriter, r *http.Request) {
				// Server handler won't be called as we close the server immediately
			},
			expectError:      true,
			expectedErrorMsg: "connect: connection refused", // Error from httputils.PostWithContext
		},
		{
			name:         "Unexpected status code",
			apiName:      "data",
			functionName: "upload",
			requestObj:   getAnomaliesRequest{Tests: []string{"foo/bar", "foo/baz"}, MaxRevision: "987654321", MinRevision: "123456789"},
			responseObjTemplate: &getAnomaliesResponse{Anomalies: map[string][]anomaly{
				"foo/bar": {anomaly1},
				"foo/baz": {anomaly1, anomaly2},
			}},
			acceptedStatusCodes: []int{http.StatusOK},
			mockServerHandler: func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusInternalServerError)
				_, err := fmt.Fprint(w, "Internal Error Detail")
				if err != nil {
					assert.Fail(t, "the fmt.Fprint should always pass.")
				}
			},
			expectError:      true,
			expectedErrorMsg: "Receive status 500 from chromeperf",
		},
		{
			name:         "Response unmarshalling error (malformed JSON)",
			apiName:      "data",
			functionName: "upload",
			requestObj:   getAnomaliesRequest{Tests: []string{"foo/bar", "foo/baz"}, MaxRevision: "987654321", MinRevision: "123456789"},
			responseObjTemplate: &getAnomaliesResponse{Anomalies: map[string][]anomaly{
				"foo/bar": {anomaly1},
				"foo/baz": {anomaly1, anomaly2},
			}},
			acceptedStatusCodes: []int{http.StatusOK},
			mockServerHandler: func(w http.ResponseWriter, r *http.Request) {
				w.Header().Set("Content-Type", "application/json")
				w.WriteHeader(http.StatusOK)
				_, err := fmt.Fprint(w, `{"status":"success", "processed_value": "not_an_int"`) // Malformed
				if err != nil {
					assert.Fail(t, "the fmt.Fprint should always pass.")
				}
			},
			expectError:      true,
			expectedErrorMsg: "unexpected EOF",
		},
		{
			name:                "Response with nil response body (responseObj is nil)",
			apiName:             "action",
			functionName:        "trigger",
			requestObj:          getAnomaliesRequest{Tests: []string{"foo/bar", "foo/baz"}, MaxRevision: "987654321", MinRevision: "123456789"},
			responseObjTemplate: nil, // Indicate no response body to be decoded
			acceptedStatusCodes: []int{http.StatusNoContent},
			mockServerHandler: func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusNoContent)
			},
			expectError:      true,
			expectedErrorMsg: "EOF",
		},
		{
			name:         "Context timeout before server responds",
			apiName:      "data",
			functionName: "upload_timeout",
			requestObj:   getAnomaliesRequest{Tests: []string{"foo/bar", "foo/baz"}, MaxRevision: "987654321", MinRevision: "123456789"},
			responseObjTemplate: &getAnomaliesResponse{Anomalies: map[string][]anomaly{
				"foo/bar": {anomaly1},
				"foo/baz": {anomaly1, anomaly2},
			}},
			acceptedStatusCodes: []int{http.StatusOK},
			mockServerHandler: func(w http.ResponseWriter, r *http.Request) {
				time.Sleep(100 * time.Millisecond) // Server takes longer than client timeout
				w.WriteHeader(http.StatusOK)
				err := json.NewEncoder(w).Encode(&getAnomaliesResponse{Anomalies: map[string][]anomaly{
					"foo/bar": {anomaly1},
					"foo/baz": {anomaly1, anomaly2},
				}})
				if err != nil {
					assert.Fail(t, "the Encode should always pass.")
				}
			},
			expectError:      true,
			expectedErrorMsg: "context deadline exceeded", // Error from client.Do due to context
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			server := httptest.NewServer(http.HandlerFunc(tt.mockServerHandler))
			// Special handling for the "server down" test
			if tt.name == "HTTP Post error (server down)" {
				server.Close() // Close immediately to simulate server down
			} else {
				defer server.Close()
			}

			// Due to the chromeperfClient.go:118, create urlOverride with path.
			apiURL := fmt.Sprintf("%s/%s/%s", server.URL, tt.apiName, tt.functionName)
			client := NewChromePerfTestClient(server.Client(), apiURL, false)

			// For context timeout test
			currentCtx := ctx
			var cancel context.CancelFunc
			if tt.name == "Context timeout before server responds" {
				currentCtx, cancel = context.WithTimeout(ctx, 50*time.Millisecond) // Client timeout shorter than server sleep
				defer cancel()
			}

			// Make a new instance of the response object for each test run
			var actualResponseObj interface{}
			if sr, ok := tt.responseObjTemplate.(*getAnomaliesResponse); ok && sr != nil {
				actualResponseObj = &getAnomaliesResponse{} // new pointer
			}

			err := client.SendPostRequest(currentCtx, tt.apiName, tt.functionName, tt.requestObj, actualResponseObj, tt.acceptedStatusCodes)

			if tt.expectError {
				require.Error(t, err)
				if tt.expectedErrorMsg != "" {
					assert.Contains(t, skerr.Unwrap(err).Error(), tt.expectedErrorMsg, "Error message mismatch")
				}
			} else {
				require.NoError(t, err)
				if tt.expectedResponse != nil {
					assert.Equal(t, tt.expectedResponse, actualResponseObj, "Response object mismatch")
				} else {
					assert.Nil(t, actualResponseObj, "Expected responseObj to remain nil")
				}
			}
		})
	}
}