test: use mocknet in unit test (#2371)

<!--
Please read and fill out this form before submitting your PR.

Please make sure you have reviewed our contributors guide before
submitting your
first PR.

NOTE: PR titles should follow semantic commits:
https://www.conventionalcommits.org/en/v1.0.0/
-->

## Overview

This pr uses a mocknet in the syncservicer_test in order to avoid
spinning up a network for a unit test. It also adds a check to prevent
dialling ourself

closes #2359 

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

- **New Features**
- Added support for creating a client with a custom or mock host,
enabling greater flexibility in peer-to-peer networking scenarios.

- **Bug Fixes**
- Improved resource cleanup to avoid errors when closing components that
may not be initialized.
- Prevented clients from attempting to connect to themselves, reducing
unnecessary connection attempts.

- **Tests**
- Updated tests to utilize mock networks for more robust and isolated
peer-to-peer testing.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: tac0turtle <you@example.com>
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

Author: 3 people

pkg/p2p/client.go

@@ -92,6 +92,33 @@ func NewClient(
 	}, nil
 }
 
+func NewClientWithHost(
+	conf config.Config,
+	nodeKey *key.NodeKey,
+	ds datastore.Datastore,
+	logger log.Logger,
+	metrics *Metrics,
+	h host.Host, // injected host (mocknet or custom)
+) (*Client, error) {
+	c, err := NewClient(conf, nodeKey, ds, logger, metrics)
+	if err != nil {
+		return nil, err
+	}
+
+	// Reject hosts whose identity does not match the supplied node key
+	expectedID, _ := peer.IDFromPrivateKey(nodeKey.PrivKey)
+	if h.ID() != expectedID {
+		return nil, fmt.Errorf(
+			"injected host ID %s does not match node key ID %s",
+			h.ID(),
+			expectedID,
+		)
+	}
+
+	c.host = h
+	return c, nil
+}
+
 // Start establish Client's P2P connectivity.
 //
 // Following steps are taken:
@@ -101,11 +128,16 @@ func NewClient(
 // 4. Use active peer discovery to look for peers from same ORU network.
 func (c *Client) Start(ctx context.Context) error {
 	c.logger.Debug("starting P2P client")
-	host, err := c.listen()
+
+	if c.host != nil {
+		return c.startWithHost(ctx, c.host)
+	}
+
+	h, err := c.listen()
 	if err != nil {
 		return err
 	}
-	return c.startWithHost(ctx, host)
+	return c.startWithHost(ctx, h)
 }
 
 func (c *Client) startWithHost(ctx context.Context, h host.Host) error {
@@ -144,10 +176,14 @@ func (c *Client) startWithHost(ctx context.Context, h host.Host) error {
 
 // Close gently stops Client.
 func (c *Client) Close() error {
-	return errors.Join(
-		c.dht.Close(),
-		c.host.Close(),
-	)
+	var dhtErr, hostErr error
+	if c.dht != nil {
+		dhtErr = c.dht.Close()
+	}
+	if c.host != nil {
+		hostErr = c.host.Close()
+	}
+	return errors.Join(dhtErr, hostErr)
 }
 
 // Addrs returns listen addresses of Client.
@@ -310,6 +346,10 @@ func (c *Client) findPeers(ctx context.Context) error {
 
 // tryConnect attempts to connect to a peer and logs error if necessary
 func (c *Client) tryConnect(ctx context.Context, peer peer.AddrInfo) {
+	if peer.ID == c.host.ID() {
+		return
+	}
+
 	err := c.host.Connect(ctx, peer)
 	if err != nil && ctx.Err() == nil {
 		c.logger.Error("failed to connect to peer", "peer", peer, "error", err)

pkg/p2p/client_test.go

@@ -10,15 +10,77 @@ import (
 	"cosmossdk.io/log"
 	"github.com/ipfs/go-datastore"
 	dssync "github.com/ipfs/go-datastore/sync"
+	libp2p "github.com/libp2p/go-libp2p"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/multiformats/go-multiaddr"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	mocknet "github.com/libp2p/go-libp2p/p2p/net/mock"
+
 	"github.com/rollkit/rollkit/pkg/config"
 	"github.com/rollkit/rollkit/pkg/p2p/key"
 )
 
+func TestNewClientWithHost(t *testing.T) {
+	require := require.New(t)
+	assert := assert.New(t)
+
+	// Common setup
+	conf := config.DefaultConfig
+	conf.RootDir = t.TempDir()
+	nodeKey, err := key.LoadOrGenNodeKey(filepath.Join(conf.RootDir, "config", "node_key.json"))
+	require.NoError(err)
+	ds := dssync.MutexWrap(datastore.NewMapDatastore())
+	logger := log.NewTestLogger(t)
+	metrics := NopMetrics()
+
+	// Ensure config directory exists for nodeKey loading
+	ClientInitFiles(t, conf.RootDir)
+
+	t.Run("successful client creation with injected host", func(t *testing.T) {
+		// First, create a client to get its expected gater
+		baseClient, err := NewClient(conf, nodeKey, ds, logger, metrics)
+		require.NoError(err)
+		require.NotNil(baseClient)
+
+		mn := mocknet.New()
+		defer mn.Close()
+
+		h, err := libp2p.New(
+			libp2p.Identity(nodeKey.PrivKey),
+			libp2p.ListenAddrs(multiaddr.StringCast("/ip4/127.0.0.1/tcp/0")),
+			libp2p.ConnectionGater(baseClient.ConnectionGater()), // Use the gater from baseClient
+		)
+		require.NoError(err)
+		defer h.Close()
+
+		client, err := NewClientWithHost(conf, nodeKey, ds, logger, metrics, h)
+		assert.NoError(err)
+		assert.NotNil(client)
+		assert.Equal(h, client.Host())
+	})
+
+	t.Run("error when injected host ID does not match node key ID", func(t *testing.T) {
+		mn := mocknet.New()
+		defer mn.Close()
+
+		// Generate a different node key for the host
+		otherNodeKey, err := key.GenerateNodeKey()
+		require.NoError(err)
+
+		h, err := mn.AddPeer(otherNodeKey.PrivKey, multiaddr.StringCast("/ip4/127.0.0.1/tcp/0"))
+		require.NoError(err)
+
+		client, err := NewClientWithHost(conf, nodeKey, ds, logger, metrics, h)
+		assert.Error(err)
+		assert.Nil(client)
+		assert.Contains(err.Error(), "injected host ID")
+		assert.Contains(err.Error(), "does not match node key ID")
+	})
+
+}
+
 func TestClientStartup(t *testing.T) {
 	assert := assert.New(t)
 	// create temp config dir

pkg/sync/sync_service_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/sync"
 	"github.com/libp2p/go-libp2p/core/crypto"
+	mocknet "github.com/libp2p/go-libp2p/p2p/net/mock"
 	"github.com/rollkit/rollkit/pkg/config"
 	genesispkg "github.com/rollkit/rollkit/pkg/genesis"
 	"github.com/rollkit/rollkit/pkg/p2p"
@@ -29,6 +30,7 @@ func TestHeaderSyncServiceRestart(t *testing.T) {
 	noopSigner, err := noop.NewNoopSigner(pk)
 	require.NoError(t, err)
 	rnd := rand.New(rand.NewSource(1)) // nolint:gosec // test code only
+	mn := mocknet.New()
 
 	proposerAddr := []byte("test")
 	genesisDoc := genesispkg.Genesis{
@@ -42,14 +44,17 @@ func TestHeaderSyncServiceRestart(t *testing.T) {
 	nodeKey, err := key.LoadOrGenNodeKey(filepath.Dir(conf.ConfigPath()))
 	require.NoError(t, err)
 	logger := sdklog.NewTestLogger(t)
-	p2pClient, err := p2p.NewClient(conf, nodeKey, mainKV, logger, p2p.NopMetrics())
+	priv := nodeKey.PrivKey
+	h, err := mn.AddPeer(priv, nil)
+	require.NoError(t, err)
+
+	p2pClient, err := p2p.NewClientWithHost(conf, nodeKey, mainKV, logger, p2p.NopMetrics(), h)
 	require.NoError(t, err)
 
 	// Start p2p client before creating sync service
 	ctx, cancel := context.WithCancel(t.Context())
 	defer cancel()
-	err = p2pClient.Start(ctx)
-	require.NoError(t, err)
+	require.NoError(t, p2pClient.Start(ctx))
 
 	svc, err := NewHeaderSyncService(mainKV, conf, genesisDoc, p2pClient, logger)
 	require.NoError(t, err)
@@ -79,7 +84,9 @@ func TestHeaderSyncServiceRestart(t *testing.T) {
 	_ = svc.Stop(ctx)
 	cancel()
 
-	p2pClient, err = p2p.NewClient(conf, nodeKey, mainKV, logger, p2p.NopMetrics())
+	h2, err := mn.AddPeer(priv, nil)
+	require.NoError(t, err)
+	p2pClient, err = p2p.NewClientWithHost(conf, nodeKey, mainKV, logger, p2p.NopMetrics(), h2)
 	require.NoError(t, err)
 
 	// Start p2p client again