Function TestConn_UsedAtConcurrentUpdates

internal/pool/conn_used_at_test.go:175–222

TestConn_UsedAtConcurrentUpdates verifies that usedAt updates are thread-safe

(t *testing.T)

// TestConn_UsedAtConcurrentUpdates verifies that usedAt updates are thread-safe
func TestConn_UsedAtConcurrentUpdates(t *testing.T) {
	// Create a mock connection
	server, client := net.Pipe()
	defer server.Close()
	defer client.Close()

	cn := NewConn(client)
	defer cn.Close()

	ctx := context.Background()
	const numGoroutines = 10
	const numIterations = 10

	// Launch multiple goroutines that perform operations concurrently
	done := make(chan bool, numGoroutines)
	for i := 0; i < numGoroutines; i++ {
		go func() {
			for j := 0; j < numIterations; j++ {
				// Alternate between read and write operations
				if j%2 == 0 {
					_ = cn.WithReader(ctx, time.Second, func(rd *proto.Reader) error {
						return nil
					})
				} else {
					_ = cn.WithWriter(ctx, time.Second, func(wr *proto.Writer) error {
						return nil
					})
				}
				time.Sleep(time.Millisecond)
			}
			done <- true
		}()
	}

	// Wait for all goroutines to complete
	for i := 0; i < numGoroutines; i++ {
		<-done
	}

	// Verify that usedAt was updated (should be recent)
	usedAt := cn.UsedAt()
	timeSinceUsed := time.Since(usedAt)

	// Should be very recent (within last second)
	if timeSinceUsed > time.Second {
		t.Errorf("Expected usedAt to be recent, but it was %v ago", timeSinceUsed)
	}
}

// TestConn_UsedAtPrecision verifies that usedAt has 50ms precision (not nanosecond)
func TestConn_UsedAtPrecision(t *testing.T) {