TestResponseWriterHijackAfterWrite() — gin Function Reference

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

Function go GinCore Middleware

Entity Profile

GinCore→ Middleware→ TestResponseWriterHijackAfterWrite() — gin Function Reference

Dependency Diagram

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

Relationship Graph

Source Code

response_writer_test.go lines 140–195

func TestResponseWriterHijackAfterWrite(t *testing.T) {
	tests := []struct {
		name                      string
		action                    func(w ResponseWriter) error // Action to perform before hijacking
		expectWrittenBeforeHijack bool
		expectHijackSuccess       bool
		expectWrittenAfterHijack  bool
		expectError               error
	}{
		{
			name:                      "hijack before write should succeed",
			action:                    func(w ResponseWriter) error { return nil },
			expectWrittenBeforeHijack: false,
			expectHijackSuccess:       true,
			expectWrittenAfterHijack:  true, // Hijack itself marks the writer as written
			expectError:               nil,
		},
		{
			name: "hijack after write should fail",
			action: func(w ResponseWriter) error {
				_, 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)

			// Check initial state
			assert.False(t, w.Written(), "should not be written initially")

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

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

			// Attempt to hijack
			_, _, hijackErr := w.Hijack()

			// Check results
			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")
		})
	}
}