Function SimulateHTTPStreaming

pkg/util.go:784–842

SimulateHTTPStreaming sends an HTTP request and returns the streaming response with a reader. The caller is responsible for reading from the response Reader and closing it when done. Use CompareHTTPStream to compare the streaming response with expected values.

(ctx context.Context, tc *models.TestCase, testSet string, logger *zap.Logger, cfg SimulationConfig)

// The caller is responsible for reading from the response Reader and closing it when done.
// Use CompareHTTPStream to compare the streaming response with expected values.
func SimulateHTTPStreaming(ctx context.Context, tc *models.TestCase, testSet string, logger *zap.Logger, cfg SimulationConfig) (*StreamingHTTPResponse, error) {
	logger.Info("starting streaming test for", zap.Any("test case", models.HighlightString(tc.Name)), zap.Any("test set", models.HighlightString(testSet)))

	// Calculate streaming timeout
	APITimeout := ComputeStreamingTimeoutSeconds(tc, cfg.APITimeout)
	cfg.RequestTimeout = time.Second * time.Duration(APITimeout)

	// Prepare the HTTP request using the shared helper
	prepared, err := prepareHTTPRequest(ctx, tc, testSet, logger, cfg)
	if err != nil {
		return nil, err
	}

	logger.Debug(fmt.Sprintf("Sending streaming request to user app:%v", prepared.Request))

	// Execute the request (re-sending only on a pre-response connection-refused)
	httpResp, errHTTPReq := doRequestWithConnRefusedRetry(ctx, logger, prepared.Client, prepared.Request)
	if errHTTPReq != nil {
		utils.LogError(logger, errHTTPReq, "failed to send testcase request to app")
		return nil, errHTTPReq
	}

	statusMessage := http.StatusText(httpResp.StatusCode)
	streamCfg := DetectHTTPStreamConfig(tc, httpResp)

	logger.Debug("detected HTTP streaming response",
		zap.String("testcase", tc.Name),
		zap.String("content_type", httpResp.Header.Get("Content-Type")),
		zap.String("stream_mode", string(streamCfg.Mode)))

	// Wrap the response body with decompression if needed
	streamReader := io.ReadCloser(httpResp.Body)
	contentEncoding := strings.ToLower(strings.TrimSpace(httpResp.Header.Get("Content-Encoding")))
	switch contentEncoding {
	case "gzip":
		gzipReader, gzErr := gzip.NewReader(httpResp.Body)
		if gzErr != nil {
			httpResp.Body.Close()
			utils.LogError(logger, gzErr, "failed to create gzip reader for streaming response")
			return nil, gzErr
		}
		streamReader = &gzipReadCloser{gzipReader: gzipReader, underlying: httpResp.Body}
	case "br":
		streamReader = &brotliReadCloser{reader: brotli.NewReader(httpResp.Body), underlying: httpResp.Body}
	case "":
		// no-op, use httpResp.Body directly
	default:
		logger.Debug("unsupported content-encoding for stream; returning raw response body",
			zap.String("content_encoding", contentEncoding))
	}

	return &StreamingHTTPResponse{
		StatusCode:    httpResp.StatusCode,
		StatusMessage: statusMessage,
		Header:        ToYamlHTTPHeader(httpResp.Header),
		Reader:        streamReader,
		StreamConfig:  streamCfg,
	}, nil