Function TestConn_UsedAtUpdatedOnWrite

internal/pool/conn_used_at_test.go:56–98

TestConn_UsedAtUpdatedOnWrite verifies that usedAt is updated when writing to connection

(t *testing.T)

// TestConn_UsedAtUpdatedOnWrite verifies that usedAt is updated when writing to connection
func TestConn_UsedAtUpdatedOnWrite(t *testing.T) {
	// Create a mock connection
	server, client := net.Pipe()
	defer server.Close()
	defer client.Close()

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

	// Get initial usedAt time
	initialUsedAt := cn.UsedAt()

	// Wait at least 100ms to ensure time difference (usedAt has ~50ms precision from cached time)
	time.Sleep(100 * time.Millisecond)

	// Simulate a write operation by calling WithWriter
	ctx := context.Background()
	err := cn.WithWriter(ctx, time.Second, func(wr *proto.Writer) error {
		// Don't actually write anything, just trigger the deadline update
		return nil
	})

	if err != nil {
		t.Fatalf("WithWriter failed: %v", err)
	}

	// Get updated usedAt time
	updatedUsedAt := cn.UsedAt()

	// Verify that usedAt was updated
	if !updatedUsedAt.After(initialUsedAt) {
		t.Errorf("Expected usedAt to be updated after write. Initial: %v, Updated: %v",
			initialUsedAt, updatedUsedAt)
	}

	// Verify the difference is reasonable (should be around 100ms, accounting for ~50ms cache precision)
	diff := updatedUsedAt.Sub(initialUsedAt)

	// 50 ms is the cache precision, so we allow up to 110ms difference
	if diff < 45*time.Millisecond || diff > 155*time.Millisecond {
		t.Errorf("Expected usedAt difference to be around 100 (±50ms for cache) (+-5ms for sleep precision), got %v", diff)
	}
}

// TestConn_UsedAtUpdatedOnMultipleOperations verifies that usedAt is updated on each operation
func TestConn_UsedAtUpdatedOnMultipleOperations(t *testing.T) {