Function doRequestWithConnRefusedRetry

pkg/util.go:677–706

doRequestWithConnRefusedRetry executes client.Do, re-sending ONLY on a pre-response connection-refused (bounded, ctx-aware backoff, request body rewound via GetBody). Any other error, or a real response, returns immediately — so a genuinely crashed/unreachable app still fails fast after the bounded

(ctx context.Context, logger *zap.Logger, client *http.Client, req *http.Request)

// immediately — so a genuinely crashed/unreachable app still fails fast after
// the bounded retries, and a mid-response reset is never retried.
func doRequestWithConnRefusedRetry(ctx context.Context, logger *zap.Logger, client *http.Client, req *http.Request) (*http.Response, error) {
	for attempt := 0; ; attempt++ {
		resp, err := client.Do(req)
		if err == nil {
			return resp, nil
		}
		if attempt >= maxConnRefusedRetries || !isPreResponseConnRefused(err) {
			return nil, err
		}
		// Only retry if we can faithfully re-send the body; otherwise stop so we
		// never send a truncated/empty body (which would fabricate a result).
		if req.Body != nil && req.GetBody == nil {
			return nil, err
		}
		if req.GetBody != nil {
			body, gbErr := req.GetBody()
			if gbErr != nil {
				return nil, err
			}
			req.Body = body
		}
		logger.Warn("test request refused by app (app not yet accepting connections); re-sending — the request was never processed, so this is not a retry of an assertion",
			zap.Int("attempt", attempt+1), zap.Int("maxRetries", maxConnRefusedRetries), zap.Error(err))
		select {
		case <-ctx.Done():
			return nil, err
		case <-time.After(connRefusedRetryBackoff * time.Duration(attempt+1)):
		}
	}
}

func SimulateHTTP(ctx context.Context, tc *models.TestCase, testSet string, logger *zap.Logger, cfg SimulationConfig) (*models.HTTPResp, error) {
	templatedResponse := tc.HTTPResp // keep a copy of the original templatized response