Function TestSimulateHTTP_PlainTextStreamMatchAndEarlyClose_321

pkg/util_test.go:706–781

(t *testing.T)

}

func TestSimulateHTTP_PlainTextStreamMatchAndEarlyClose_321(t *testing.T) {
	ctx := context.Background()
	logger := zap.NewNop()

	serverClosed := make(chan struct{})
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "text/plain")
		flusher, ok := w.(http.Flusher)
		require.True(t, ok, "server response writer must support flushing")

		_, _ = w.Write([]byte("[INFO] booting\n"))
		flusher.Flush()
		_, _ = w.Write([]byte("[INFO] ready\n"))
		flusher.Flush()
		_, _ = w.Write([]byte("[INFO] keep-running\n"))
		flusher.Flush()

		<-r.Context().Done()
		close(serverClosed)
	}))
	defer server.Close()

	expectedBody := "[INFO] booting\n[INFO] ready\n"

	tc := &models.TestCase{
		Name: "plain-stream-match-and-close",
		HTTPReq: models.HTTPReq{
			Method: "GET",
			URL:    server.URL,
		},
		HTTPResp: models.HTTPResp{
			Header: map[string]string{
				"Content-Type": "text/plain",
			},
			Body: expectedBody,
			StreamBody: []models.HTTPStreamChunk{
				{
					Data: []models.HTTPStreamDataField{
						{Key: "raw", Value: "[INFO] booting"},
					},
				},
				{
					Data: []models.HTTPStreamDataField{
						{Key: "raw", Value: "[INFO] ready"},
					},
				},
			},
		},
	}

	// Use SimulateHTTPStreaming for streaming test cases
	streamResp, err := SimulateHTTPStreaming(ctx, tc, "test-set", logger, SimulationConfig{APITimeout: 3})
	require.NoError(t, err)
	require.NotNil(t, streamResp)

	// Compare the stream
	noiseKeys := map[string]struct{}{}
	matched, _, _, compareErr := CompareHTTPStream(tc.HTTPResp, streamResp.Reader, streamResp.StreamConfig, noiseKeys, logger)