congestion: migrate the pacer tests away from Ginkgo (#4929)

internal/congestion/pacer_test.go

@@ -2,151 +2,116 @@ package congestion
 
 import (
 	"math/rand"
+	"testing"
 	"time"
 
-	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/stretchr/testify/require"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
 )
 
-var _ = Describe("Pacer", func() {
+func TestPacerPacing(t *testing.T) {
-	var p *pacer
+	bandwidth := 50 * initialMaxDatagramSize // 50 full-size packets per second
+	p := newPacer(func() Bandwidth { return Bandwidth(bandwidth) * BytesPerSecond * 4 / 5 })
+	now := time.Now()
+	require.Zero(t, p.TimeUntilSend())
+	budget := p.Budget(now)
+	require.Equal(t, maxBurstSizePackets*initialMaxDatagramSize, budget)
 
-	const packetsPerSecond = 50
+	// consume the initial budget by sending packets
-	var bandwidth uint64 // in bytes/s
+	for budget > 0 {
-
+		require.Zero(t, p.TimeUntilSend())
-	BeforeEach(func() {
+		require.Equal(t, budget, p.Budget(now))
-		bandwidth = uint64(packetsPerSecond * initialMaxDatagramSize) // 50 full-size packets per second
+		p.SentPacket(now, initialMaxDatagramSize)
-		// The pacer will multiply the bandwidth with 1.25 to achieve a slightly higher pacing speed.
+		budget -= initialMaxDatagramSize
-		// For the tests, cancel out this factor, so we can do the math using the exact bandwidth.
-		p = newPacer(func() Bandwidth { return Bandwidth(bandwidth) * BytesPerSecond * 4 / 5 })
-	})
-
-	It("allows a burst at the beginning", func() {
-		t := time.Now()
-		Expect(p.TimeUntilSend()).To(BeZero())
-		Expect(p.Budget(t)).To(BeEquivalentTo(maxBurstSizePackets * initialMaxDatagramSize))
-	})
-
-	It("allows a big burst for high pacing rates", func() {
-		t := time.Now()
-		bandwidth = uint64(10000 * packetsPerSecond * initialMaxDatagramSize)
-		Expect(p.TimeUntilSend()).To(BeZero())
-		Expect(p.Budget(t)).To(BeNumerically(">", maxBurstSizePackets*initialMaxDatagramSize))
-	})
-
-	It("reduces the budget when sending packets", func() {
-		t := time.Now()
-		budget := p.Budget(t)
-		for budget > 0 {
-			Expect(p.TimeUntilSend()).To(BeZero())
-			Expect(p.Budget(t)).To(Equal(budget))
-			p.SentPacket(t, initialMaxDatagramSize)
-			budget -= initialMaxDatagramSize
-		}
-		Expect(p.Budget(t)).To(BeZero())
-		Expect(p.TimeUntilSend()).ToNot(BeZero())
-	})
-
-	sendBurst := func(t time.Time) {
-		for p.Budget(t) > 0 {
-			p.SentPacket(t, initialMaxDatagramSize)
-		}
 	}
 
-	It("paces packets after a burst", func() {
+	// now packets are being paced
-		t := time.Now()
+	for i := 0; i < 5; i++ {
-		sendBurst(t)
+		require.Zero(t, p.Budget(now))
-		// send 100 exactly paced packets
+		nextPacket := p.TimeUntilSend()
-		for i := 0; i < 100; i++ {
+		require.NotZero(t, nextPacket)
-			t2 := p.TimeUntilSend()
+		require.Equal(t, time.Second/50, nextPacket.Sub(now))
-			Expect(t2.Sub(t)).To(BeNumerically("~", time.Second/packetsPerSecond, time.Nanosecond))
+		now = nextPacket
-			Expect(p.Budget(t2)).To(BeEquivalentTo(initialMaxDatagramSize))
+		p.SentPacket(now, initialMaxDatagramSize)
-			p.SentPacket(t2, initialMaxDatagramSize)
+	}
-			t = t2
-		}
-	})
 
-	It("accounts for non-full-size packets", func() {
+	nextPacket := p.TimeUntilSend()
-		t := time.Now()
+	require.Equal(t, time.Second/50, nextPacket.Sub(now))
-		sendBurst(t)
+	// send this packet a bit later, simulating timer delay
-		t2 := p.TimeUntilSend()
+	p.SentPacket(nextPacket.Add(time.Millisecond), initialMaxDatagramSize)
-		Expect(t2.Sub(t)).To(BeNumerically("~", time.Second/packetsPerSecond, time.Nanosecond))
+	// the next packet should be paced again, without a delay
-		// send a half-full packet
+	require.Equal(t, time.Second/50, p.TimeUntilSend().Sub(nextPacket))
-		Expect(p.Budget(t2)).To(BeEquivalentTo(initialMaxDatagramSize))
-		size := initialMaxDatagramSize / 2
-		p.SentPacket(t2, size)
-		Expect(p.Budget(t2)).To(Equal(initialMaxDatagramSize - size))
-		Expect(p.TimeUntilSend()).To(BeTemporally("~", t2.Add(time.Second/packetsPerSecond/2), time.Nanosecond))
-	})
 
-	It("accumulates budget, if no packets are sent", func() {
+	// now send a half-size packet
-		t := time.Now()
+	now = p.TimeUntilSend()
-		sendBurst(t)
+	p.SentPacket(now, initialMaxDatagramSize/2)
-		t2 := p.TimeUntilSend()
+	require.Equal(t, initialMaxDatagramSize/2, p.Budget(now))
-		Expect(t2).To(BeTemporally(">", t))
+	require.Equal(t, time.Second/100, p.TimeUntilSend().Sub(now))
-		// wait for 5 times the duration
+	p.SentPacket(p.TimeUntilSend(), initialMaxDatagramSize/2)
-		Expect(p.Budget(t.Add(5 * t2.Sub(t)))).To(BeEquivalentTo(5 * initialMaxDatagramSize))
-	})
 
-	It("accumulates budget, if no packets are sent, for larger packet sizes", func() {
+	now = p.TimeUntilSend()
-		t := time.Now()
+	// budget accumulates if no packets are sent for a while
-		sendBurst(t)
+	// we should have accumulated budget to send a burst now
-		const packetSize = initialMaxDatagramSize + 200
+	require.Equal(t, 5*initialMaxDatagramSize, p.Budget(now.Add(4*time.Second/50)))
-		p.SetMaxDatagramSize(packetSize)
+	// but the budget is capped at the max burst size
-		t2 := p.TimeUntilSend()
+	require.Equal(t, maxBurstSizePackets*initialMaxDatagramSize, p.Budget(now.Add(time.Hour)))
-		Expect(t2).To(BeTemporally(">", t))
+	p.SentPacket(now, initialMaxDatagramSize)
-		// wait for 5 times the duration
+	require.Zero(t, p.Budget(now))
-		Expect(p.Budget(t.Add(5 * t2.Sub(t)))).To(BeEquivalentTo(5 * packetSize))
-	})
 
-	It("has enough budget for at least one packet when the timer expires", func() {
+	// reduce the bandwidth
-		t := time.Now()
+	bandwidth = 10 * initialMaxDatagramSize // 10 full-size packets per second
-		sendBurst(t)
+	require.Equal(t, time.Second/10, p.TimeUntilSend().Sub(now))
-		for bw := uint64(100); bw < uint64(5*initialMaxDatagramSize); bw++ {
+}
-			bandwidth = bw // reduce the bandwidth to 5 packet per second
-			t2 := p.TimeUntilSend()
-			Expect(t2).To(BeTemporally(">", t))
-			Expect(p.Budget(t2)).To(BeNumerically(">=", initialMaxDatagramSize))
-		}
-	})
 
-	It("never allows bursts larger than the maximum burst size", func() {
+func TestPacerUpdatePacketSize(t *testing.T) {
-		t := time.Now()
+	const bandwidth = 50 * initialMaxDatagramSize // 50 full-size packets per second
-		sendBurst(t)
+	p := newPacer(func() Bandwidth { return Bandwidth(bandwidth) * BytesPerSecond * 4 / 5 })
-		Expect(p.Budget(t.Add(time.Hour))).To(BeEquivalentTo(maxBurstSizePackets * initialMaxDatagramSize))
-	})
 
-	It("never allows bursts larger than the maximum burst size, for larger packets", func() {
+	// consume the initial budget by sending packets
-		t := time.Now()
+	now := time.Now()
-		const packetSize = initialMaxDatagramSize + 200
+	for p.Budget(now) > 0 {
-		p.SetMaxDatagramSize(packetSize)
+		p.SentPacket(now, initialMaxDatagramSize)
-		sendBurst(t)
+	}
-		Expect(p.Budget(t.Add(time.Hour))).To(BeEquivalentTo(maxBurstSizePackets * packetSize))
-	})
 
-	It("changes the bandwidth", func() {
+	require.Equal(t, time.Second/50, p.TimeUntilSend().Sub(now))
-		t := time.Now()
+	// Double the packet size. We now need to wait twice as long to send the next packet.
-		sendBurst(t)
+	const newDatagramSize = 2 * initialMaxDatagramSize
-		bandwidth = uint64(5 * initialMaxDatagramSize) // reduce the bandwidth to 5 packet per second
+	p.SetMaxDatagramSize(newDatagramSize)
-		Expect(p.TimeUntilSend()).To(Equal(t.Add(time.Second / 5)))
+	require.Equal(t, 2*time.Second/50, p.TimeUntilSend().Sub(now))
-	})
 
-	It("doesn't pace faster than the minimum pacing duration", func() {
+	// check that the maximum burst size is updated
-		t := time.Now()
+	require.Equal(t, maxBurstSizePackets*newDatagramSize, p.Budget(now.Add(time.Hour)))
-		sendBurst(t)
+}
-		bandwidth = uint64(1e6 * initialMaxDatagramSize)
-		Expect(p.TimeUntilSend()).To(Equal(t.Add(protocol.MinPacingDelay)))
-		Expect(p.Budget(t.Add(protocol.MinPacingDelay))).To(Equal(protocol.ByteCount(protocol.MinPacingDelay) * initialMaxDatagramSize * 1e6 / 1e9))
-	})
 
-	It("protects against overflows", func() {
+func TestPacerFastPacing(t *testing.T) {
-		p = newPacer(func() Bandwidth { return infBandwidth })
+	const bandwidth = 10000 * initialMaxDatagramSize // 10,000 full-size packets per second
-		t := time.Now()
+	p := newPacer(func() Bandwidth { return Bandwidth(bandwidth) * BytesPerSecond * 4 / 5 })
-		p.SentPacket(t, initialMaxDatagramSize)
+
-		for i := 0; i < 1e5; i++ {
+	// consume the initial budget by sending packets
-			Expect(p.Budget(t.Add(time.Duration(rand.Int63())))).To(BeNumerically(">=", 0))
+	now := time.Now()
-		}
+	for p.Budget(now) > 0 {
-	})
+		p.SentPacket(now, initialMaxDatagramSize)
-})
+	}
+
+	// If we were pacing by packet, we'd expect the next packet to send in 1/10ms.
+	// However, we don't want to arm the pacing timer for less than 1ms,
+	// so we wait for 1ms, and then send 10 packets in a burst.
+	require.Equal(t, time.Millisecond, p.TimeUntilSend().Sub(now))
+	require.Equal(t, 10*initialMaxDatagramSize, p.Budget(now.Add(time.Millisecond)))
+
+	now = now.Add(time.Millisecond)
+	for i := 0; i < 10; i++ {
+		require.NotZero(t, p.Budget(now))
+		p.SentPacket(now, initialMaxDatagramSize)
+	}
+	require.Zero(t, p.Budget(now))
+	require.Equal(t, time.Millisecond, p.TimeUntilSend().Sub(now))
+}
+
+func TestPacerNoOverflows(t *testing.T) {
+	p := newPacer(func() Bandwidth { return infBandwidth })
+	now := time.Now()
+	p.SentPacket(now, initialMaxDatagramSize)
+	for i := 0; i < 1e5; i++ {
+		require.NotZero(t, p.Budget(now.Add(time.Duration(rand.Int63()))))
+	}
+}