Adding more wrappers and test to connect and disconnect peers

testlibs/src/testing-wrappers.go

@@ -1,8 +1,10 @@
 package testlibs
 
 import (
+	"context"
 	"errors"
-     utilities "github.com/waku-org/waku-go-bindings/testlibs/utilities"
+
+	utilities "github.com/waku-org/waku-go-bindings/testlibs/utilities"
 	"github.com/waku-org/waku-go-bindings/waku"
 	"go.uber.org/zap"
 )
@@ -11,11 +13,11 @@ type WakuNodeWrapper struct {
 	*waku.WakuNode
 }
 
-func Wrappers_CreateWakuNode(customCfg *waku.WakuConfig, logger *zap.Logger) (*waku.WakuNode, error) {
+// This function create waku node from config and start it
+func Wrappers_StartWakuNode(customCfg *waku.WakuConfig, logger *zap.Logger) (*WakuNodeWrapper, error) {
 
 	var nodeCfg waku.WakuConfig
 
-	
 	if customCfg == nil {
 		nodeCfg = *utilities.DefaultWakuConfig
 	} else {
@@ -32,30 +34,27 @@ func Wrappers_CreateWakuNode(customCfg *waku.WakuConfig, logger *zap.Logger) (*w
 		return nil, err
 	}
 
-	return node, nil
-}
-
-func (node *WakuNodeWrapper) Wrappers_Start() error {
-	if node== nil || node.WakuNode == nil {
+	utilities.Debug("Attempting to start WakuNode")
+	wrapper := &WakuNodeWrapper{WakuNode: node}
+	if wrapper.WakuNode == nil {
 		err := errors.New("WakuNode instance is nil")
 		utilities.Error("Failed to start WakuNode", zap.Error(err))
-		return err
+		return nil, err
 	}
 
-	utilities.Debug("Attempting to start WakuNode")
-	err := node.WakuNode.Start()
+	err = wrapper.WakuNode.Start()
 	if err != nil {
 		utilities.Error("Failed to start WakuNode", zap.Error(err))
-		return err
+		return nil, err
 	}
-
 	utilities.Debug("Successfully started WakuNode")
-	return nil
+
+	return wrapper, nil
 }
 
-// Stops the WakuNode instance.
-func (node*WakuNodeWrapper) Wrappers_Stop() error {
-	if node== nil || node.WakuNode == nil {
+// Stops the WakuNode .
+func (node *WakuNodeWrapper) Wrappers_Stop() error {
+	if node == nil || node.WakuNode == nil {
 		err := errors.New("WakuNode instance is nil")
 		utilities.Error("Failed to stop WakuNode", zap.Error(err))
 		return err
@@ -72,9 +71,9 @@ func (node*WakuNodeWrapper) Wrappers_Stop() error {
 	return nil
 }
 
-//  Destroys the WakuNode instance.
-func (node*WakuNodeWrapper) Wrappers_Destroy() error {
-	if node== nil || node.WakuNode == nil {
+// Destroys the WakuNode .
+func (node *WakuNodeWrapper) Wrappers_Destroy() error {
+	if node == nil || node.WakuNode == nil {
 		err := errors.New("WakuNode instance is nil")
 		utilities.Error("Failed to destroy WakuNode", zap.Error(err))
 		return err
@@ -90,3 +89,116 @@ func (node*WakuNodeWrapper) Wrappers_Destroy() error {
 	utilities.Debug("Successfully destroyed WakuNode")
 	return nil
 }
+
+func (wrapper *WakuNodeWrapper) Wrappers_StopAndDestroy() error {
+	if wrapper.WakuNode == nil {
+		err := errors.New("WakuNode instance is nil")
+		utilities.Error("Failed to stop or destroy WakuNode", zap.Error(err))
+		return err
+	}
+
+	utilities.Debug("Attempting to stop WakuNode")
+	err := wrapper.Stop()
+	if err != nil {
+		utilities.Error("Failed to stop WakuNode", zap.Error(err))
+		return err
+	}
+
+	utilities.Debug("Attempting to destroy WakuNode")
+	err = wrapper.Destroy()
+	if err != nil {
+		utilities.Error("Failed to destroy WakuNode", zap.Error(err))
+		return err
+	}
+
+	utilities.Debug("Successfully stopped and destroyed WakuNode")
+	return nil
+}
+
+func (wrapper *WakuNodeWrapper) Wrappers_GetNumConnectedRelayPeers(optPubsubTopic ...string) (int, error) {
+	utilities.Debug("Wrappers_GetNumConnectedRelayPeers called")
+
+	if wrapper.WakuNode == nil {
+		err := errors.New("WakuNode is nil in WakuNodeWrapper")
+		utilities.Error("Cannot proceed; node is nil", zap.Error(err))
+		// Return an error immediately to “stop” the function
+		return 0, err
+	}
+
+	numPeers, err := wrapper.WakuNode.GetNumConnectedRelayPeers(optPubsubTopic...)
+	if err != nil {
+		utilities.Error("Failed to get number of connected relay peers", zap.Error(err))
+		return 0, err
+	}
+
+	utilities.Debug("Successfully fetched number of connected relay peers",
+		zap.Int("count", numPeers),
+	)
+	return numPeers, nil
+}
+
+func (w *WakuNodeWrapper) Wrappers_ConnectPeer(target *WakuNodeWrapper) error {
+	if w.WakuNode == nil {
+		err := errors.New("WakuNode is nil in caller")
+		utilities.Error("Cannot call Connect; caller node is nil", zap.Error(err))
+		return err
+	}
+	if target == nil || target.WakuNode == nil {
+		err := errors.New("target WakuNode is nil")
+		utilities.Error("Cannot connect; target node is nil", zap.Error(err))
+		return err
+	}
+
+	addrs, err := target.ListenAddresses()
+	if err != nil || len(addrs) == 0 {
+		errMsg := "failed to obtain target node's listening addresses"
+		utilities.Error(errMsg, zap.String("error", err.Error()))
+		return errors.New(errMsg)
+	}
+
+	peerAddr := addrs[0]
+
+	utilities.Debug("Wrappers_ConnectPeer called", zap.String("targetAddr", peerAddr.String()))
+
+	ctx, cancel := context.WithTimeout(context.Background(), utilities.ConnectPeerTimeout)
+	defer cancel()
+
+	utilities.Debug("Connecting to peer with address", zap.String("address", peerAddr.String()))
+	err = w.WakuNode.Connect(ctx, peerAddr)
+	if err != nil {
+		utilities.Error("Failed to connect", zap.Error(err))
+		return err
+	}
+
+	utilities.Debug("Successfully connected", zap.String("address", peerAddr.String()))
+	return nil
+}
+
+func (wrapper *WakuNodeWrapper) Wrappers_DisconnectPeer(targetNode *WakuNodeWrapper) error {
+	if wrapper.WakuNode == nil {
+		err := errors.New("the calling WakuNode is nil")
+		utilities.Error("Cannot disconnect; calling node is nil", zap.Error(err))
+		return err
+	}
+	if targetNode == nil || targetNode.WakuNode == nil {
+		err := errors.New("the target WakuNode is nil")
+		utilities.Error("Cannot disconnect; target node is nil", zap.Error(err))
+		return err
+	}
+
+	peerID, err := targetNode.WakuNode.PeerID()
+	if err != nil {
+		utilities.Error("Failed to retrieve peer ID from target node", zap.Error(err))
+		return err
+	}
+
+	utilities.Debug("Wrappers_DisconnectPeer", zap.String("peerID", peerID.String()))
+	err = wrapper.WakuNode.DisconnectPeerByID(peerID)
+	if err != nil {
+		utilities.Error("Failed to disconnect peer", zap.Error(err))
+		return err
+	}
+
+	utilities.Debug("Successfully disconnected peer", zap.String("peerID", peerID.String()))
+	return nil
+}

testlibs/utilities/logging.go

@@ -2,7 +2,6 @@ package utilities
 
 import (
 	"go.uber.org/zap"
-	
 )
 
 var devLogger *zap.Logger

testlibs/utilities/utils.go

@@ -31,6 +31,9 @@ var DefaultWakuConfig = &waku.WakuConfig{
 // WakuConfigOption is a function that applies a change to a WakuConfig.
 type WakuConfigOption func(*waku.WakuConfig)
 
+
+var ConnectPeerTimeout = 10 * time.Second //default timeout for node to connect to another node
+
 func GenerateUniquePort() int {
 	rng := rand.New(rand.NewSource(time.Now().UnixNano())) // Local RNG instance
 

testlibs/waku-go-tests/Nodes_basic_test.go

@@ -2,63 +2,73 @@ package waku_go_tests
 
 import (
 	"testing"
-    utilities "github.com/waku-org/waku-go-bindings/testlibs/utilities"
+	"time"
+
+	"github.com/stretchr/testify/require"
 	testlibs "github.com/waku-org/waku-go-bindings/testlibs/src"
+	utilities "github.com/waku-org/waku-go-bindings/testlibs/utilities"
 	"go.uber.org/zap"
-	 "github.com/stretchr/testify/require"
 )
 
 func TestBasicWakuNodes(t *testing.T) {
-     
-	utilities.Debug("Create logger isntance")
-	logger, err := zap.NewDevelopment()
-	defaultConfig := *utilities.DefaultWakuConfig 
 
-	
-	utilities.Debug("Creating the first WakuNodeWrapper")
-	node1, err := testlibs.Wrappers_CreateWakuNode(&defaultConfig, logger)
+	utilities.Debug("Create logger isntance")
+	logger, _ := zap.NewDevelopment()
+	nodeCfg1 := *utilities.DefaultWakuConfig
+	nodeCfg1.Relay = true
+
+	nodeCfg2 := *utilities.DefaultWakuConfig
+	nodeCfg2.Relay = true
+
+	utilities.Debug("Starting the first WakuNodeWrapper")
+	node1, err := testlibs.Wrappers_StartWakuNode(&nodeCfg1, logger.Named("node1"))
 	require.NoError(t, err, "Failed to create the first WakuNodeWrapper")
 	utilities.Debug("Successfully created the first WakuNodeWrapper")
 
-
-	utilities.Debug("Creating the second WakuNodeWrapper")
-	node2, err := testlibs.Wrappers_CreateWakuNode(&defaultConfig, logger)
+	utilities.Debug("Starting the second WakuNodeWrapper")
+	node2, err := testlibs.Wrappers_StartWakuNode(&nodeCfg2, logger.Named("node2"))
 	require.NoError(t, err, "Failed to create the second WakuNodeWrapper")
 	utilities.Debug("Successfully created the second WakuNodeWrapper")
 
-	
-	utilities.Debug("Starting the first WakuNodeWrapper")
-	err = 
 	require.NoError(t, err, "Failed to start the first WakuNodeWrapper")
 	utilities.Debug("Successfully started the first WakuNodeWrapper")
 
-	
-	utilities.Debug("Starting the second WakuNodeWrapper")
-	err = node2.Wrappers_Start()
 	require.NoError(t, err, "Failed to start the second WakuNodeWrapper")
 	utilities.Debug("Successfully started the second WakuNodeWrapper")
 
-	
+	time.Sleep(2 * time.Second)
 	utilities.Debug("Stopping the first WakuNodeWrapper")
-	err = node1.Wrappers_Stop()
-	require.NoError(t, err, "Failed to stop the first WakuNodeWrapper")
-	utilities.Debug("Successfully stopped the first WakuNodeWrapper")
 
-	
-	utilities.Debug("Stopping the second WakuNodeWrapper")
-	err = node2.Wrappers_Stop()
-	require.NoError(t, err, "Failed to stop the second WakuNodeWrapper")
-	utilities.Debug("Successfully stopped the second WakuNodeWrapper")
+	err = node1.Wrappers_StopAndDestroy()
+	require.NoError(t, err, "Failed to stop+destroy Node 1")
 
-	
-	utilities.Debug("Destroying the first WakuNodeWrapper")
-	err = node1.Wrappers_Destroy()
-	require.NoError(t, err, "Failed to destroy the first WakuNodeWrapper")
-	utilities.Debug("Successfully destroyed the first WakuNodeWrapper")
-
-
-	utilities.Debug("Destroying the second WakuNodeWrapper")
-	err = node2.Wrappers_Destroy()
-	require.NoError(t, err, "Failed to destroy the second WakuNodeWrapper")
-	utilities.Debug("Successfully destroyed the second WakuNodeWrapper")
+	err = node2.Wrappers_StopAndDestroy()
+	require.NoError(t, err, "Failed to stop+destroy Node 2")
+}
+
+// Test to connect 2 nodes and disconnect them
+
+func TestConnectAndDisconnectNodes(t *testing.T) {
+	logger, err := zap.NewDevelopment()
+	require.NoError(t, err, "failed to create logger")
+
+	nodeA, err := testlibs.Wrappers_StartWakuNode(nil, logger.Named("nodeA"))
+	require.NoError(t, err, "failed to create/start Node A")
+	defer nodeA.Wrappers_StopAndDestroy() // ensures cleanup
+
+	nodeB, err := testlibs.Wrappers_StartWakuNode(nil, logger.Named("nodeB"))
+	require.NoError(t, err, "failed to create/start Node B")
+	defer nodeB.Wrappers_StopAndDestroy() // ensures cleanup
+
+	nodeC, err := testlibs.Wrappers_StartWakuNode(nil, logger.Named("nodeB"))
+	require.NoError(t, err, "failed to create/start Node B")
+	defer nodeC.Wrappers_StopAndDestroy() // ensures cleanup
+
+	err = nodeA.Wrappers_ConnectPeer(nodeB)
+	require.NoError(t, err, "failed to connect Node A to Node B")
+
+	time.Sleep(3 * time.Second)
+
+	err = nodeA.Wrappers_DisconnectPeer(nodeC)
+	require.NoError(t, err, "failed to disconnect Node A from Node B")
 }