ceremonyclient/go-libp2p/p2p/net/swarm/swarm_metrics_test.go
Cassie Heart ebb31fd792 v1.4.19
2024-06-08 11:32:45 +00:00

114 lines
3.3 KiB
Go

//go:build nocover
package swarm
import (
"context"
"crypto/rand"
"net"
"syscall"
"testing"
"time"
"github.com/libp2p/go-libp2p/core/crypto"
"github.com/libp2p/go-libp2p/core/network"
ma "github.com/multiformats/go-multiaddr"
mrand "math/rand"
"github.com/stretchr/testify/require"
)
func BenchmarkMetricsConnOpen(b *testing.B) {
b.ReportAllocs()
quicConnState := network.ConnectionState{Transport: "quic"}
tcpConnState := network.ConnectionState{
StreamMultiplexer: "yamux",
Security: "tls",
Transport: "tcp",
}
_, pub, err := crypto.GenerateEd25519Key(rand.Reader)
require.NoError(b, err)
quicAddr := ma.StringCast("/ip4/1.2.3.4/udp/1/quic-v1")
tcpAddr := ma.StringCast("/ip4/1.2.3.4/tcp/1/")
tr := NewMetricsTracer()
for i := 0; i < b.N; i++ {
switch i % 2 {
case 0:
tr.OpenedConnection(network.DirInbound, pub, quicConnState, quicAddr)
case 1:
tr.OpenedConnection(network.DirInbound, pub, tcpConnState, tcpAddr)
}
}
}
func randItem[T any](items []T) T {
return items[mrand.Intn(len(items))]
}
func TestMetricsNoAllocNoCover(t *testing.T) {
mt := NewMetricsTracer()
connections := []network.ConnectionState{
{StreamMultiplexer: "yamux", Security: "tls", Transport: "tcp", UsedEarlyMuxerNegotiation: true},
{StreamMultiplexer: "yamux", Security: "noise", Transport: "tcp", UsedEarlyMuxerNegotiation: false},
{StreamMultiplexer: "", Security: "", Transport: "quic"},
{StreamMultiplexer: "another-yamux", Security: "noise", Transport: "tcp"},
}
directions := []network.Direction{network.DirInbound, network.DirOutbound}
_, pub1, err := crypto.GenerateEd25519Key(rand.Reader)
require.NoError(t, err)
_, pub2, err := crypto.GenerateEd25519Key(rand.Reader)
require.NoError(t, err)
_, pub3, err := crypto.GenerateEd25519Key(rand.Reader)
require.NoError(t, err)
keys := []crypto.PubKey{pub1, pub2, pub3}
errors := []error{
context.Canceled,
context.DeadlineExceeded,
&net.OpError{Err: syscall.ETIMEDOUT},
}
addrs := []ma.Multiaddr{
ma.StringCast("/ip4/1.2.3.4/tcp/1"),
ma.StringCast("/ip4/1.2.3.4/tcp/2"),
ma.StringCast("/ip4/1.2.3.4/udp/2345"),
}
bhfNames := []string{"udp", "ipv6", "tcp", "icmp"}
bhfState := []blackHoleState{blackHoleStateAllowed, blackHoleStateBlocked}
tests := map[string]func(){
"OpenedConnection": func() {
mt.OpenedConnection(randItem(directions), randItem(keys), randItem(connections), randItem(addrs))
},
"ClosedConnection": func() {
mt.ClosedConnection(randItem(directions), time.Duration(mrand.Intn(100))*time.Second, randItem(connections), randItem(addrs))
},
"CompletedHandshake": func() {
mt.CompletedHandshake(time.Duration(mrand.Intn(100))*time.Second, randItem(connections), randItem(addrs))
},
"FailedDialing": func() { mt.FailedDialing(randItem(addrs), randItem(errors), randItem(errors)) },
"DialCompleted": func() { mt.DialCompleted(mrand.Intn(2) == 1, mrand.Intn(10)) },
"DialRankingDelay": func() { mt.DialRankingDelay(time.Duration(mrand.Intn(1e10))) },
"UpdatedBlackHoleFilterState": func() {
mt.UpdatedBlackHoleFilterState(
randItem(bhfNames),
randItem(bhfState),
mrand.Intn(100),
mrand.Float64(),
)
},
}
for method, f := range tests {
allocs := testing.AllocsPerRun(1000, f)
if allocs > 0 {
t.Fatalf("Alloc Test: %s, got: %0.2f, expected: 0 allocs", method, allocs)
}
}
}