test(forwarder): port conflict detection, explicit half-close verification

Author: alysnnix

internal/forwarder/forwarder_test.go

@@ -102,3 +102,97 @@ func TestForwardMultipleConnections(t *testing.T) {
 		}
 	}
 }
+
+func TestForwardPortConflict(t *testing.T) {
+	echoAddr := startEchoServer(t)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// Start the first forwarder on an ephemeral port.
+	f1 := New("127.0.0.1:0", echoAddr)
+	errCh1 := make(chan error, 1)
+	go func() { errCh1 <- f1.Start(ctx) }()
+	time.Sleep(50 * time.Millisecond)
+
+	// Sanity-check: the first forwarder should be working.
+	boundAddr := f1.ListenAddr()
+	conn, err := net.Dial("tcp", boundAddr)
+	if err != nil {
+		t.Fatalf("first forwarder unreachable: %v", err)
+	}
+	conn.Close()
+
+	// Start a second forwarder on the SAME address — this must fail.
+	f2 := New(boundAddr, echoAddr)
+	err = f2.Start(ctx)
+	if err == nil {
+		t.Fatal("expected error when binding to an already-used port, got nil")
+	}
+	t.Logf("second forwarder correctly failed: %v", err)
+}
+
+func TestForwardHalfClose(t *testing.T) {
+	// Server that reads ALL client data, then sends a response after
+	// the client has already closed its write side.
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { ln.Close() })
+
+	const serverReply = "server-says-hello"
+
+	go func() {
+		for {
+			conn, err := ln.Accept()
+			if err != nil {
+				return
+			}
+			go func() {
+				defer conn.Close()
+				// Read everything the client sends (blocks until client CloseWrite).
+				data, _ := io.ReadAll(conn)
+				// Now send back: the echoed data + a fixed suffix.
+				conn.Write(data)
+				conn.Write([]byte(serverReply))
+				// Close write so the proxy's copy loop terminates.
+				if tc, ok := conn.(*net.TCPConn); ok {
+					tc.CloseWrite()
+				}
+			}()
+		}
+	}()
+
+	serverAddr := ln.Addr().String()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	f := New("127.0.0.1:0", serverAddr)
+	go f.Start(ctx)
+	time.Sleep(50 * time.Millisecond)
+
+	conn, err := net.Dial("tcp", f.ListenAddr())
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer conn.Close()
+
+	// Client sends data, then closes its write side.
+	clientMsg := "half-close-test"
+	conn.Write([]byte(clientMsg))
+	conn.(*net.TCPConn).CloseWrite()
+
+	// The server only starts writing AFTER it has read everything, so
+	// if half-close propagation is broken we would hang or get no data.
+	conn.SetReadDeadline(time.Now().Add(2 * time.Second))
+	buf, err := io.ReadAll(conn)
+	if err != nil {
+		t.Fatalf("reading server response: %v", err)
+	}
+
+	expected := clientMsg + serverReply
+	if string(buf) != expected {
+		t.Errorf("expected %q, got %q", expected, string(buf))
+	}
+}