fix(a2agrpc): check error returns in pool (errcheck lint)

Author: kuangmi-bit

a2agrpc/v1/pool.go

@@ -105,7 +105,7 @@ func (p *DefaultGRPCConnectionPool) Close() error {
 	defer p.mu.Unlock()
 
 	for url, pc := range p.conns {
-		pc.conn.Close()
+		_ = pc.conn.Close()
 		delete(p.conns, url)
 	}
 	return nil
@@ -125,7 +125,7 @@ func (p *DefaultGRPCConnectionPool) evictExpired() {
 	now := time.Now()
 	for url, pc := range p.conns {
 		if now.Sub(pc.lastUsed) > p.ttl {
-			pc.conn.Close()
+			_ = pc.conn.Close()
 			delete(p.conns, url)
 		}
 	}

a2agrpc/v1/pool_test.go

@@ -25,21 +25,35 @@ import (
 	"google.golang.org/grpc/test/bufconn"
 )
 
-func TestDefaultPool_AcquireCreatesConnection(t *testing.T) {
-	pool := NewDefaultGRPCConnectionPool(1 * time.Minute)
-	defer pool.Close()
-
-	// Start a local gRPC server
+func newBufconnServer(t *testing.T) (*grpc.Server, *bufconn.Listener, func()) {
+	t.Helper()
 	lis := bufconn.Listen(1024 * 1024)
 	srv := grpc.NewServer()
-	go srv.Serve(lis)
-	defer srv.Stop()
+	go func() { _ = srv.Serve(lis) }()
+	return srv, lis, func() { srv.Stop() }
+}
 
-	dialer := func(context.Context, string) (net.Conn, error) {
+func bufconnDialer(lis *bufconn.Listener) func(context.Context, string) (net.Conn, error) {
+	return func(context.Context, string) (net.Conn, error) {
 		return lis.Dial()
 	}
+}
+
+func bufconnOpts(lis *bufconn.Listener) []grpc.DialOption {
+	return []grpc.DialOption{
+		grpc.WithContextDialer(bufconnDialer(lis)),
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+	}
+}
+
+func TestDefaultPool_AcquireCreatesConnection(t *testing.T) {
+	pool := NewDefaultGRPCConnectionPool(1 * time.Minute)
+	defer func() { _ = pool.Close() }()
+
+	_, lis, stop := newBufconnServer(t)
+	defer stop()
 
-	conn, err := pool.Acquire(context.Background(), "bufnet", grpc.WithContextDialer(dialer), grpc.WithTransportCredentials(insecure.NewCredentials()))
+	conn, err := pool.Acquire(context.Background(), "bufnet", bufconnOpts(lis)...)
 	if err != nil {
 		t.Fatalf("Acquire failed: %v", err)
 	}
@@ -54,30 +68,22 @@ func TestDefaultPool_AcquireCreatesConnection(t *testing.T) {
 
 func TestDefaultPool_ReusesConnection(t *testing.T) {
 	pool := NewDefaultGRPCConnectionPool(1 * time.Minute)
-	defer pool.Close()
-
-	lis := bufconn.Listen(1024 * 1024)
-	srv := grpc.NewServer()
-	go srv.Serve(lis)
-	defer srv.Stop()
+	defer func() { _ = pool.Close() }()
 
-	dialer := func(context.Context, string) (net.Conn, error) {
-		return lis.Dial()
-	}
-	opts := []grpc.DialOption{grpc.WithContextDialer(dialer), grpc.WithTransportCredentials(insecure.NewCredentials())}
+	_, lis, stop := newBufconnServer(t)
+	defer stop()
 
-	conn1, err := pool.Acquire(context.Background(), "bufnet", opts...)
+	conn1, err := pool.Acquire(context.Background(), "bufnet", bufconnOpts(lis)...)
 	if err != nil {
 		t.Fatalf("Acquire 1 failed: %v", err)
 	}
-	pool.Release(conn1)
+	_ = pool.Release(conn1)
 
-	conn2, err := pool.Acquire(context.Background(), "bufnet", opts...)
+	conn2, err := pool.Acquire(context.Background(), "bufnet", bufconnOpts(lis)...)
 	if err != nil {
 		t.Fatalf("Acquire 2 failed: %v", err)
 	}
 
-	// Same underlying connection should be reused
 	if conn1 != conn2 {
 		t.Fatal("expected same connection to be reused")
 	}
@@ -89,29 +95,23 @@ func TestDefaultPool_ReusesConnection(t *testing.T) {
 
 func TestDefaultPool_DifferentURLs(t *testing.T) {
 	pool := NewDefaultGRPCConnectionPool(1 * time.Minute)
-	defer pool.Close()
+	defer func() { _ = pool.Close() }()
 
-	lis := bufconn.Listen(1024 * 1024)
-	srv := grpc.NewServer()
-	go srv.Serve(lis)
-	defer srv.Stop()
-
-	dialer := func(context.Context, string) (net.Conn, error) {
-		return lis.Dial()
-	}
-	opts := []grpc.DialOption{grpc.WithContextDialer(dialer), grpc.WithTransportCredentials(insecure.NewCredentials())}
+	_, lis, stop := newBufconnServer(t)
+	defer stop()
+	opts := bufconnOpts(lis)
 
 	conn1, err := pool.Acquire(context.Background(), "agent-a", opts...)
 	if err != nil {
 		t.Fatalf("Acquire agent-a failed: %v", err)
 	}
-	defer pool.Release(conn1)
+	defer func() { _ = pool.Release(conn1) }()
 
 	conn2, err := pool.Acquire(context.Background(), "agent-b", opts...)
 	if err != nil {
 		t.Fatalf("Acquire agent-b failed: %v", err)
 	}
-	defer pool.Release(conn2)
+	defer func() { _ = pool.Release(conn2) }()
 
 	if conn1 == conn2 {
 		t.Fatal("different URLs should not reuse the same connection")
@@ -124,31 +124,24 @@ func TestDefaultPool_DifferentURLs(t *testing.T) {
 
 func TestDefaultPool_TTLEviction(t *testing.T) {
 	pool := NewDefaultGRPCConnectionPool(50 * time.Millisecond)
-	defer pool.Close()
-
-	lis := bufconn.Listen(1024 * 1024)
-	srv := grpc.NewServer()
-	go srv.Serve(lis)
-	defer srv.Stop()
+	defer func() { _ = pool.Close() }()
 
-	dialer := func(context.Context, string) (net.Conn, error) {
-		return lis.Dial()
-	}
-	opts := []grpc.DialOption{grpc.WithContextDialer(dialer), grpc.WithTransportCredentials(insecure.NewCredentials())}
+	_, lis, stop := newBufconnServer(t)
+	defer stop()
+	opts := bufconnOpts(lis)
 
 	conn1, err := pool.Acquire(context.Background(), "bufnet", opts...)
 	if err != nil {
 		t.Fatalf("Acquire failed: %v", err)
 	}
-	pool.Release(conn1)
+	_ = pool.Release(conn1)
 
 	if n := pool.Len(); n != 1 {
 		t.Fatalf("expected 1 pooled connection before TTL, got %d", n)
 	}
 
 	time.Sleep(100 * time.Millisecond)
 
-	// Next Acquire should evict the expired connection and create a new one
 	conn2, err := pool.Acquire(context.Background(), "bufnet", opts...)
 	if err != nil {
 		t.Fatalf("Acquire after TTL failed: %v", err)
@@ -165,23 +158,17 @@ func TestDefaultPool_TTLEviction(t *testing.T) {
 
 func TestDefaultPool_ZeroTTLNeverEvicts(t *testing.T) {
 	pool := NewDefaultGRPCConnectionPool(0)
-	defer pool.Close()
+	defer func() { _ = pool.Close() }()
 
-	lis := bufconn.Listen(1024 * 1024)
-	srv := grpc.NewServer()
-	go srv.Serve(lis)
-	defer srv.Stop()
-
-	dialer := func(context.Context, string) (net.Conn, error) {
-		return lis.Dial()
-	}
-	opts := []grpc.DialOption{grpc.WithContextDialer(dialer), grpc.WithTransportCredentials(insecure.NewCredentials())}
+	_, lis, stop := newBufconnServer(t)
+	defer stop()
+	opts := bufconnOpts(lis)
 
 	conn1, err := pool.Acquire(context.Background(), "bufnet", opts...)
 	if err != nil {
 		t.Fatalf("Acquire failed: %v", err)
 	}
-	pool.Release(conn1)
+	_ = pool.Release(conn1)
 
 	time.Sleep(50 * time.Millisecond)
 
@@ -197,24 +184,16 @@ func TestDefaultPool_ZeroTTLNeverEvicts(t *testing.T) {
 
 func TestDefaultPool_Release(t *testing.T) {
 	pool := NewDefaultGRPCConnectionPool(1 * time.Minute)
-	defer pool.Close()
+	defer func() { _ = pool.Close() }()
 
-	lis := bufconn.Listen(1024 * 1024)
-	srv := grpc.NewServer()
-	go srv.Serve(lis)
-	defer srv.Stop()
-
-	dialer := func(context.Context, string) (net.Conn, error) {
-		return lis.Dial()
-	}
-	opts := []grpc.DialOption{grpc.WithContextDialer(dialer), grpc.WithTransportCredentials(insecure.NewCredentials())}
+	_, lis, stop := newBufconnServer(t)
+	defer stop()
 
-	conn, err := pool.Acquire(context.Background(), "bufnet", opts...)
+	conn, err := pool.Acquire(context.Background(), "bufnet", bufconnOpts(lis)...)
 	if err != nil {
 		t.Fatalf("Acquire failed: %v", err)
 	}
 
-	// Release should succeed even for a connection not in the map (e.g., externally provided)
 	if err := pool.Release(conn); err != nil {
 		t.Fatalf("Release failed: %v", err)
 	}