Implement unit test in gRPC service

grpc/src/main/java/com/baeldung/grpc/userservice/client/UserClient.java

@@ -0,0 +1,24 @@
+package com.baeldung.grpc.userservice.client;
+
+import com.baeldung.grpc.userservice.User;
+import com.baeldung.grpc.userservice.UserRequest;
+import com.baeldung.grpc.userservice.UserServiceGrpc;
+import io.grpc.ManagedChannel;
+
+public class UserClient {
+    private final UserServiceGrpc.UserServiceBlockingStub userServiceStub;
+    private final ManagedChannel managedChannel;
+
+    public UserClient(ManagedChannel managedChannel) {
+        this.managedChannel = managedChannel;
+        this.userServiceStub = UserServiceGrpc.newBlockingStub(managedChannel);
+    }
+
+    public User getUser(int id) {
+        UserRequest userRequest = UserRequest.newBuilder()
+          .setId(id)
+          .build();
+
+        return userServiceStub.getUser(userRequest).getUser();
+    }
+}

grpc/src/main/java/com/baeldung/grpc/userservice/server/UserNotFoundException.java

@@ -0,0 +1,7 @@
+package com.baeldung.grpc.userservice.server;
+
+public class UserNotFoundException extends RuntimeException {
+    public UserNotFoundException(int userId) {
+        super(String.format("User not found with ID %s", userId));
+    }
+}

grpc/src/main/java/com/baeldung/grpc/userservice/server/UserServiceImpl.java

@@ -0,0 +1,42 @@
+package com.baeldung.grpc.userservice.server;
+
+import com.baeldung.grpc.userservice.User;
+import com.baeldung.grpc.userservice.UserRequest;
+import com.baeldung.grpc.userservice.UserResponse;
+import com.baeldung.grpc.userservice.UserServiceGrpc;
+import io.grpc.Status;
+import io.grpc.stub.StreamObserver;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Map;
+import java.util.Optional;
+
+public class UserServiceImpl extends UserServiceGrpc.UserServiceImplBase {
+    private static final Logger logger = LoggerFactory.getLogger(UserServiceImpl.class);
+
+    private final Map<Integer, User> userRepositoryMap = Map.of(1, User.newBuilder()
+        .setId(1)
+        .setName("user1")
+        .setEmail("[email protected]")
+        .build());
+
+    @Override
+    public void getUser(UserRequest request, StreamObserver<UserResponse> responseObserver) {
+        try {
+            User user = Optional.ofNullable(userRepositoryMap.get(request.getId()))
+                .orElseThrow(() -> new UserNotFoundException(request.getId()));
+
+            UserResponse response = UserResponse.newBuilder()
+                .setUser(user)
+                .build();
+
+            responseObserver.onNext(response);
+            responseObserver.onCompleted();
+            logger.info("Return User for id {}", request.getId());
+        } catch (UserNotFoundException ex) {
+            responseObserver.onError(Status.NOT_FOUND.withDescription(ex.getMessage()).asRuntimeException());
+        }
+    }
+}
+

grpc/src/main/proto/user_service.proto

@@ -0,0 +1,23 @@
+syntax = "proto3";
+
+package userservice;
+option java_multiple_files = true;
+option java_package = "com.baeldung.grpc.userservice";
+
+service UserService {
+  rpc GetUser(UserRequest) returns (UserResponse);
+}
+
+message UserRequest {
+  int32 id = 1;
+}
+
+message UserResponse {
+  User user = 1;
+}
+
+message User {
+  int32 id = 1;
+  string name = 2;
+  string email = 3;
+}

grpc/src/test/java/com/baeldung/grpc/userservice/client/UserClientUnitTest.java

@@ -0,0 +1,76 @@
+package com.baeldung.grpc.userservice.client;
+
+import com.baeldung.grpc.userservice.User;
+import com.baeldung.grpc.userservice.UserResponse;
+import com.baeldung.grpc.userservice.UserServiceGrpc;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.stub.StreamObserver;
+import org.junit.jupiter.api.*;
+import org.mockito.Mockito;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.spy;
+
+public class UserClientUnitTest {
+    private UserClient userClient;
+    private UserServiceGrpc.UserServiceImplBase mockUserService;
+    private Server inProcessServer;
+    private ManagedChannel managedChannel;
+
+    @BeforeEach
+    public void setup() throws Exception {
+        String serverName = InProcessServerBuilder.generateName();
+        mockUserService = spy(UserServiceGrpc.UserServiceImplBase.class);
+
+        inProcessServer = InProcessServerBuilder
+            .forName(serverName)
+            .directExecutor()
+            .addService(mockUserService)
+            .build()
+            .start();
+
+        managedChannel = InProcessChannelBuilder.forName(serverName)
+            .directExecutor()
+            .usePlaintext()
+            .build();
+
+        userClient = new UserClient(managedChannel);
+    }
+
+    @AfterEach
+    void tearDown() {
+        managedChannel.shutdownNow();
+        inProcessServer.shutdownNow();
+    }
+
+    @Test
+    void givenUserIsPresent_whenGetUserIsCalled_ThenReturnUser() {
+        User expectedUser = User.newBuilder()
+            .setId(1)
+            .setName("user1")
+            .setEmail("[email protected]")
+            .build();
+
+        mockGetUser(expectedUser);
+
+        User user = userClient.getUser(1);
+        assertEquals(expectedUser, user);
+    }
+
+    private void mockGetUser(User expectedUser) {
+        Mockito.doAnswer(invocation -> {
+            StreamObserver<UserResponse> observer = invocation.getArgument(1);
+            UserResponse response = UserResponse.newBuilder()
+                .setUser(expectedUser)
+                .build();
+
+            observer.onNext(response);
+            observer.onCompleted();
+            return null;
+        }).when(mockUserService).getUser(any(), any());
+    }
+}

grpc/src/test/java/com/baeldung/grpc/userservice/server/UserServiceUnitTest.java

@@ -0,0 +1,78 @@
+package com.baeldung.grpc.userservice.server;
+
+import com.baeldung.grpc.userservice.UserRequest;
+import com.baeldung.grpc.userservice.UserResponse;
+import com.baeldung.grpc.userservice.UserServiceGrpc;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class UserServiceUnitTest {
+    private UserServiceGrpc.UserServiceBlockingStub userServiceBlockingStub;
+    private Server inProcessServer;
+    private ManagedChannel managedChannel;
+
+    @BeforeEach
+    void setup() throws IOException {
+        String serviceName = InProcessServerBuilder.generateName();
+
+        inProcessServer = InProcessServerBuilder.forName(serviceName)
+            .directExecutor()
+            .addService(new UserServiceImpl())
+            .build()
+            .start();
+
+        managedChannel = InProcessChannelBuilder.forName(serviceName)
+            .directExecutor()
+            .usePlaintext()
+            .build();
+
+        userServiceBlockingStub = UserServiceGrpc.newBlockingStub(managedChannel);
+    }
+
+    @AfterEach
+    void tearDown() {
+        managedChannel.shutdownNow();
+        inProcessServer.shutdownNow();
+    }
+
+    @Test
+    void givenUserIsPresent_whenGetUserIsCalled_ThenReturnUser() {
+        UserRequest userRequest = UserRequest.newBuilder()
+            .setId(1)
+            .build();
+
+        UserResponse userResponse = userServiceBlockingStub.getUser(userRequest);
+
+        assertNotNull(userResponse);
+        assertNotNull(userResponse.getUser());
+        assertEquals(1, userResponse.getUser().getId());
+        assertEquals("user1", userResponse.getUser().getName());
+        assertEquals("[email protected]", userResponse.getUser().getEmail());
+    }
+
+    @Test
+    void givenUserIsNotPresent_whenGetUserIsCalled_ThenThrowRuntimeException(){
+        UserRequest userRequest = UserRequest.newBuilder()
+            .setId(3)
+            .build();
+
+        StatusRuntimeException statusRuntimeException = assertThrows(StatusRuntimeException.class,
+            () -> userServiceBlockingStub.getUser(userRequest));
+
+        assertNotNull(statusRuntimeException);
+        assertNotNull(statusRuntimeException.getStatus());
+        assertEquals(Status.NOT_FOUND.getCode(), statusRuntimeException.getStatus().getCode());
+        assertEquals("User not found with ID 3", statusRuntimeException.getStatus().getDescription());
+    }
+}