Improve UT coverage

cmd/podmon/main_steps_test.go

@@ -19,6 +19,7 @@ import (
 	"os"
 	"podmon/internal/csiapi"
 	"podmon/internal/k8sapi"
+	"podmon/internal/mocks"
 	"podmon/internal/monitor"
 	"strings"
 	"sync"
@@ -35,8 +36,8 @@ import (
 type mainFeature struct {
 	// Logrus test hook
 	loghook             *logtest.Hook
-	k8sapiMock          *k8sapi.K8sMock
-	csiapiMock          *csiapi.CSIMock
+	k8sapiMock          *mocks.K8sMock
+	csiapiMock          *mocks.CSIMock
 	leaderElect         *mockLeaderElect
 	failStartAPIMonitor bool
 }
@@ -53,8 +54,8 @@ func (m *mainFeature) aPodmonInstance() error {
 		fmt.Printf("loghook last-entry %+v\n", m.loghook.LastEntry())
 	}
 	monitor.PodMonitor.CSIExtensionsPresent = false
-	m.csiapiMock = new(csiapi.CSIMock)
-	m.k8sapiMock = new(k8sapi.K8sMock)
+	m.csiapiMock = new(mocks.CSIMock)
+	m.k8sapiMock = new(mocks.K8sMock)
 	GetCSIClient = m.mockGetCSIClient
 	K8sAPI = m.k8sapiMock
 	m.leaderElect = &mockLeaderElect{}

internal/criapi/criapi.go

@@ -25,7 +25,7 @@ import (
 
 	log "github.com/sirupsen/logrus"
 	"google.golang.org/grpc"
-	"k8s.io/cri-api/pkg/apis/runtime/v1"
+	v1 "k8s.io/cri-api/pkg/apis/runtime/v1"
 )
 
 // Client represents the client grpc connection to the ContainerRuntimerInterface
@@ -46,13 +46,17 @@ var CRIMaxConnectionRetry = 3
 // CRINewClientTimeout is the timeout for making a new client.
 var CRINewClientTimeout = 90 * time.Second
 
+var getGrpcDialContext = func(ctx context.Context, target string, opts ...grpc.DialOption) (conn *grpc.ClientConn, err error) {
+	return grpc.DialContext(ctx, target, opts...)
+}
+
 // NewCRIClient returns a new client connection to the ContainerRuntimeInterface or an error
 func NewCRIClient(criSock string, _ ...grpc.DialOption) (*Client, error) {
 	var err error
 	ctx, cancel := context.WithTimeout(context.Background(), CRINewClientTimeout)
 	defer cancel()
 	for i := 0; i < CRIMaxConnectionRetry; i++ {
-		CRIClient.CRIConn, err = grpc.DialContext(ctx, criSock, grpc.WithInsecure())
+		CRIClient.CRIConn, err = getGrpcDialContext(ctx, criSock, grpc.WithInsecure())
 		if err != nil || CRIClient.CRIConn == nil {
 			var errMsg string
 			if err == nil {
@@ -97,9 +101,11 @@ var knownPaths = [3]string{"/var/run/dockershim.sock", "/run/containerd/containe
 
 // ChooseCRIPath chooses an appropriate unix domain socket path to the CRI interface.
 // This is done according to the ordering described for the crictl command.
+var osStat = os.Stat
+
 func (cri *Client) ChooseCRIPath() (string, error) {
 	for _, path := range knownPaths {
-		_, err := os.Stat(path)
+		_, err := osStat(path)
 		if err == nil {
 			retval := fmt.Sprintf("unix:///%s", path)
 			return retval, nil

internal/criapi/criapi_test.go

@@ -1,6 +1,3 @@
-//go:build k8s
-// +build k8s
-
 /*
 * Copyright (c) 2021-2022 Dell Inc., or its subsidiaries. All Rights Reserved.
 *
@@ -21,41 +18,265 @@ package criapi
 
 import (
 	"context"
-	"fmt"
+	"errors"
+	"net"
+	"os"
 	"testing"
+	"time"
 
+	"github.com/stretchr/testify/assert"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/test/bufconn"
 	v1 "k8s.io/cri-api/pkg/apis/runtime/v1"
 )
 
-func TestListContainers(t *testing.T) {
-	client, err := NewCRIClient("unix:/var/run/dockershim.sock")
-	if err != nil {
-		t.Errorf("NewCRIClient: %s", err)
+// Mocking the grpc.DialContext function
+var dialContextMock = func(ctx context.Context, target string, _ ...grpc.DialOption) (*grpc.ClientConn, error) {
+	_ = target // Explicitly ignore the unused parameter
+	lis := bufconn.Listen(1024 * 1024)
+	s := grpc.NewServer()
+	v1.RegisterRuntimeServiceServer(s, &mockRuntimeServiceServer{})
+	go func() {
+		if err := s.Serve(lis); err != nil {
+			panic(err)
+		}
+	}()
+	return grpc.DialContext(ctx, "", grpc.WithContextDialer(bufconnDialer(lis)), grpc.WithInsecure())
+}
+
+func bufconnDialer(lis *bufconn.Listener) func(context.Context, string) (net.Conn, error) {
+	return func(context.Context, string) (net.Conn, error) {
+		return lis.Dial()
 	}
-	req := &v1.ListContainersRequest{}
-	rep, err := client.ListContainers(context.Background(), req)
-	if err != nil {
-		t.Errorf("ListContainers: %s", err)
-	} else {
-		for _, cont := range rep.Containers {
-			fmt.Printf("container Id %s Name %s State %s\n", cont.Id, cont.Metadata.Name, cont.State)
+}
+
+type mockRuntimeServiceServer struct {
+	v1.UnimplementedRuntimeServiceServer
+}
+
+func (s *mockRuntimeServiceServer) ListContainers(_ context.Context, _ *v1.ListContainersRequest) (*v1.ListContainersResponse, error) {
+	// Return a mock response
+	return &v1.ListContainersResponse{
+		Containers: []*v1.Container{
+			{
+				Id: "test-container-id",
+				Metadata: &v1.ContainerMetadata{
+					Name: "test-container",
+				},
+				State: v1.ContainerState_CONTAINER_RUNNING,
+			},
+		},
+	}, nil
+}
+
+func TestGetGrpcDialContext(t *testing.T) {
+	// Mock context and target
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	target := "unix:///var/run/dockershim.sock"
+
+	// Call the function
+	conn, err := getGrpcDialContext(ctx, target, grpc.WithInsecure())
+
+	// Assertions
+	assert.NoError(t, err)
+	assert.NotNil(t, conn)
+
+	// Close the connection
+	err = conn.Close()
+	assert.NoError(t, err)
+}
+
+func TestNewCRIClient_Success(t *testing.T) {
+	// Override the getGrpcDialContext function with mock
+	getGrpcDialContext = dialContextMock
+
+	client, err := NewCRIClient("unix:///var/run/dockershim.sock")
+	assert.NoError(t, err)
+	assert.NotNil(t, client)
+	assert.NotNil(t, client.CRIConn)
+	assert.NotNil(t, client.RuntimeServiceClient)
+}
+
+func TestNewCRIClient_Failure(t *testing.T) {
+	// Override the getGrpcDialContext function to simulate failure
+	getGrpcDialContext = func(_ context.Context, _ string, _ ...grpc.DialOption) (*grpc.ClientConn, error) {
+		return nil, errors.New("failed to connect")
+	}
+
+	// Reduce retry count and sleep interval for the test
+	originalRetry := CRIMaxConnectionRetry
+	originalSleep := CRIClientDialRetry
+	CRIMaxConnectionRetry = 2
+	CRIClientDialRetry = 1 * time.Second
+	defer func() {
+		CRIMaxConnectionRetry = originalRetry
+		CRIClientDialRetry = originalSleep
+	}()
+
+	_, err := NewCRIClient("unix:///var/run/dockershim.sock")
+	assert.Error(t, err)
+	//	assert.Nil(t, client)
+}
+
+func TestNewCRIClient_NilConnNoError(t *testing.T) {
+	// Simulate retries with nil connection and no error
+	retryCount := 0
+	getGrpcDialContext = func(_ context.Context, _ string, _ ...grpc.DialOption) (*grpc.ClientConn, error) {
+		retryCount++
+		if retryCount < 2 {
+			return nil, nil
 		}
+		return nil, errors.New("failed to connect after retries")
 	}
+
+	// Reduce retry count and sleep interval for the test
+	originalRetry := CRIMaxConnectionRetry
+	originalSleep := CRIClientDialRetry
+	CRIMaxConnectionRetry = 2
+	CRIClientDialRetry = 1 * time.Second
+	defer func() {
+		CRIMaxConnectionRetry = originalRetry
+		CRIClientDialRetry = originalSleep
+	}()
+
+	_, err := NewCRIClient("unix:///var/run/dockershim.sock")
+	assert.Error(t, err)
+	//	assert.Nil(t, client)
+}
+
+func TestClient_Connected(t *testing.T) {
+	client := &Client{}
+
+	// Test when CRIConn is nil
+	assert.False(t, client.Connected())
+
+	// Test when CRIConn is not nil
+	client.CRIConn = &grpc.ClientConn{}
+	assert.True(t, client.Connected())
+}
+
+func TestClient_Close(t *testing.T) {
+	client := &Client{}
+
+	// Test when CRIConn is nil
+	err := client.Close()
+	assert.NoError(t, err)
+
+	// Test when CRIConn is not nil
+	lis := bufconn.Listen(1024 * 1024)
+	conn, _ := grpc.DialContext(context.Background(), "", grpc.WithContextDialer(bufconnDialer(lis)), grpc.WithInsecure())
+	client.CRIConn = conn
+
 	err = client.Close()
-	if err != nil {
-		t.Errorf("Close: %s", err)
+	assert.NoError(t, err)
+	assert.Nil(t, client.CRIConn)
+}
+
+func TestClient_ListContainers(t *testing.T) {
+	// Mocking the grpc.DialContext function
+	getGrpcDialContext = func(ctx context.Context, _ string, _ ...grpc.DialOption) (*grpc.ClientConn, error) {
+		lis := bufconn.Listen(1024 * 1024)
+		s := grpc.NewServer()
+		v1.RegisterRuntimeServiceServer(s, &mockRuntimeServiceServer{})
+		go func() {
+			if err := s.Serve(lis); err != nil {
+				panic(err)
+			}
+		}()
+		return grpc.DialContext(ctx, "", grpc.WithContextDialer(bufconnDialer(lis)), grpc.WithInsecure())
 	}
+
+	client, err := NewCRIClient("unix:///var/run/dockershim.sock")
+	assert.NoError(t, err)
+	assert.NotNil(t, client)
+
+	req := &v1.ListContainersRequest{}
+	resp, err := client.ListContainers(context.Background(), req)
+	assert.NoError(t, err)
+	assert.NotNil(t, resp)
+	assert.Len(t, resp.Containers, 1)
+	assert.Equal(t, "test-container-id", resp.Containers[0].Id)
+	assert.Equal(t, "test-container", resp.Containers[0].Metadata.Name)
+	assert.Equal(t, v1.ContainerState_CONTAINER_RUNNING, resp.Containers[0].State)
+}
+
+func TestChooseCRIPath_Success(t *testing.T) {
+	// Override osStat with mockStat
+	originalStat := osStat
+	osStat = mockStat
+	defer func() { osStat = originalStat }() // Restore original osStat after test
+
+	client := &Client{}
+	path, err := client.ChooseCRIPath()
+	assert.NoError(t, err)
+	assert.Equal(t, "unix:////var/run/dockershim.sock", path)
 }
 
-func TestGetContainerInfo(t *testing.T) {
-	infoMap, err := CRIClient.GetContainerInfo(context.Background())
-	if err != nil {
-		t.Errorf("GetContainerInfo failed: %s", err)
+func TestChooseCRIPath_Failure(t *testing.T) {
+	// Override osStat with a mock implementation that simulates all paths not existing
+	originalStat := osStat
+	osStat = func(_ string) (os.FileInfo, error) {
+		return nil, os.ErrNotExist
 	}
-	for key, value := range infoMap {
-		if key != value.ID {
-			t.Error("key != value.ID")
+	defer func() { osStat = originalStat }() // Restore original osStat after test
+
+	client := &Client{}
+	path, err := client.ChooseCRIPath()
+	assert.Error(t, err)
+	assert.Equal(t, "", path)
+	assert.Equal(t, "Could not find path for CRI runtime from knownPaths", err.Error())
+}
+
+var dialContextMockForGetContainerInfo = func(ctx context.Context, _ string, _ ...grpc.DialOption) (*grpc.ClientConn, error) {
+	lis := bufconn.Listen(1024 * 1024)
+	s := grpc.NewServer()
+	v1.RegisterRuntimeServiceServer(s, &mockRuntimeServiceServer{})
+	go func() {
+		if err := s.Serve(lis); err != nil {
+			panic(err)
 		}
-		fmt.Printf("ContainerInfo %+v\n", *value)
+	}()
+	return grpc.DialContext(ctx, "", grpc.WithContextDialer(bufconnDialer(lis)), grpc.WithInsecure())
+}
+
+func mockStat(path string) (os.FileInfo, error) {
+	if path == "/var/run/dockershim.sock" || path == "/run/containerd/containerd.sock" || path == "/run/crio/crio.sock" {
+		return nil, nil // Simulate that the file exists
+	}
+	return nil, os.ErrNotExist // Simulate that the file does not exist
+}
+
+func TestGetContainerInfo_Success(t *testing.T) {
+	// Override osStat with mockStat
+	originalStat := osStat
+	osStat = mockStat
+	defer func() { osStat = originalStat }() // Restore original osStat after test
+
+	// Override the getGrpcDialContext function with our mock
+	getGrpcDialContext = dialContextMockForGetContainerInfo
+
+	client := &Client{}
+	result, err := client.GetContainerInfo(context.Background())
+	assert.NoError(t, err)
+	assert.NotNil(t, result)
+	assert.Len(t, result, 1)
+	assert.Equal(t, "test-container-id", result["test-container-id"].ID)
+	assert.Equal(t, "test-container", result["test-container-id"].Name)
+	assert.Equal(t, v1.ContainerState_CONTAINER_RUNNING, result["test-container-id"].State)
+}
+
+func TestGetContainerInfo_ChooseCRIPathFailure(t *testing.T) {
+	// Override osStat with a mock implementation that simulates all paths not existing
+	originalStat := osStat
+	osStat = func(_ string) (os.FileInfo, error) {
+		return nil, os.ErrNotExist
 	}
+	defer func() { osStat = originalStat }() // Restore original osStat after test
+
+	client := &Client{}
+	result, err := client.GetContainerInfo(context.Background())
+	assert.Error(t, err)
+	assert.Equal(t, "Could not find path for CRI runtime from knownPaths", err.Error())
+	assert.Empty(t, result)
 }

internal/csiapi/csi.go

@@ -40,12 +40,16 @@ var CSIClient Client
 // CSIClientDialRetry is timeout after failure to connect to the CSI Driver
 var CSIClientDialRetry = 30 * time.Second
 
+var getGrpcDialContext = func(ctx context.Context, target string, opts ...grpc.DialOption) (conn *grpc.ClientConn, err error) {
+	return grpc.DialContext(ctx, target, opts...)
+}
+
 // NewCSIClient returns a new CSIApi interface
 func NewCSIClient(csiSock string, clientOpts ...grpc.DialOption) (CSIApi, error) {
 	var err error
 	for {
 		// Wait on the driver. It will not open its unix socket until it has become leader.
-		CSIClient.DriverConn, err = grpc.DialContext(context.Background(), csiSock, clientOpts...)
+		CSIClient.DriverConn, err = getGrpcDialContext(context.Background(), csiSock, clientOpts...)
 		log.Debugf("grpc.Dial returned %v %v", CSIClient.DriverConn, err)
 		if err != nil || CSIClient.DriverConn == nil {
 			var errMsg string