feat: add tests for iperf package

Signed-off-by: nabil salah <nabil.salah203@gmail.com>

Author: Nabil-Salah

go.mod

@@ -53,7 +53,7 @@ require (
 	github.com/vishvananda/netns v0.0.0-20210104183010-2eb08e3e575f
 	github.com/whs/nacl-sealed-box v0.0.0-20180930164530-92b9ba845d8d
 	github.com/yggdrasil-network/yggdrasil-go v0.4.0
-	go.uber.org/mock v0.5.0
+	go.uber.org/mock v0.5.2
 	golang.org/x/crypto v0.33.0
 	golang.org/x/sys v0.30.0
 	golang.zx2c4.com/wireguard/wgctrl v0.0.0-20200609130330-bd2cb7843e1b

go.sum

@@ -637,6 +637,8 @@ go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/goleak v1.1.12/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
 go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU=
 go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM=
+go.uber.org/mock v0.5.2 h1:LbtPTcP8A5k9WPXj54PPPbjcI4Y6lhyOZXn+VS7wNko=
+go.uber.org/mock v0.5.2/go.mod h1:wLlUxC2vVTPTaE3UD51E0BGOAElKrILxhVSDYQLld5o=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=

pkg/perf/iperf/exec_wrapper.go

@@ -0,0 +1,43 @@
+package iperf
+
+import (
+	"context"
+	"os/exec"
+)
+
+// ExecWrapper wraps the exec package functions to allow for mocking
+type ExecWrapper interface {
+	LookPath(file string) (string, error)
+	CommandContext(ctx context.Context, name string, arg ...string) ExecCmd
+}
+
+// ExecCmd represents a command that can be executed
+type ExecCmd interface {
+	CombinedOutput() ([]byte, error)
+}
+
+// RealExecWrapper implements ExecWrapper using the real exec package
+type RealExecWrapper struct{}
+
+// LookPath searches for an executable named file in the directories named by the PATH environment variable
+func (r *RealExecWrapper) LookPath(file string) (string, error) {
+	return exec.LookPath(file)
+}
+
+// CommandContext returns the Cmd struct to execute the named program with the given arguments
+func (r *RealExecWrapper) CommandContext(ctx context.Context, name string, arg ...string) ExecCmd {
+	return &RealExecCmd{cmd: exec.CommandContext(ctx, name, arg...)}
+}
+
+// RealExecCmd wraps exec.Cmd to implement ExecCmd interface
+type RealExecCmd struct {
+	cmd *exec.Cmd
+}
+
+// CombinedOutput runs the command and returns its combined standard output and standard error
+func (r *RealExecCmd) CombinedOutput() ([]byte, error) {
+	return r.cmd.CombinedOutput()
+}
+
+// Global instance that can be overridden in tests
+var execWrapper ExecWrapper = &RealExecWrapper{}

pkg/perf/iperf/graphql_wrapper.go

@@ -0,0 +1,27 @@
+package iperf
+
+import (
+	"context"
+
+	"github.com/threefoldtech/zosbase/pkg/perf/graphql"
+)
+
+// GraphQLClient interface for mocking GraphQL operations
+type GraphQLClient interface {
+	GetUpNodes(ctx context.Context, nodesNum int, farmID, excludeFarmID uint32, ipv4, ipv6 bool) ([]graphql.Node, error)
+}
+
+// GraphQLClientWrapper wraps the real GraphQL client to implement the interface
+type GraphQLClientWrapper struct {
+	client graphql.GraphQl
+}
+
+// NewGraphQLClientWrapper creates a new wrapper for the GraphQL client
+func NewGraphQLClientWrapper(client graphql.GraphQl) GraphQLClient {
+	return &GraphQLClientWrapper{client: client}
+}
+
+// GetUpNodes calls the underlying GraphQL client's GetUpNodes method
+func (g *GraphQLClientWrapper) GetUpNodes(ctx context.Context, nodesNum int, farmID, excludeFarmID uint32, ipv4, ipv6 bool) ([]graphql.Node, error) {
+	return g.client.GetUpNodes(ctx, nodesNum, farmID, excludeFarmID, ipv4, ipv6)
+}

pkg/perf/iperf/iperf_task.go

@@ -29,7 +29,11 @@ const (
 )
 
 // IperfTest for iperf tcp/udp tests
-type IperfTest struct{}
+type IperfTest struct {
+	// Optional dependencies for testing
+	graphqlClient GraphQLClient
+	execWrapper   ExecWrapper
+}
 
 // IperfResult for iperf test results
 type IperfResult struct {
@@ -75,10 +79,19 @@ func (t *IperfTest) Jitter() uint32 {
 
 // Run runs the tcp test and returns the result
 func (t *IperfTest) Run(ctx context.Context) (interface{}, error) {
-	env := environment.MustGet()
-	g, err := graphql.NewGraphQl(env.GraphQL...)
-	if err != nil {
-		return nil, err
+	var g GraphQLClient
+	var err error
+
+	// Use injected GraphQL client if available, otherwise create a new one
+	if t.graphqlClient != nil {
+		g = t.graphqlClient
+	} else {
+		env := environment.MustGet()
+		graphqlClient, err := graphql.NewGraphQl(env.GraphQL...)
+		if err != nil {
+			return nil, err
+		}
+		g = NewGraphQLClientWrapper(graphqlClient)
 	}
 
 	// get public up nodes
@@ -94,7 +107,13 @@ func (t *IperfTest) Run(ctx context.Context) (interface{}, error) {
 
 	nodes = append(nodes, freeFarmNodes...)
 
-	_, err = exec.LookPath("iperf")
+	// Use injected exec wrapper if available
+	execWrap := execWrapper
+	if t.execWrapper != nil {
+		execWrap = t.execWrapper
+	}
+
+	_, err = execWrap.LookPath("iperf")
 	if err != nil {
 		return nil, err
 	}
@@ -150,9 +169,15 @@ func (t *IperfTest) runIperfTest(ctx context.Context, clientIP string, tcp bool)
 		opts = append(opts, "--length", "16B", "--udp")
 	}
 
+	// Use injected exec wrapper if available
+	execWrap := execWrapper
+	if t.execWrapper != nil {
+		execWrap = t.execWrapper
+	}
+
 	var report iperfCommandOutput
 	operation := func() error {
-		res := runIperfCommand(ctx, opts)
+		res := runIperfCommand(ctx, opts, execWrap)
 		if res.Error == errServerBusy {
 			return errors.New(errServerBusy)
 		}
@@ -196,8 +221,8 @@ func (t *IperfTest) runIperfTest(ctx context.Context, clientIP string, tcp bool)
 	return iperfResult
 }
 
-func runIperfCommand(ctx context.Context, opts []string) iperfCommandOutput {
-	output, err := exec.CommandContext(ctx, "iperf", opts...).CombinedOutput()
+func runIperfCommand(ctx context.Context, opts []string, execWrap ExecWrapper) iperfCommandOutput {
+	output, err := execWrap.CommandContext(ctx, "iperf", opts...).CombinedOutput()
 	exitErr := &exec.ExitError{}
 	if err != nil && !errors.As(err, &exitErr) {
 		log.Err(err).Msg("failed to run iperf")

pkg/perf/iperf/iperf_task_test.go

@@ -0,0 +1,217 @@
+package iperf
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/threefoldtech/zosbase/pkg/perf/graphql"
+	"go.uber.org/mock/gomock"
+)
+
+func TestIperfTest_Run_Success(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockGraphQL := NewMockGraphQLClient(ctrl)
+	mockExec := NewMockExecWrapper(ctrl)
+	mockCmd := NewMockExecCmd(ctrl)
+
+	task := &IperfTest{
+		graphqlClient: mockGraphQL,
+		execWrapper:   mockExec,
+	}
+
+	testNodes := []graphql.Node{
+		{
+			NodeID: 123,
+			PublicConfig: graphql.PublicConfig{
+				Ipv4: "192.168.1.100/24",
+				Ipv6: "2001:db8::1/64",
+			},
+		},
+	}
+
+	mockGraphQL.EXPECT().
+		GetUpNodes(gomock.Any(), 0, uint32(1), uint32(0), true, true).
+		Return([]graphql.Node{testNodes[0]}, nil)
+
+	mockGraphQL.EXPECT().
+		GetUpNodes(gomock.Any(), 12, uint32(0), uint32(1), true, true).
+		Return([]graphql.Node{}, nil)
+
+	mockExec.EXPECT().
+		LookPath("iperf").
+		Return("/usr/bin/iperf", nil)
+
+	tcpOutput := createMockIperfOutput(false, 1000000, 2000000)
+	udpOutput := createMockIperfOutput(true, 500000, 800000)
+
+	tcpOutputBytes, _ := json.Marshal(tcpOutput)
+	udpOutputBytes, _ := json.Marshal(udpOutput)
+
+	mockExec.EXPECT().
+		CommandContext(gomock.Any(), "iperf", gomock.Any()).
+		Return(mockCmd).
+		Times(4)
+
+	mockCmd.EXPECT().CombinedOutput().Return(tcpOutputBytes, nil)
+	mockCmd.EXPECT().CombinedOutput().Return(tcpOutputBytes, nil)
+	mockCmd.EXPECT().CombinedOutput().Return(udpOutputBytes, nil)
+	mockCmd.EXPECT().CombinedOutput().Return(udpOutputBytes, nil)
+
+	ctx := context.Background()
+	result, err := task.Run(ctx)
+
+	assert.NoError(t, err)
+	assert.NotNil(t, result)
+
+	results, ok := result.([]IperfResult)
+	assert.True(t, ok)
+	assert.Len(t, results, 4)
+
+	firstResult := results[0]
+	assert.Equal(t, uint32(123), firstResult.NodeID)
+	assert.Equal(t, "192.168.1.100", firstResult.NodeIpv4)
+	assert.Equal(t, "tcp", firstResult.TestType)
+	assert.Equal(t, float64(1000000), firstResult.UploadSpeed)
+	assert.Equal(t, float64(2000000), firstResult.DownloadSpeed)
+}
+
+func TestIperfTest_Run_GraphQLError(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockGraphQL := NewMockGraphQLClient(ctrl)
+
+	// Create test task with injected dependencies
+	task := &IperfTest{
+		graphqlClient: mockGraphQL,
+	}
+
+	// Mock GraphQL error
+	mockGraphQL.EXPECT().
+		GetUpNodes(gomock.Any(), 0, uint32(1), uint32(0), true, true).
+		Return(nil, errors.New("graphql connection failed"))
+
+	// Execute the test
+	ctx := context.Background()
+	result, err := task.Run(ctx)
+
+	// Verify error
+	assert.Error(t, err)
+	assert.Nil(t, result)
+	assert.Contains(t, err.Error(), "failed to list freefarm nodes from graphql")
+}
+
+func TestIperfTest_Run_IperfNotFound(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockGraphQL := NewMockGraphQLClient(ctrl)
+	mockExec := NewMockExecWrapper(ctrl)
+
+	task := &IperfTest{
+		graphqlClient: mockGraphQL,
+		execWrapper:   mockExec,
+	}
+
+	mockGraphQL.EXPECT().
+		GetUpNodes(gomock.Any(), 0, uint32(1), uint32(0), true, true).
+		Return([]graphql.Node{}, nil)
+
+	mockGraphQL.EXPECT().
+		GetUpNodes(gomock.Any(), 12, uint32(0), uint32(1), true, true).
+		Return([]graphql.Node{}, nil)
+
+	mockExec.EXPECT().
+		LookPath("iperf").
+		Return("", errors.New("executable file not found in $PATH"))
+
+	ctx := context.Background()
+	result, err := task.Run(ctx)
+
+	assert.Error(t, err)
+	assert.Nil(t, result)
+}
+
+func TestIperfTest_Run_InvalidIPAddress(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockGraphQL := NewMockGraphQLClient(ctrl)
+	mockExec := NewMockExecWrapper(ctrl)
+
+	task := &IperfTest{
+		graphqlClient: mockGraphQL,
+		execWrapper:   mockExec,
+	}
+
+	testNodes := []graphql.Node{
+		{
+			NodeID: 123,
+			PublicConfig: graphql.PublicConfig{
+				Ipv4: "invalid-ip",
+				Ipv6: "invalid-ipv6",
+			},
+		},
+	}
+
+	mockGraphQL.EXPECT().
+		GetUpNodes(gomock.Any(), 0, uint32(1), uint32(0), true, true).
+		Return(testNodes, nil)
+
+	mockGraphQL.EXPECT().
+		GetUpNodes(gomock.Any(), 12, uint32(0), uint32(1), true, true).
+		Return([]graphql.Node{}, nil)
+
+	mockExec.EXPECT().
+		LookPath("iperf").
+		Return("/usr/bin/iperf", nil)
+
+	ctx := context.Background()
+	result, err := task.Run(ctx)
+
+	assert.NoError(t, err)
+	results, ok := result.([]IperfResult)
+	assert.True(t, ok)
+	assert.Len(t, results, 0)
+}
+
+func TestNewTask(t *testing.T) {
+	task := NewTask()
+	assert.NotNil(t, task)
+	assert.Equal(t, "iperf", task.ID())
+}
+
+// Helper function to create mock iperf output
+func createMockIperfOutput(isUDP bool, uploadSpeed, downloadSpeed float64) iperfCommandOutput {
+	output := iperfCommandOutput{
+		End: End{
+			SumSent: Sum{
+				BitsPerSecond: uploadSpeed,
+			},
+			SumReceived: Sum{
+				BitsPerSecond: downloadSpeed,
+			},
+			CPUUtilizationPercent: CPUUtilizationPercent{
+				HostTotal:   10.5,
+				RemoteTotal: 8.2,
+			},
+		},
+	}
+
+	if isUDP {
+		output.End.Streams = []EndStream{
+			{
+				UDP: UDPSum{
+					BitsPerSecond: downloadSpeed,
+				},
+			},
+		}
+	}
+
+	return output
+}