COCOS-159 - Improve test coverage to 65% (#310)

* few atls tests Signed-off-by: Sammy Oina <[email protected]> * remove commented code Signed-off-by: Sammy Oina <[email protected]> * add atls tests Signed-off-by: Sammy Oina <[email protected]> * new line Signed-off-by: Sammy Oina <[email protected]> * add more test cases Signed-off-by: Sammy Oina <[email protected]> * more test cases Signed-off-by: Sammy Oina <[email protected]> * add empty line and parallel test cases Signed-off-by: Sammy Oina <[email protected]> * move const outside test case Signed-off-by: Sammy Oina <[email protected]> --------- Signed-off-by: Sammy Oina <[email protected]>
ultravioletrs · Nov 19, 2024 · 5a22ac2 · 5a22ac2
1 parent d5941ed
commit 5a22ac2
Show file tree

Hide file tree

Showing 11 changed files with 711 additions and 197 deletions.
diff --git a/internal/file_test.go b/internal/file_test.go
@@ -38,6 +38,13 @@ func TestCopyFile(t *testing.T) {
 	}
 }
 
+func TestCopyFile_NonExistentSource(t *testing.T) {
+	err := CopyFile("nonexistent.txt", "destination.txt")
+	if err == nil {
+		t.Error("CopyFile did not return an error for a nonexistent source file")
+	}
+}
+
 func TestDeleteFilesInDir(t *testing.T) {
 	tempDir, err := os.MkdirTemp("", "deletefiles_test")
 	if err != nil {
@@ -111,6 +118,13 @@ func TestChecksum(t *testing.T) {
 	}
 }
 
+func TestChecksum_NonExistentFile(t *testing.T) {
+	_, err := Checksum("nonexistent.txt")
+	if err == nil {
+		t.Error("Checksum did not return an error for a nonexistent file")
+	}
+}
+
 func TestChecksumHex(t *testing.T) {
 	tempFile, err := os.CreateTemp("", "checksumhex_test")
 	if err != nil {
@@ -134,3 +148,10 @@ func TestChecksumHex(t *testing.T) {
 		t.Errorf("ChecksumHex mismatch. Got %s, want %s", checksumHex, expectedChecksumHex)
 	}
 }
+
+func TestChecksumHex_NonExistentFile(t *testing.T) {
+	_, err := ChecksumHex("nonexistent.txt")
+	if err == nil {
+		t.Error("ChecksumHex did not return an error for a nonexistent file")
+	}
+}
diff --git a/manager/api/grpc/client_test.go b/manager/api/grpc/client_test.go
@@ -33,26 +33,100 @@ func (m *mockStream) Send(msg *manager.ClientStreamMessage) error {
 	return args.Error(0)
 }
 
-func TestManagerClient_Process(t *testing.T) {
-	mockStream := new(mockStream)
-	mockSvc := new(mocks.Service)
-	messageQueue := make(chan *manager.ClientStreamMessage, 10)
-	logger := mglog.NewMock()
+func TestManagerClient_Process1(t *testing.T) {
+	tests := []struct {
+		name        string
+		setupMocks  func(mockStream *mockStream, mockSvc *mocks.Service)
+		expectError bool
+		errorMsg    string
+	}{
+		{
+			name: "Stop computation",
+			setupMocks: func(mockStream *mockStream, mockSvc *mocks.Service) {
+				mockStream.On("Recv").Return(&manager.ServerStreamMessage{
+					Message: &manager.ServerStreamMessage_StopComputation{
+						StopComputation: &manager.StopComputation{},
+					},
+				}, nil)
+				mockStream.On("Send", mock.Anything).Return(nil)
+				mockSvc.On("Stop", mock.Anything, mock.Anything).Return(nil)
+			},
+			expectError: true,
+			errorMsg:    "context deadline exceeded",
+		},
+		{
+			name: "Terminate request",
+			setupMocks: func(mockStream *mockStream, mockSvc *mocks.Service) {
+				mockStream.On("Recv").Return(&manager.ServerStreamMessage{
+					Message: &manager.ServerStreamMessage_TerminateReq{
+						TerminateReq: &manager.Terminate{},
+					},
+				}, nil)
+			},
+			expectError: true,
+			errorMsg:    errTerminationFromServer.Error(),
+		},
+		{
+			name: "Backend info request",
+			setupMocks: func(mockStream *mockStream, mockSvc *mocks.Service) {
+				mockStream.On("Recv").Return(&manager.ServerStreamMessage{
+					Message: &manager.ServerStreamMessage_BackendInfoReq{
+						BackendInfoReq: &manager.BackendInfoReq{},
+					},
+				}, nil)
+				mockStream.On("Send", mock.Anything).Return(nil).Once()
+				mockSvc.On("FetchBackendInfo", mock.Anything, mock.Anything).Return(nil, assert.AnError)
+			},
+			expectError: true,
+		},
+		{
+			name: "Run request chunks",
+			setupMocks: func(mockStream *mockStream, mockSvc *mocks.Service) {
+				mockStream.On("Recv").Return(&manager.ServerStreamMessage{
+					Message: &manager.ServerStreamMessage_RunReqChunks{
+						RunReqChunks: &manager.RunReqChunks{},
+					},
+				}, nil)
+				mockStream.On("Send", mock.Anything).Return(nil).Once()
+				mockSvc.On("Run", mock.Anything, mock.Anything).Return("", assert.AnError).Once()
+			},
+			expectError: true,
+		},
+		{
+			name: "Receive error",
+			setupMocks: func(mockStream *mockStream, mockSvc *mocks.Service) {
+				mockStream.On("Recv").Return(&manager.ServerStreamMessage{}, assert.AnError)
+			},
+			expectError: true,
+		},
+	}
 
-	client := NewClient(mockStream, mockSvc, messageQueue, logger)
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			mockStream := new(mockStream)
+			mockSvc := new(mocks.Service)
+			messageQueue := make(chan *manager.ClientStreamMessage, 10)
+			logger := mglog.NewMock()
 
-	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
-	defer cancel()
+			client := NewClient(mockStream, mockSvc, messageQueue, logger)
 
-	mockStream.On("Recv").Return(&manager.ServerStreamMessage{Message: &manager.ServerStreamMessage_StopComputation{StopComputation: &manager.StopComputation{}}}, nil).Maybe()
-	mockStream.On("Send", mock.Anything).Return(nil).Maybe()
+			ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+			defer cancel()
 
-	mockSvc.On("Stop", mock.Anything, mock.Anything).Return(nil).Maybe()
+			tc.setupMocks(mockStream, mockSvc)
 
-	err := client.Process(ctx, cancel)
+			err := client.Process(ctx, cancel)
 
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "context deadline exceeded")
+			if tc.expectError {
+				assert.Error(t, err)
+				if tc.errorMsg != "" {
+					assert.Contains(t, err.Error(), tc.errorMsg)
+				}
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
 }
 
 func TestManagerClient_handleRunReqChunks(t *testing.T) {
@@ -233,3 +307,16 @@ func TestManagerClient_handleSVMInfoReq(t *testing.T) {
 	assert.Equal(t, "", infoRes.SvmInfo.EosVersion)
 	assert.Equal(t, qemu.KernelCommandLine, infoRes.SvmInfo.KernelCmd)
 }
+
+func TestManagerClient_timeoutRequest(t *testing.T) {
+	rm := newRunRequestManager()
+	rm.requests["test-id"] = &runRequest{
+		timer:     time.NewTimer(100 * time.Millisecond),
+		buffer:    []byte("test-data"),
+		lastChunk: time.Now(),
+	}
+
+	rm.timeoutRequest("test-id")
+
+	assert.Len(t, rm.requests, 0)
+}
diff --git a/manager/api/grpc/server_test.go b/manager/api/grpc/server_test.go
@@ -54,34 +54,60 @@ func TestNewServer(t *testing.T) {
 }
 
 func TestGrpcServer_Process(t *testing.T) {
-	incoming := make(chan *manager.ClientStreamMessage, 1)
-	mockSvc := new(mockService)
-	server := NewServer(incoming, mockSvc).(*grpcServer)
-
-	mockStream := new(mockServerStream)
-	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
-	defer cancel()
-
-	mockStream.On("Context").Return(peer.NewContext(ctx, &peer.Peer{
-		Addr:     mockAddr{},
-		AuthInfo: mockAuthInfo{},
-	}))
-
-	go func() {
-		for mes := range incoming {
-			assert.NotNil(t, mes)
-		}
-	}()
-
-	mockStream.On("Recv").Return(&manager.ClientStreamMessage{}, nil)
-	mockSvc.On("Run", mock.Anything, "test", mock.Anything, mock.AnythingOfType("mockAuthInfo")).Return()
-
-	err := server.Process(mockStream)
+	tests := []struct {
+		name          string
+		recvReturn    *manager.ClientStreamMessage
+		recvError     error
+		expectedError string
+	}{
+		{
+			name:          "Process with context deadline exceeded",
+			recvReturn:    &manager.ClientStreamMessage{},
+			recvError:     nil,
+			expectedError: "context deadline exceeded",
+		},
+		{
+			name:          "Process with Recv error",
+			recvReturn:    &manager.ClientStreamMessage{},
+			recvError:     errors.New("recv error"),
+			expectedError: "recv error",
+		},
+	}
 
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "context deadline exceeded")
-	mockStream.AssertExpectations(t)
-	mockSvc.AssertExpectations(t)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			incoming := make(chan *manager.ClientStreamMessage, 1)
+			mockSvc := new(mockService)
+			server := NewServer(incoming, mockSvc).(*grpcServer)
+
+			mockStream := new(mockServerStream)
+			ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+			defer cancel()
+
+			mockStream.On("Context").Return(peer.NewContext(ctx, &peer.Peer{
+				Addr:     mockAddr{},
+				AuthInfo: mockAuthInfo{},
+			}))
+
+			if tt.recvError == nil {
+				go func() {
+					for mes := range incoming {
+						assert.NotNil(t, mes)
+					}
+				}()
+			}
+
+			mockStream.On("Recv").Return(tt.recvReturn, tt.recvError)
+			mockSvc.On("Run", mock.Anything, "test", mock.Anything, mock.AnythingOfType("mockAuthInfo")).Return()
+
+			err := server.Process(mockStream)
+
+			assert.Error(t, err)
+			assert.Contains(t, err.Error(), tt.expectedError)
+			mockStream.AssertExpectations(t)
+			mockSvc.AssertExpectations(t)
+		})
+	}
 }
 
 func TestGrpcServer_sendRunReqInChunks(t *testing.T) {
@@ -138,58 +164,90 @@ type mockAuthInfo struct{}
 func (mockAuthInfo) AuthType() string { return "test auth" }
 
 func TestGrpcServer_ProcessWithMockService(t *testing.T) {
-	incoming := make(chan *manager.ClientStreamMessage, 10)
-	mockSvc := new(mockService)
-	server := NewServer(incoming, mockSvc).(*grpcServer)
-
-	go func() {
-		for mes := range incoming {
-			assert.NotNil(t, mes)
-		}
-	}()
+	tests := []struct {
+		name        string
+		setupMockFn func(*mockService, *mockServerStream)
+	}{
+		{
+			name: "Run Request Test",
+			setupMockFn: func(mockSvc *mockService, mockStream *mockServerStream) {
+				mockSvc.On("Run", mock.Anything, "test", mock.Anything, mock.AnythingOfType("mockAuthInfo")).
+					Run(func(args mock.Arguments) {
+						sendFunc := args.Get(2).(SendFunc)
+						runReq := &manager.ComputationRunReq{Id: "test-run-id"}
+						err := sendFunc(&manager.ServerStreamMessage{
+							Message: &manager.ServerStreamMessage_RunReq{
+								RunReq: runReq,
+							},
+						})
+						assert.NoError(t, err)
+					}).
+					Return()
+
+				mockStream.On("Send", mock.MatchedBy(func(msg *manager.ServerStreamMessage) bool {
+					chunks := msg.GetRunReqChunks()
+					return chunks != nil && chunks.Id == "test-run-id"
+				})).Return(nil)
+			},
+		},
+		{
+			name: "Terminate Request Test",
+			setupMockFn: func(mockSvc *mockService, mockStream *mockServerStream) {
+				mockSvc.On("Run", mock.Anything, "test", mock.Anything, mock.AnythingOfType("mockAuthInfo")).
+					Run(func(args mock.Arguments) {
+						sendFunc := args.Get(2).(SendFunc)
+						err := sendFunc(&manager.ServerStreamMessage{
+							Message: &manager.ServerStreamMessage_TerminateReq{
+								TerminateReq: &manager.Terminate{},
+							},
+						})
+						assert.NoError(t, err)
+					}).Return()
+
+				mockStream.On("Send", mock.AnythingOfType("*manager.ServerStreamMessage")).Return(nil)
+			},
+		},
+	}
 
-	mockStream := new(mockServerStream)
-	ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
-	defer cancel()
-
-	peerCtx := peer.NewContext(ctx, &peer.Peer{
-		Addr:     mockAddr{},
-		AuthInfo: mockAuthInfo{},
-	})
-
-	mockStream.On("Context").Return(peerCtx)
-	mockStream.On("Recv").Return(&manager.ClientStreamMessage{}, nil).Maybe()
-
-	mockSvc.On("Run", mock.Anything, "test", mock.Anything, mock.AnythingOfType("mockAuthInfo")).
-		Run(func(args mock.Arguments) {
-			sendFunc := args.Get(2).(SendFunc)
-			// Simulate sending a RunReq
-			runReq := &manager.ComputationRunReq{Id: "test-run-id"}
-			err := sendFunc(&manager.ServerStreamMessage{
-				Message: &manager.ServerStreamMessage_RunReq{
-					RunReq: runReq,
-				},
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			incoming := make(chan *manager.ClientStreamMessage, 10)
+			mockSvc := new(mockService)
+			server := NewServer(incoming, mockSvc).(*grpcServer)
+
+			go func() {
+				for mes := range incoming {
+					assert.NotNil(t, mes)
+				}
+			}()
+
+			mockStream := new(mockServerStream)
+			ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
+			defer cancel()
+
+			peerCtx := peer.NewContext(ctx, &peer.Peer{
+				Addr:     mockAddr{},
+				AuthInfo: mockAuthInfo{},
 			})
-			assert.NoError(t, err)
-		}).
-		Return()
 
-	mockStream.On("Send", mock.MatchedBy(func(msg *manager.ServerStreamMessage) bool {
-		chunks := msg.GetRunReqChunks()
-		return chunks != nil && chunks.Id == "test-run-id"
-	})).Return(nil)
+			mockStream.On("Context").Return(peerCtx)
+			mockStream.On("Recv").Return(&manager.ClientStreamMessage{}, nil).Maybe()
 
-	go func() {
-		time.Sleep(150 * time.Millisecond)
-		cancel()
-	}()
+			tt.setupMockFn(mockSvc, mockStream)
 
-	err := server.Process(mockStream)
+			go func() {
+				time.Sleep(150 * time.Millisecond)
+				cancel()
+			}()
 
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "context canceled")
-	mockStream.AssertExpectations(t)
-	mockSvc.AssertExpectations(t)
+			err := server.Process(mockStream)
+
+			assert.Error(t, err)
+			assert.Contains(t, err.Error(), "context canceled")
+			mockStream.AssertExpectations(t)
+			mockSvc.AssertExpectations(t)
+		})
+	}
 }
 
 func TestGrpcServer_sendRunReqInChunksError(t *testing.T) {