From 72be861aa2ab8be28fd92008e529c42082a552cb Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Wed, 11 Sep 2024 15:49:02 +0800 Subject: [PATCH] logging: migrate tests away from Ginkgo (#4641) --- logging/connection_tracer_test.go | 350 ++++++++++++++++++++++++++++++ logging/logging_suite_test.go | 24 -- logging/multiplex_test.go | 291 ------------------------- logging/packet_header_test.go | 86 +++++--- logging/tracer_test.go | 91 ++++++++ 5 files changed, 494 insertions(+), 348 deletions(-) create mode 100644 logging/connection_tracer_test.go delete mode 100644 logging/logging_suite_test.go delete mode 100644 logging/multiplex_test.go create mode 100644 logging/tracer_test.go diff --git a/logging/connection_tracer_test.go b/logging/connection_tracer_test.go new file mode 100644 index 00000000..fa79f6a5 --- /dev/null +++ b/logging/connection_tracer_test.go @@ -0,0 +1,350 @@ +package logging_test + +import ( + "errors" + "net" + "testing" + "time" + + mocklogging "github.com/quic-go/quic-go/internal/mocks/logging" + "github.com/quic-go/quic-go/internal/protocol" + "github.com/quic-go/quic-go/internal/wire" + "github.com/quic-go/quic-go/logging" + + "go.uber.org/mock/gomock" +) + +func TestConnectionTracerStartedConnection(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + local := &net.UDPAddr{IP: net.IPv4(1, 2, 3, 4)} + remote := &net.UDPAddr{IP: net.IPv4(4, 3, 2, 1)} + dest := protocol.ParseConnectionID([]byte{1, 2, 3, 4}) + src := protocol.ParseConnectionID([]byte{4, 3, 2, 1}) + tr1.EXPECT().StartedConnection(local, remote, src, dest) + tr2.EXPECT().StartedConnection(local, remote, src, dest) + tracer.StartedConnection(local, remote, src, dest) +} + +func TestConnectionTracerNegotiatedVersion(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + chosen := protocol.Version2 + client := []protocol.Version{protocol.Version1} + server := []protocol.Version{13, 37} + tr1.EXPECT().NegotiatedVersion(chosen, client, server) + tr2.EXPECT().NegotiatedVersion(chosen, client, server) + tracer.NegotiatedVersion(chosen, client, server) +} + +func TestConnectionTracerClosedConnection(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + e := errors.New("test err") + tr1.EXPECT().ClosedConnection(e) + tr2.EXPECT().ClosedConnection(e) + tracer.ClosedConnection(e) +} + +func TestConnectionTracerSentTransportParameters(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tp := &wire.TransportParameters{InitialMaxData: 1337} + tr1.EXPECT().SentTransportParameters(tp) + tr2.EXPECT().SentTransportParameters(tp) + tracer.SentTransportParameters(tp) +} + +func TestConnectionTracerReceivedTransportParameters(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tp := &wire.TransportParameters{InitialMaxData: 1337} + tr1.EXPECT().ReceivedTransportParameters(tp) + tr2.EXPECT().ReceivedTransportParameters(tp) + tracer.ReceivedTransportParameters(tp) +} + +func TestConnectionTracerRestoredTransportParameters(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tp := &wire.TransportParameters{InitialMaxData: 1337} + tr1.EXPECT().RestoredTransportParameters(tp) + tr2.EXPECT().RestoredTransportParameters(tp) + tracer.RestoredTransportParameters(tp) +} + +func TestConnectionTracerSentLongHeaderPacket(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + hdr := &logging.ExtendedHeader{Header: logging.Header{DestConnectionID: protocol.ParseConnectionID([]byte{1, 2, 3})}} + ack := &logging.AckFrame{AckRanges: []logging.AckRange{{Smallest: 1, Largest: 10}}} + ping := &logging.PingFrame{} + tr1.EXPECT().SentLongHeaderPacket(hdr, logging.ByteCount(1337), logging.ECTNot, ack, []logging.Frame{ping}) + tr2.EXPECT().SentLongHeaderPacket(hdr, logging.ByteCount(1337), logging.ECTNot, ack, []logging.Frame{ping}) + tracer.SentLongHeaderPacket(hdr, 1337, logging.ECTNot, ack, []logging.Frame{ping}) +} + +func TestConnectionTracerSentShortHeaderPacket(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + hdr := &logging.ShortHeader{DestConnectionID: protocol.ParseConnectionID([]byte{1, 2, 3})} + ack := &logging.AckFrame{AckRanges: []logging.AckRange{{Smallest: 1, Largest: 10}}} + ping := &logging.PingFrame{} + tr1.EXPECT().SentShortHeaderPacket(hdr, logging.ByteCount(1337), logging.ECNCE, ack, []logging.Frame{ping}) + tr2.EXPECT().SentShortHeaderPacket(hdr, logging.ByteCount(1337), logging.ECNCE, ack, []logging.Frame{ping}) + tracer.SentShortHeaderPacket(hdr, 1337, logging.ECNCE, ack, []logging.Frame{ping}) +} + +func TestConnectionTracerReceivedVersionNegotiationPacket(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + src := logging.ArbitraryLenConnectionID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13} + dest := logging.ArbitraryLenConnectionID{1, 2, 3, 4} + tr1.EXPECT().ReceivedVersionNegotiationPacket(dest, src, []logging.Version{1337}) + tr2.EXPECT().ReceivedVersionNegotiationPacket(dest, src, []logging.Version{1337}) + tracer.ReceivedVersionNegotiationPacket(dest, src, []logging.Version{1337}) +} + +func TestConnectionTracerReceivedRetry(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + hdr := &logging.Header{DestConnectionID: protocol.ParseConnectionID([]byte{1, 2, 3})} + tr1.EXPECT().ReceivedRetry(hdr) + tr2.EXPECT().ReceivedRetry(hdr) + tracer.ReceivedRetry(hdr) +} + +func TestConnectionTracerReceivedLongHeaderPacket(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + hdr := &logging.ExtendedHeader{Header: logging.Header{DestConnectionID: protocol.ParseConnectionID([]byte{1, 2, 3})}} + ping := &logging.PingFrame{} + tr1.EXPECT().ReceivedLongHeaderPacket(hdr, logging.ByteCount(1337), logging.ECT1, []logging.Frame{ping}) + tr2.EXPECT().ReceivedLongHeaderPacket(hdr, logging.ByteCount(1337), logging.ECT1, []logging.Frame{ping}) + tracer.ReceivedLongHeaderPacket(hdr, 1337, logging.ECT1, []logging.Frame{ping}) +} + +func TestConnectionTracerReceivedShortHeaderPacket(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + hdr := &logging.ShortHeader{DestConnectionID: protocol.ParseConnectionID([]byte{1, 2, 3})} + ping := &logging.PingFrame{} + tr1.EXPECT().ReceivedShortHeaderPacket(hdr, logging.ByteCount(1337), logging.ECT0, []logging.Frame{ping}) + tr2.EXPECT().ReceivedShortHeaderPacket(hdr, logging.ByteCount(1337), logging.ECT0, []logging.Frame{ping}) + tracer.ReceivedShortHeaderPacket(hdr, 1337, logging.ECT0, []logging.Frame{ping}) +} + +func TestConnectionTracerBufferedPacket(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().BufferedPacket(logging.PacketTypeHandshake, logging.ByteCount(1337)) + tr2.EXPECT().BufferedPacket(logging.PacketTypeHandshake, logging.ByteCount(1337)) + tracer.BufferedPacket(logging.PacketTypeHandshake, 1337) +} + +func TestConnectionTracerDroppedPacket(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().DroppedPacket(logging.PacketTypeInitial, logging.PacketNumber(42), logging.ByteCount(1337), logging.PacketDropHeaderParseError) + tr2.EXPECT().DroppedPacket(logging.PacketTypeInitial, logging.PacketNumber(42), logging.ByteCount(1337), logging.PacketDropHeaderParseError) + tracer.DroppedPacket(logging.PacketTypeInitial, 42, 1337, logging.PacketDropHeaderParseError) +} + +func TestConnectionTracerUpdatedMTU(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().UpdatedMTU(logging.ByteCount(1337), true) + tr2.EXPECT().UpdatedMTU(logging.ByteCount(1337), true) + tracer.UpdatedMTU(1337, true) +} + +func TestConnectionTracerUpdatedCongestionState(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().UpdatedCongestionState(logging.CongestionStateRecovery) + tr2.EXPECT().UpdatedCongestionState(logging.CongestionStateRecovery) + tracer.UpdatedCongestionState(logging.CongestionStateRecovery) +} + +func TestConnectionTracerUpdatedMetrics(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + rttStats := &logging.RTTStats{} + rttStats.UpdateRTT(time.Second, 0, time.Now()) + tr1.EXPECT().UpdatedMetrics(rttStats, logging.ByteCount(1337), logging.ByteCount(42), 13) + tr2.EXPECT().UpdatedMetrics(rttStats, logging.ByteCount(1337), logging.ByteCount(42), 13) + tracer.UpdatedMetrics(rttStats, 1337, 42, 13) +} + +func TestConnectionTracerAcknowledgedPacket(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().AcknowledgedPacket(logging.EncryptionHandshake, logging.PacketNumber(42)) + tr2.EXPECT().AcknowledgedPacket(logging.EncryptionHandshake, logging.PacketNumber(42)) + tracer.AcknowledgedPacket(logging.EncryptionHandshake, 42) +} + +func TestConnectionTracerLostPacket(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().LostPacket(logging.EncryptionHandshake, logging.PacketNumber(42), logging.PacketLossReorderingThreshold) + tr2.EXPECT().LostPacket(logging.EncryptionHandshake, logging.PacketNumber(42), logging.PacketLossReorderingThreshold) + tracer.LostPacket(logging.EncryptionHandshake, 42, logging.PacketLossReorderingThreshold) +} + +func TestConnectionTracerUpdatedPTOCount(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().UpdatedPTOCount(uint32(88)) + tr2.EXPECT().UpdatedPTOCount(uint32(88)) + tracer.UpdatedPTOCount(88) +} + +func TestConnectionTracerUpdatedKeyFromTLS(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().UpdatedKeyFromTLS(logging.EncryptionHandshake, logging.PerspectiveClient) + tr2.EXPECT().UpdatedKeyFromTLS(logging.EncryptionHandshake, logging.PerspectiveClient) + tracer.UpdatedKeyFromTLS(logging.EncryptionHandshake, logging.PerspectiveClient) +} + +func TestConnectionTracerUpdatedKey(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().UpdatedKey(logging.KeyPhase(42), true) + tr2.EXPECT().UpdatedKey(logging.KeyPhase(42), true) + tracer.UpdatedKey(logging.KeyPhase(42), true) +} + +func TestConnectionTracerDroppedEncryptionLevel(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().DroppedEncryptionLevel(logging.EncryptionHandshake) + tr2.EXPECT().DroppedEncryptionLevel(logging.EncryptionHandshake) + tracer.DroppedEncryptionLevel(logging.EncryptionHandshake) +} + +func TestConnectionTracerDroppedKey(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().DroppedKey(logging.KeyPhase(123)) + tr2.EXPECT().DroppedKey(logging.KeyPhase(123)) + tracer.DroppedKey(123) +} + +func TestConnectionTracerSetLossTimer(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + now := time.Now() + tr1.EXPECT().SetLossTimer(logging.TimerTypePTO, logging.EncryptionHandshake, now) + tr2.EXPECT().SetLossTimer(logging.TimerTypePTO, logging.EncryptionHandshake, now) + tracer.SetLossTimer(logging.TimerTypePTO, logging.EncryptionHandshake, now) +} + +func TestConnectionTracerLossTimerExpired(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().LossTimerExpired(logging.TimerTypePTO, logging.EncryptionHandshake) + tr2.EXPECT().LossTimerExpired(logging.TimerTypePTO, logging.EncryptionHandshake) + tracer.LossTimerExpired(logging.TimerTypePTO, logging.EncryptionHandshake) +} + +func TestConnectionTracerLossTimerCanceled(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().LossTimerCanceled() + tr2.EXPECT().LossTimerCanceled() + tracer.LossTimerCanceled() +} + +func TestConnectionTracerClose(t *testing.T) { + ctrl := gomock.NewController(t) + t1, tr1 := mocklogging.NewMockConnectionTracer(ctrl) + t2, tr2 := mocklogging.NewMockConnectionTracer(ctrl) + tracer := logging.NewMultiplexedConnectionTracer(t1, t2) + + tr1.EXPECT().Close() + tr2.EXPECT().Close() + tracer.Close() +} diff --git a/logging/logging_suite_test.go b/logging/logging_suite_test.go deleted file mode 100644 index e595313d..00000000 --- a/logging/logging_suite_test.go +++ /dev/null @@ -1,24 +0,0 @@ -package logging_test - -import ( - "testing" - - . "github.com/onsi/ginkgo/v2" - . "github.com/onsi/gomega" - "go.uber.org/mock/gomock" -) - -func TestLogging(t *testing.T) { - RegisterFailHandler(Fail) - RunSpecs(t, "Logging Suite") -} - -var mockCtrl *gomock.Controller - -var _ = BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) -}) - -var _ = AfterEach(func() { - mockCtrl.Finish() -}) diff --git a/logging/multiplex_test.go b/logging/multiplex_test.go deleted file mode 100644 index cf78dcf1..00000000 --- a/logging/multiplex_test.go +++ /dev/null @@ -1,291 +0,0 @@ -package logging_test - -import ( - "errors" - "net" - "time" - - mocklogging "github.com/quic-go/quic-go/internal/mocks/logging" - "github.com/quic-go/quic-go/internal/protocol" - "github.com/quic-go/quic-go/internal/wire" - . "github.com/quic-go/quic-go/logging" - - . "github.com/onsi/ginkgo/v2" - . "github.com/onsi/gomega" -) - -var _ = Describe("Tracing", func() { - Context("Tracer", func() { - It("returns a nil tracer if no tracers are passed in", func() { - Expect(NewMultiplexedTracer()).To(BeNil()) - }) - - It("returns the raw tracer if only one tracer is passed in", func() { - tr := &Tracer{} - tracer := NewMultiplexedTracer(tr) - Expect(tracer).To(Equal(tr)) - }) - - Context("tracing events", func() { - var ( - tracer *Tracer - tr1, tr2 *mocklogging.MockTracer - ) - - BeforeEach(func() { - var t1, t2 *Tracer - t1, tr1 = mocklogging.NewMockTracer(mockCtrl) - t2, tr2 = mocklogging.NewMockTracer(mockCtrl) - tracer = NewMultiplexedTracer(t1, t2, &Tracer{}) - }) - - It("traces the PacketSent event", func() { - remote := &net.UDPAddr{IP: net.IPv4(4, 3, 2, 1)} - hdr := &Header{DestConnectionID: protocol.ParseConnectionID([]byte{1, 2, 3})} - f := &MaxDataFrame{MaximumData: 1337} - tr1.EXPECT().SentPacket(remote, hdr, ByteCount(1024), []Frame{f}) - tr2.EXPECT().SentPacket(remote, hdr, ByteCount(1024), []Frame{f}) - tracer.SentPacket(remote, hdr, 1024, []Frame{f}) - }) - - It("traces the PacketSent event", func() { - remote := &net.UDPAddr{IP: net.IPv4(4, 3, 2, 1)} - src := ArbitraryLenConnectionID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13} - dest := ArbitraryLenConnectionID{1, 2, 3, 4} - versions := []Version{1, 2, 3} - tr1.EXPECT().SentVersionNegotiationPacket(remote, dest, src, versions) - tr2.EXPECT().SentVersionNegotiationPacket(remote, dest, src, versions) - tracer.SentVersionNegotiationPacket(remote, dest, src, versions) - }) - - It("traces the PacketDropped event", func() { - remote := &net.UDPAddr{IP: net.IPv4(4, 3, 2, 1)} - tr1.EXPECT().DroppedPacket(remote, PacketTypeRetry, ByteCount(1024), PacketDropDuplicate) - tr2.EXPECT().DroppedPacket(remote, PacketTypeRetry, ByteCount(1024), PacketDropDuplicate) - tracer.DroppedPacket(remote, PacketTypeRetry, 1024, PacketDropDuplicate) - }) - - It("traces the Debug event", func() { - tr1.EXPECT().Debug("foo", "bar") - tr2.EXPECT().Debug("foo", "bar") - tracer.Debug("foo", "bar") - }) - - It("traces the Close event", func() { - tr1.EXPECT().Close() - tr2.EXPECT().Close() - tracer.Close() - }) - }) - }) - - Context("Connection Tracer", func() { - var ( - tracer *ConnectionTracer - tr1 *mocklogging.MockConnectionTracer - tr2 *mocklogging.MockConnectionTracer - ) - - BeforeEach(func() { - var t1, t2 *ConnectionTracer - t1, tr1 = mocklogging.NewMockConnectionTracer(mockCtrl) - t2, tr2 = mocklogging.NewMockConnectionTracer(mockCtrl) - tracer = NewMultiplexedConnectionTracer(t1, t2) - }) - - It("traces the StartedConnection event", func() { - local := &net.UDPAddr{IP: net.IPv4(1, 2, 3, 4)} - remote := &net.UDPAddr{IP: net.IPv4(4, 3, 2, 1)} - dest := protocol.ParseConnectionID([]byte{1, 2, 3, 4}) - src := protocol.ParseConnectionID([]byte{4, 3, 2, 1}) - tr1.EXPECT().StartedConnection(local, remote, src, dest) - tr2.EXPECT().StartedConnection(local, remote, src, dest) - tracer.StartedConnection(local, remote, src, dest) - }) - - It("traces the NegotiatedVersion event", func() { - chosen := protocol.Version2 - client := []protocol.Version{protocol.Version1} - server := []protocol.Version{13, 37} - tr1.EXPECT().NegotiatedVersion(chosen, client, server) - tr2.EXPECT().NegotiatedVersion(chosen, client, server) - tracer.NegotiatedVersion(chosen, client, server) - }) - - It("traces the ClosedConnection event", func() { - e := errors.New("test err") - tr1.EXPECT().ClosedConnection(e) - tr2.EXPECT().ClosedConnection(e) - tracer.ClosedConnection(e) - }) - - It("traces the SentTransportParameters event", func() { - tp := &wire.TransportParameters{InitialMaxData: 1337} - tr1.EXPECT().SentTransportParameters(tp) - tr2.EXPECT().SentTransportParameters(tp) - tracer.SentTransportParameters(tp) - }) - - It("traces the ReceivedTransportParameters event", func() { - tp := &wire.TransportParameters{InitialMaxData: 1337} - tr1.EXPECT().ReceivedTransportParameters(tp) - tr2.EXPECT().ReceivedTransportParameters(tp) - tracer.ReceivedTransportParameters(tp) - }) - - It("traces the RestoredTransportParameters event", func() { - tp := &wire.TransportParameters{InitialMaxData: 1337} - tr1.EXPECT().RestoredTransportParameters(tp) - tr2.EXPECT().RestoredTransportParameters(tp) - tracer.RestoredTransportParameters(tp) - }) - - It("traces the SentLongHeaderPacket event", func() { - hdr := &ExtendedHeader{Header: Header{DestConnectionID: protocol.ParseConnectionID([]byte{1, 2, 3})}} - ack := &AckFrame{AckRanges: []AckRange{{Smallest: 1, Largest: 10}}} - ping := &PingFrame{} - tr1.EXPECT().SentLongHeaderPacket(hdr, ByteCount(1337), ECTNot, ack, []Frame{ping}) - tr2.EXPECT().SentLongHeaderPacket(hdr, ByteCount(1337), ECTNot, ack, []Frame{ping}) - tracer.SentLongHeaderPacket(hdr, 1337, ECTNot, ack, []Frame{ping}) - }) - - It("traces the SentShortHeaderPacket event", func() { - hdr := &ShortHeader{DestConnectionID: protocol.ParseConnectionID([]byte{1, 2, 3})} - ack := &AckFrame{AckRanges: []AckRange{{Smallest: 1, Largest: 10}}} - ping := &PingFrame{} - tr1.EXPECT().SentShortHeaderPacket(hdr, ByteCount(1337), ECNCE, ack, []Frame{ping}) - tr2.EXPECT().SentShortHeaderPacket(hdr, ByteCount(1337), ECNCE, ack, []Frame{ping}) - tracer.SentShortHeaderPacket(hdr, 1337, ECNCE, ack, []Frame{ping}) - }) - - It("traces the ReceivedVersionNegotiationPacket event", func() { - src := ArbitraryLenConnectionID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13} - dest := ArbitraryLenConnectionID{1, 2, 3, 4} - tr1.EXPECT().ReceivedVersionNegotiationPacket(dest, src, []Version{1337}) - tr2.EXPECT().ReceivedVersionNegotiationPacket(dest, src, []Version{1337}) - tracer.ReceivedVersionNegotiationPacket(dest, src, []Version{1337}) - }) - - It("traces the ReceivedRetry event", func() { - hdr := &Header{DestConnectionID: protocol.ParseConnectionID([]byte{1, 2, 3})} - tr1.EXPECT().ReceivedRetry(hdr) - tr2.EXPECT().ReceivedRetry(hdr) - tracer.ReceivedRetry(hdr) - }) - - It("traces the ReceivedLongHeaderPacket event", func() { - hdr := &ExtendedHeader{Header: Header{DestConnectionID: protocol.ParseConnectionID([]byte{1, 2, 3})}} - ping := &PingFrame{} - tr1.EXPECT().ReceivedLongHeaderPacket(hdr, ByteCount(1337), ECT1, []Frame{ping}) - tr2.EXPECT().ReceivedLongHeaderPacket(hdr, ByteCount(1337), ECT1, []Frame{ping}) - tracer.ReceivedLongHeaderPacket(hdr, 1337, ECT1, []Frame{ping}) - }) - - It("traces the ReceivedShortHeaderPacket event", func() { - hdr := &ShortHeader{DestConnectionID: protocol.ParseConnectionID([]byte{1, 2, 3})} - ping := &PingFrame{} - tr1.EXPECT().ReceivedShortHeaderPacket(hdr, ByteCount(1337), ECT0, []Frame{ping}) - tr2.EXPECT().ReceivedShortHeaderPacket(hdr, ByteCount(1337), ECT0, []Frame{ping}) - tracer.ReceivedShortHeaderPacket(hdr, 1337, ECT0, []Frame{ping}) - }) - - It("traces the BufferedPacket event", func() { - tr1.EXPECT().BufferedPacket(PacketTypeHandshake, ByteCount(1337)) - tr2.EXPECT().BufferedPacket(PacketTypeHandshake, ByteCount(1337)) - tracer.BufferedPacket(PacketTypeHandshake, 1337) - }) - - It("traces the DroppedPacket event", func() { - tr1.EXPECT().DroppedPacket(PacketTypeInitial, PacketNumber(42), ByteCount(1337), PacketDropHeaderParseError) - tr2.EXPECT().DroppedPacket(PacketTypeInitial, PacketNumber(42), ByteCount(1337), PacketDropHeaderParseError) - tracer.DroppedPacket(PacketTypeInitial, 42, 1337, PacketDropHeaderParseError) - }) - - It("traces the UpdatedMTU event", func() { - tr1.EXPECT().UpdatedMTU(ByteCount(1337), true) - tr2.EXPECT().UpdatedMTU(ByteCount(1337), true) - tracer.UpdatedMTU(1337, true) - }) - - It("traces the UpdatedCongestionState event", func() { - tr1.EXPECT().UpdatedCongestionState(CongestionStateRecovery) - tr2.EXPECT().UpdatedCongestionState(CongestionStateRecovery) - tracer.UpdatedCongestionState(CongestionStateRecovery) - }) - - It("traces the UpdatedMetrics event", func() { - rttStats := &RTTStats{} - rttStats.UpdateRTT(time.Second, 0, time.Now()) - tr1.EXPECT().UpdatedMetrics(rttStats, ByteCount(1337), ByteCount(42), 13) - tr2.EXPECT().UpdatedMetrics(rttStats, ByteCount(1337), ByteCount(42), 13) - tracer.UpdatedMetrics(rttStats, 1337, 42, 13) - }) - - It("traces the AcknowledgedPacket event", func() { - tr1.EXPECT().AcknowledgedPacket(EncryptionHandshake, PacketNumber(42)) - tr2.EXPECT().AcknowledgedPacket(EncryptionHandshake, PacketNumber(42)) - tracer.AcknowledgedPacket(EncryptionHandshake, 42) - }) - - It("traces the LostPacket event", func() { - tr1.EXPECT().LostPacket(EncryptionHandshake, PacketNumber(42), PacketLossReorderingThreshold) - tr2.EXPECT().LostPacket(EncryptionHandshake, PacketNumber(42), PacketLossReorderingThreshold) - tracer.LostPacket(EncryptionHandshake, 42, PacketLossReorderingThreshold) - }) - - It("traces the UpdatedPTOCount event", func() { - tr1.EXPECT().UpdatedPTOCount(uint32(88)) - tr2.EXPECT().UpdatedPTOCount(uint32(88)) - tracer.UpdatedPTOCount(88) - }) - - It("traces the UpdatedKeyFromTLS event", func() { - tr1.EXPECT().UpdatedKeyFromTLS(EncryptionHandshake, PerspectiveClient) - tr2.EXPECT().UpdatedKeyFromTLS(EncryptionHandshake, PerspectiveClient) - tracer.UpdatedKeyFromTLS(EncryptionHandshake, PerspectiveClient) - }) - - It("traces the UpdatedKey event", func() { - tr1.EXPECT().UpdatedKey(KeyPhase(42), true) - tr2.EXPECT().UpdatedKey(KeyPhase(42), true) - tracer.UpdatedKey(KeyPhase(42), true) - }) - - It("traces the DroppedEncryptionLevel event", func() { - tr1.EXPECT().DroppedEncryptionLevel(EncryptionHandshake) - tr2.EXPECT().DroppedEncryptionLevel(EncryptionHandshake) - tracer.DroppedEncryptionLevel(EncryptionHandshake) - }) - - It("traces the DroppedKey event", func() { - tr1.EXPECT().DroppedKey(KeyPhase(123)) - tr2.EXPECT().DroppedKey(KeyPhase(123)) - tracer.DroppedKey(123) - }) - - It("traces the SetLossTimer event", func() { - now := time.Now() - tr1.EXPECT().SetLossTimer(TimerTypePTO, EncryptionHandshake, now) - tr2.EXPECT().SetLossTimer(TimerTypePTO, EncryptionHandshake, now) - tracer.SetLossTimer(TimerTypePTO, EncryptionHandshake, now) - }) - - It("traces the LossTimerExpired event", func() { - tr1.EXPECT().LossTimerExpired(TimerTypePTO, EncryptionHandshake) - tr2.EXPECT().LossTimerExpired(TimerTypePTO, EncryptionHandshake) - tracer.LossTimerExpired(TimerTypePTO, EncryptionHandshake) - }) - - It("traces the LossTimerCanceled event", func() { - tr1.EXPECT().LossTimerCanceled() - tr2.EXPECT().LossTimerCanceled() - tracer.LossTimerCanceled() - }) - - It("traces the Close event", func() { - tr1.EXPECT().Close() - tr2.EXPECT().Close() - tracer.Close() - }) - }) -}) diff --git a/logging/packet_header_test.go b/logging/packet_header_test.go index 66810a9c..bd5e70b8 100644 --- a/logging/packet_header_test.go +++ b/logging/packet_header_test.go @@ -1,50 +1,70 @@ package logging_test import ( + "testing" + "github.com/quic-go/quic-go/internal/protocol" "github.com/quic-go/quic-go/internal/wire" - . "github.com/quic-go/quic-go/logging" - - . "github.com/onsi/ginkgo/v2" - . "github.com/onsi/gomega" + "github.com/quic-go/quic-go/logging" + "github.com/stretchr/testify/require" ) -var _ = Describe("Packet Header", func() { - Context("determining the packet type from the header", func() { - It("recognizes Initial packets", func() { - Expect(PacketTypeFromHeader(&wire.Header{ +func TestPacketTypeFromHeader(t *testing.T) { + testCases := []struct { + name string + header *wire.Header + expectedType logging.PacketType + }{ + { + name: "Initial packet", + header: &wire.Header{ Type: protocol.PacketTypeInitial, Version: protocol.Version1, - })).To(Equal(PacketTypeInitial)) - }) - - It("recognizes Handshake packets", func() { - Expect(PacketTypeFromHeader(&wire.Header{ + }, + expectedType: logging.PacketTypeInitial, + }, + { + name: "Handshake packet", + header: &wire.Header{ Type: protocol.PacketTypeHandshake, Version: protocol.Version1, - })).To(Equal(PacketTypeHandshake)) - }) - - It("recognizes Retry packets", func() { - Expect(PacketTypeFromHeader(&wire.Header{ + }, + expectedType: logging.PacketTypeHandshake, + }, + { + name: "Retry packet", + header: &wire.Header{ Type: protocol.PacketTypeRetry, Version: protocol.Version1, - })).To(Equal(PacketTypeRetry)) - }) - - It("recognizes 0-RTT packets", func() { - Expect(PacketTypeFromHeader(&wire.Header{ + }, + expectedType: logging.PacketTypeRetry, + }, + { + name: "0-RTT packet", + header: &wire.Header{ Type: protocol.PacketType0RTT, Version: protocol.Version1, - })).To(Equal(PacketType0RTT)) - }) + }, + expectedType: logging.PacketType0RTT, + }, + { + name: "Version Negotiation packet", + header: &wire.Header{}, + expectedType: logging.PacketTypeVersionNegotiation, + }, + { + name: "Unrecognized packet type", + header: &wire.Header{ + Version: protocol.Version1, + }, + expectedType: logging.PacketTypeNotDetermined, + }, + } - It("recognizes Version Negotiation packets", func() { - Expect(PacketTypeFromHeader(&wire.Header{})).To(Equal(PacketTypeVersionNegotiation)) + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + packetType := logging.PacketTypeFromHeader(tc.header) + require.Equal(t, tc.expectedType, packetType) }) - - It("handles unrecognized packet types", func() { - Expect(PacketTypeFromHeader(&wire.Header{Version: protocol.Version1})).To(Equal(PacketTypeNotDetermined)) - }) - }) -}) + } +} diff --git a/logging/tracer_test.go b/logging/tracer_test.go new file mode 100644 index 00000000..c3641e38 --- /dev/null +++ b/logging/tracer_test.go @@ -0,0 +1,91 @@ +package logging_test + +import ( + "net" + "testing" + + mocklogging "github.com/quic-go/quic-go/internal/mocks/logging" + "github.com/quic-go/quic-go/internal/protocol" + . "github.com/quic-go/quic-go/logging" + + "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" +) + +func TestNilTracerWhenEmpty(t *testing.T) { + require.Nil(t, NewMultiplexedTracer()) +} + +func TestSingleTracer(t *testing.T) { + tr := &Tracer{} + tracer := NewMultiplexedTracer(tr) + require.Equal(t, tr, tracer) +} + +func TestTracerPacketSent(t *testing.T) { + ctrl := gomock.NewController(t) + + t1, tr1 := mocklogging.NewMockTracer(ctrl) + t2, tr2 := mocklogging.NewMockTracer(ctrl) + tracer := NewMultiplexedTracer(t1, t2, &Tracer{}) + + remote := &net.UDPAddr{IP: net.IPv4(4, 3, 2, 1)} + hdr := &Header{DestConnectionID: protocol.ParseConnectionID([]byte{1, 2, 3})} + f := &MaxDataFrame{MaximumData: 1337} + tr1.EXPECT().SentPacket(remote, hdr, ByteCount(1024), []Frame{f}) + tr2.EXPECT().SentPacket(remote, hdr, ByteCount(1024), []Frame{f}) + tracer.SentPacket(remote, hdr, 1024, []Frame{f}) +} + +func TestTracerVersionNegotiationSent(t *testing.T) { + ctrl := gomock.NewController(t) + + t1, tr1 := mocklogging.NewMockTracer(ctrl) + t2, tr2 := mocklogging.NewMockTracer(ctrl) + tracer := NewMultiplexedTracer(t1, t2, &Tracer{}) + + remote := &net.UDPAddr{IP: net.IPv4(4, 3, 2, 1)} + src := ArbitraryLenConnectionID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13} + dest := ArbitraryLenConnectionID{1, 2, 3, 4} + versions := []Version{1, 2, 3} + tr1.EXPECT().SentVersionNegotiationPacket(remote, dest, src, versions) + tr2.EXPECT().SentVersionNegotiationPacket(remote, dest, src, versions) + tracer.SentVersionNegotiationPacket(remote, dest, src, versions) +} + +func TestTracerPacketDropped(t *testing.T) { + ctrl := gomock.NewController(t) + + t1, tr1 := mocklogging.NewMockTracer(ctrl) + t2, tr2 := mocklogging.NewMockTracer(ctrl) + tracer := NewMultiplexedTracer(t1, t2, &Tracer{}) + + remote := &net.UDPAddr{IP: net.IPv4(4, 3, 2, 1)} + tr1.EXPECT().DroppedPacket(remote, PacketTypeRetry, ByteCount(1024), PacketDropDuplicate) + tr2.EXPECT().DroppedPacket(remote, PacketTypeRetry, ByteCount(1024), PacketDropDuplicate) + tracer.DroppedPacket(remote, PacketTypeRetry, 1024, PacketDropDuplicate) +} + +func TestTracerDebug(t *testing.T) { + ctrl := gomock.NewController(t) + + t1, tr1 := mocklogging.NewMockTracer(ctrl) + t2, tr2 := mocklogging.NewMockTracer(ctrl) + tracer := NewMultiplexedTracer(t1, t2, &Tracer{}) + + tr1.EXPECT().Debug("foo", "bar") + tr2.EXPECT().Debug("foo", "bar") + tracer.Debug("foo", "bar") +} + +func TestTracerClose(t *testing.T) { + ctrl := gomock.NewController(t) + + t1, tr1 := mocklogging.NewMockTracer(ctrl) + t2, tr2 := mocklogging.NewMockTracer(ctrl) + tracer := NewMultiplexedTracer(t1, t2, &Tracer{}) + + tr1.EXPECT().Close() + tr2.EXPECT().Close() + tracer.Close() +}