TestResponseWriterHijackAfterWriteHeaderNow() — gin Function Reference

Architecture documentation for the TestResponseWriterHijackAfterWriteHeaderNow() function in response_writer_test.go from the gin codebase.

Function go GinCore Routing

Entity Profile

GinCore→ Routing→ TestResponseWriterHijackAfterWriteHeaderNow() — gin Function Reference

Dependency Diagram

graph TD
  cd28e283_d3fc_be2f_ec6b_e939e88d4bd3["TestResponseWriterHijackAfterWriteHeaderNow()"]
  decb0a54_57bf_2698_fa41_76836dcc6724["response_writer_test.go"]
  cd28e283_d3fc_be2f_ec6b_e939e88d4bd3 -->|defined in| decb0a54_57bf_2698_fa41_76836dcc6724
  style cd28e283_d3fc_be2f_ec6b_e939e88d4bd3 fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

response_writer_test.go lines 198–253

func TestResponseWriterHijackAfterWriteHeaderNow(t *testing.T) {
	tests := []struct {
		name                      string
		action                    func(w ResponseWriter) error
		expectWrittenBeforeHijack bool
		expectHijackSuccess       bool
		expectWrittenAfterHijack  bool
		expectError               error
	}{
		{
			name: "hijack after WriteHeaderNow only should succeed (websocket pattern)",
			action: func(w ResponseWriter) error {
				w.WriteHeaderNow() // Simulate websocket.Accept() behavior
				return nil
			},
			expectWrittenBeforeHijack: true,
			expectHijackSuccess:       true, // NEW BEHAVIOR: allow hijack after just header write
			expectWrittenAfterHijack:  true,
			expectError:               nil,
		},
		{
			name: "hijack after WriteHeaderNow + Write should fail",
			action: func(w ResponseWriter) error {
				w.WriteHeaderNow()
				_, err := w.Write([]byte("test"))
				return err
			},
			expectWrittenBeforeHijack: true,
			expectHijackSuccess:       false,
			expectWrittenAfterHijack:  true,
			expectError:               errHijackAlreadyWritten,
		},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			hijacker := &mockHijacker{ResponseRecorder: httptest.NewRecorder()}
			writer := &responseWriter{}
			writer.reset(hijacker)
			w := ResponseWriter(writer)

			require.NoError(t, tc.action(w), "unexpected error during pre-hijack action")

			assert.Equal(t, tc.expectWrittenBeforeHijack, w.Written(), "unexpected w.Written() state before hijack")

			_, _, hijackErr := w.Hijack()

			if tc.expectError == nil {
				require.NoError(t, hijackErr, "expected hijack to succeed")
			} else {
				require.ErrorIs(t, hijackErr, tc.expectError, "unexpected error from Hijack()")
			}
			assert.Equal(t, tc.expectHijackSuccess, hijacker.hijacked, "unexpected hijacker.hijacked state")
			assert.Equal(t, tc.expectWrittenAfterHijack, w.Written(), "unexpected w.Written() state after hijack")
		})
	}
}