feat(libp2p): add exchange addr tests

Signed-off-by: Minh Huy Tran <huy@perun.network>

Author: NhoxxKienn

wire/net/libp2p/account.go

@@ -324,7 +324,6 @@ func getRelayServerInfo() (*peer.AddrInfo, string, error) {
 // getHost returns a new random account for testing.
 func getHost(rng *rand.Rand) *Account {
 	acc := NewRandomAccount(rng)
-	log.Println(acc.ID())
 	return acc
 }
 
@@ -345,8 +344,11 @@ func (acc *Account) keepReservationAlive(ctx context.Context, ai peer.AddrInfo)
 		select {
 		case <-ctx.Done():
 			log.Println("keepReservationAlive: context cancelled")
+			err := acc.Close()
+			if err != nil {
+				panic(err)
+			}
 			return
-
 		case <-ticker.C:
 			newReservation, err := libp2pclient.Reserve(ctx, acc.Host, ai)
 			if err != nil {

wire/net/libp2p/address.go

@@ -22,9 +22,13 @@ import (
 	"github.com/libp2p/go-libp2p/core/crypto"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/pkg/errors"
+	"perun.network/go-perun/wallet"
 	"perun.network/go-perun/wire"
 )
 
+// testBackendID is the identifier for the simulated Backend.
+const testBackendID = 0
+
 // Address is a peer address for wire discovery.
 type Address struct {
 	peer.ID
@@ -49,6 +53,21 @@ func NewRandomAddress(rng *rand.Rand) *Address {
 	return &Address{id}
 }
 
+// NewRandomAddresses returns a new random peer address.
+func NewRandomAddresses(rng *rand.Rand) map[wallet.BackendID]wire.Address {
+	_, publicKey, err := crypto.GenerateKeyPairWithReader(crypto.RSA, keySize, rng)
+	if err != nil {
+		panic(err)
+	}
+
+	id, err := peer.IDFromPublicKey(publicKey)
+	if err != nil {
+		panic(err)
+	}
+	a := Address{id}
+	return map[wallet.BackendID]wire.Address{testBackendID: &a}
+}
+
 // Equal returns whether the two addresses are equal.
 func (a *Address) Equal(b wire.Address) bool {
 	bTyped, ok := b.(*Address)

wire/net/libp2p/dialer_internal_test.go

@@ -61,7 +61,7 @@ func TestDialer_Register(t *testing.T) {
 }
 
 func TestDialer_Dial(t *testing.T) {
-	timeout := 1000 * time.Millisecond
+	timeout := 2 * time.Second
 	rng := pkgtest.Prng(t)
 
 	lHost := getHost(rng)

wire/net/libp2p/init_test.go

@@ -16,4 +16,5 @@ package libp2p_test
 
 import (
 	_ "perun.network/go-perun/backend/sim/wallet" // Initializes the randomizers.
+	_ "perun.network/go-perun/backend/sim/wire"   // Reninit the sim wire package.
 )

wire/net/libp2p/mockconn_internal_test.go

@@ -0,0 +1,68 @@
+// Copyright 2025 - See NOTICE file for copyright holders.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package libp2p
+
+import (
+	"sync"
+
+	"github.com/pkg/errors"
+
+	"perun.network/go-perun/wire"
+	wirenet "perun.network/go-perun/wire/net"
+	"polycry.pt/poly-go/sync/atomic"
+)
+
+var _ wirenet.Conn = (*MockConn)(nil)
+
+type MockConn struct {
+	mutex     sync.Mutex
+	closed    atomic.Bool
+	recvQueue chan *wire.Envelope
+
+	sent func(*wire.Envelope) // observes sent messages.
+}
+
+func newMockConn() *MockConn {
+	return &MockConn{
+		sent:      func(*wire.Envelope) {},
+		recvQueue: make(chan *wire.Envelope, 1),
+	}
+}
+
+func (c *MockConn) Send(e *wire.Envelope) error {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	if c.closed.IsSet() {
+		return errors.New("closed")
+	}
+	c.sent(e)
+	return nil
+}
+
+func (c *MockConn) Recv() (*wire.Envelope, error) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	if c.closed.IsSet() {
+		return nil, errors.New("closed")
+	}
+	return <-c.recvQueue, nil
+}
+
+func (c *MockConn) Close() error {
+	if !c.closed.TrySet() {
+		return errors.New("double close")
+	}
+	return nil
+}

wire/net/libp2p/simple_exchange_addr_test.go

@@ -0,0 +1,122 @@
+// Copyright 2025 - See NOTICE file for copyright holders.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This test uses the wire/net/libp2p implementation of Account and Address
+// to test the default implementation of wire.
+//
+//nolint:testpackage
+package libp2p
+
+import (
+	"context"
+	"math/rand"
+	"net"
+	"sync"
+	"testing"
+	"time"
+
+	"perun.network/go-perun/channel"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"perun.network/go-perun/wire"
+	wirenet "perun.network/go-perun/wire/net"
+	perunio "perun.network/go-perun/wire/perunio/serializer"
+	wiretest "perun.network/go-perun/wire/test"
+	ctxtest "polycry.pt/poly-go/context/test"
+	"polycry.pt/poly-go/test"
+)
+
+const timeout = 100 * time.Millisecond
+
+func TestExchangeAddrs_ConnFail(t *testing.T) {
+	rng := test.Prng(t)
+	a, _ := newPipeConnPair()
+	a.Close()
+	acc := wiretest.NewRandomAccountMap(rng, channel.TestBackendID)
+	defer acc[channel.TestBackendID].(*Account).Close()
+	addr, err := wirenet.ExchangeAddrsPassive(context.Background(), acc, a)
+	assert.Nil(t, addr)
+	assert.Error(t, err)
+}
+
+func TestExchangeAddrs_Success(t *testing.T) {
+	rng := test.Prng(t)
+	conn0, conn1 := newPipeConnPair()
+	defer conn0.Close()
+	account0, account1 := wiretest.NewRandomAccountMap(rng, channel.TestBackendID), wiretest.NewRandomAccountMap(rng, channel.TestBackendID)
+	defer account0[channel.TestBackendID].(*Account).Close()
+	defer account1[channel.TestBackendID].(*Account).Close()
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	go func() {
+		defer wg.Done()
+		defer conn1.Close()
+
+		recvAddr0, err := wirenet.ExchangeAddrsPassive(context.Background(), account1, conn1)
+		assert.NoError(t, err)
+		assert.True(t, channel.EqualWireMaps(recvAddr0, wire.AddressMapfromAccountMap(account0)))
+	}()
+
+	err := wirenet.ExchangeAddrsActive(context.Background(), account0, wire.AddressMapfromAccountMap(account1), conn0)
+	require.NoError(t, err)
+
+	wg.Wait()
+}
+
+func TestExchangeAddrs_BogusMsg(t *testing.T) {
+	rng := test.Prng(t)
+	acc := wiretest.NewRandomAccountMap(rng, channel.TestBackendID)
+	defer acc[channel.TestBackendID].(*Account).Close()
+	conn := newMockConn()
+	conn.recvQueue <- newRandomEnvelope(rng, wire.NewPingMsg())
+	addr, err := wirenet.ExchangeAddrsPassive(context.Background(), acc, conn)
+
+	assert.Error(t, err, "ExchangeAddrs should error when peer sends a non-AuthResponseMsg")
+	assert.Nil(t, addr)
+}
+
+func TestExchangeAddrs_Timeout(t *testing.T) {
+	rng := test.Prng(t)
+	a, _ := newPipeConnPair()
+
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	ctxtest.AssertTerminates(t, 20*timeout, func() {
+		acc := wiretest.NewRandomAccountMap(rng, channel.TestBackendID)
+		defer acc[channel.TestBackendID].(*Account).Close()
+		addr, err := wirenet.ExchangeAddrsPassive(ctx, acc, a)
+		assert.Nil(t, addr)
+		assert.Error(t, err)
+	})
+}
+
+// newPipeConnPair creates endpoints that are connected via pipes.
+func newPipeConnPair() (a wirenet.Conn, b wirenet.Conn) {
+	c0, c1 := net.Pipe()
+	ser := perunio.Serializer()
+	return wirenet.NewIoConn(c0, ser), wirenet.NewIoConn(c1, ser)
+}
+
+// NewRandomEnvelope returns an envelope around message m with random sender and
+// recipient generated using randomness from rng.
+func newRandomEnvelope(rng *rand.Rand, m wire.Msg) *wire.Envelope {
+	return &wire.Envelope{
+		Sender:    NewRandomAddresses(rng),
+		Recipient: NewRandomAddresses(rng),
+		Msg:       m,
+	}
+}