MACRO NEPAL
gRPC Testing with Java: Comprehensive Guide
awiskar acharya
November 19, 2025
11:27 am

gRPC testing involves verifying both client and server implementations, testing various scenarios, and ensuring the reliability of your gRPC services.

Core Concepts

What is gRPC Testing?

  • Unit testing of gRPC services and clients
  • Integration testing of gRPC communication
  • Testing different gRPC call types (Unary, Streaming)
  • Mocking gRPC services for isolated testing
  • Performance and load testing

Key Testing Strategies:

  • In-process testing: Running gRPC server in test
  • Mock servers: Simulating gRPC service behavior
  • Test containers: Using real gRPC servers in containers
  • Wire mocking: Intercepting gRPC calls

Dependencies and Setup

Maven Dependencies
<properties>
<grpc.version>1.59.0</grpc.version>
<protobuf.version>3.25.1</protobuf.version>
<grpc-spring-boot.version>2.15.0.RELEASE</grpc-spring-boot.version>
<junit.version>5.9.2</junit.version>
<mockito.version>5.5.0</mockito.version>
<testcontainers.version>1.19.1</testcontainers.version>
</properties>
<dependencies>
<!-- gRPC -->
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-core</artifactId>
<version>${grpc.version}</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-stub</artifactId>
<version>${grpc.version}</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-protobuf</artifactId>
<version>${grpc.version}</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-netty-shaded</artifactId>
<version>${grpc.version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-testing</artifactId>
<version>${grpc.version}</version>
<scope>test</scope>
</dependency>
<!-- Protobuf -->
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java</artifactId>
<version>${protobuf.version}</version>
</dependency>
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java-util</artifactId>
<version>${protobuf.version}</version>
</dependency>
<!-- Spring Boot gRPC -->
<dependency>
<groupId>net.devh</groupId>
<artifactId>grpc-spring-boot-starter</artifactId>
<version>${grpc-spring-boot.version}</version>
</dependency>
<!-- Testing -->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>${mockito.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-junit-jupiter</artifactId>
<version>${mockito.version}</version>
<scope>test</scope>
</dependency>
<!-- Test Containers -->
<dependency>
<groupId>org.testcontainers</groupId>
<artifactId>junit-jupiter</artifactId>
<version>${testcontainers.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.testcontainers</groupId>
<artifactId>testcontainers</artifactId>
<version>${testcontainers.version}</version>
<scope>test</scope>
</dependency>
<!-- Assertions -->
<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
<version>3.24.2</version>
<scope>test</scope>
</dependency>
<!-- Awaitility -->
<dependency>
<groupId>org.awaitility</groupId>
<artifactId>awaitility</artifactId>
<version>4.2.0</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.xolstice.maven.plugins</groupId>
<artifactId>protobuf-maven-plugin</artifactId>
<version>0.6.1</version>
<configuration>
<protocArtifact>com.google.protobuf:protoc:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
<pluginId>grpc-java</pluginId>
<pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>compile-custom</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
Protocol Buffer Definitions
// src/main/proto/user_service.proto
syntax = "proto3";
package com.example.grpc;
option java_package = "com.example.grpc";
option java_multiple_files = true;
// User service definition
service UserService {
// Unary RPC
rpc GetUser (GetUserRequest) returns (UserResponse);
rpc CreateUser (CreateUserRequest) returns (UserResponse);
rpc UpdateUser (UpdateUserRequest) returns (UserResponse);
rpc DeleteUser (DeleteUserRequest) returns (DeleteUserResponse);
// Server streaming RPC
rpc ListUsers (ListUsersRequest) returns (stream UserResponse);
// Client streaming RPC
rpc CreateUsers (stream CreateUserRequest) returns (CreateUsersResponse);
// Bidirectional streaming RPC
rpc Chat (stream ChatMessage) returns (stream ChatMessage);
}
// Request/Response messages
message GetUserRequest {
string user_id = 1;
}
message CreateUserRequest {
string name = 1;
string email = 2;
int32 age = 3;
}
message UpdateUserRequest {
string user_id = 1;
string name = 2;
string email = 3;
int32 age = 4;
}
message DeleteUserRequest {
string user_id = 1;
}
message DeleteUserResponse {
bool success = 1;
string message = 2;
}
message ListUsersRequest {
int32 page_size = 1;
string page_token = 2;
}
message CreateUsersResponse {
int32 created_count = 1;
repeated string user_ids = 2;
}
message UserResponse {
string user_id = 1;
string name = 2;
string email = 3;
int32 age = 4;
string created_at = 5;
string updated_at = 6;
}
message ChatMessage {
string user_id = 1;
string message = 2;
int64 timestamp = 3;
}

gRPC Service Implementation

1. User Service Implementation
package com.example.grpc.service;
import com.example.grpc.*;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;
import org.lognet.springboot.grpc.GRpcService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
@GRpcService
public class UserServiceImpl extends UserServiceGrpc.UserServiceImplBase {
private static final Logger logger = LoggerFactory.getLogger(UserServiceImpl.class);
private final Map<String, UserResponse> userStore = new ConcurrentHashMap<>();
private final AtomicInteger userIdCounter = new AtomicInteger(1);
@Override
public void getUser(GetUserRequest request, StreamObserver<UserResponse> responseObserver) {
logger.info("GetUser request for ID: {}", request.getUserId());
String userId = request.getUserId();
UserResponse user = userStore.get(userId);
if (user == null) {
responseObserver.onError(Status.NOT_FOUND
.withDescription("User not found: " + userId)
.asRuntimeException());
return;
}
responseObserver.onNext(user);
responseObserver.onCompleted();
}
@Override
public void createUser(CreateUserRequest request, StreamObserver<UserResponse> responseObserver) {
logger.info("CreateUser request for: {}", request.getEmail());
try {
// Validate request
if (request.getName().isEmpty() || request.getEmail().isEmpty()) {
responseObserver.onError(Status.INVALID_ARGUMENT
.withDescription("Name and email are required")
.asRuntimeException());
return;
}
// Check if user already exists
boolean userExists = userStore.values().stream()
.anyMatch(user -> user.getEmail().equals(request.getEmail()));
if (userExists) {
responseObserver.onError(Status.ALREADY_EXISTS
.withDescription("User with email already exists: " + request.getEmail())
.asRuntimeException());
return;
}
// Create user
String userId = "user_" + userIdCounter.getAndIncrement();
UserResponse user = UserResponse.newBuilder()
.setUserId(userId)
.setName(request.getName())
.setEmail(request.getEmail())
.setAge(request.getAge())
.setCreatedAt(String.valueOf(System.currentTimeMillis()))
.setUpdatedAt(String.valueOf(System.currentTimeMillis()))
.build();
userStore.put(userId, user);
logger.info("User created successfully: {}", userId);
responseObserver.onNext(user);
responseObserver.onCompleted();
} catch (Exception e) {
logger.error("Error creating user", e);
responseObserver.onError(Status.INTERNAL
.withDescription("Failed to create user")
.withCause(e)
.asRuntimeException());
}
}
@Override
public void updateUser(UpdateUserRequest request, StreamObserver<UserResponse> responseObserver) {
logger.info("UpdateUser request for ID: {}", request.getUserId());
try {
String userId = request.getUserId();
UserResponse existingUser = userStore.get(userId);
if (existingUser == null) {
responseObserver.onError(Status.NOT_FOUND
.withDescription("User not found: " + userId)
.asRuntimeException());
return;
}
// Update user
UserResponse updatedUser = UserResponse.newBuilder(existingUser)
.setName(request.getName())
.setEmail(request.getEmail())
.setAge(request.getAge())
.setUpdatedAt(String.valueOf(System.currentTimeMillis()))
.build();
userStore.put(userId, updatedUser);
logger.info("User updated successfully: {}", userId);
responseObserver.onNext(updatedUser);
responseObserver.onCompleted();
} catch (Exception e) {
logger.error("Error updating user", e);
responseObserver.onError(Status.INTERNAL
.withDescription("Failed to update user")
.withCause(e)
.asRuntimeException());
}
}
@Override
public void deleteUser(DeleteUserRequest request, StreamObserver<DeleteUserResponse> responseObserver) {
logger.info("DeleteUser request for ID: {}", request.getUserId());
String userId = request.getUserId();
UserResponse removedUser = userStore.remove(userId);
DeleteUserResponse response = DeleteUserResponse.newBuilder()
.setSuccess(removedUser != null)
.setMessage(removedUser != null ? 
"User deleted successfully" : "User not found")
.build();
responseObserver.onNext(response);
responseObserver.onCompleted();
}
@Override
public void listUsers(ListUsersRequest request, StreamObserver<UserResponse> responseObserver) {
logger.info("ListUsers request - page size: {}", request.getPageSize());
try {
int pageSize = request.getPageSize() > 0 ? request.getPageSize() : 10;
List<UserResponse> users = new ArrayList<>(userStore.values());
// Simulate pagination
int endIndex = Math.min(pageSize, users.size());
List<UserResponse> pageUsers = users.subList(0, endIndex);
for (UserResponse user : pageUsers) {
responseObserver.onNext(user);
// Simulate some processing time
Thread.sleep(100);
}
responseObserver.onCompleted();
logger.info("ListUsers completed, sent {} users", pageUsers.size());
} catch (Exception e) {
logger.error("Error listing users", e);
responseObserver.onError(Status.INTERNAL
.withDescription("Failed to list users")
.withCause(e)
.asRuntimeException());
}
}
@Override
public StreamObserver<CreateUserRequest> createUsers(StreamObserver<CreateUsersResponse> responseObserver) {
logger.info("CreateUsers streaming request started");
return new StreamObserver<CreateUserRequest>() {
private final List<String> createdUserIds = new ArrayList<>();
private int processedCount = 0;
@Override
public void onNext(CreateUserRequest request) {
logger.debug("Processing streaming user creation: {}", request.getEmail());
try {
// Create user
String userId = "user_" + userIdCounter.getAndIncrement();
UserResponse user = UserResponse.newBuilder()
.setUserId(userId)
.setName(request.getName())
.setEmail(request.getEmail())
.setAge(request.getAge())
.setCreatedAt(String.valueOf(System.currentTimeMillis()))
.setUpdatedAt(String.valueOf(System.currentTimeMillis()))
.build();
userStore.put(userId, user);
createdUserIds.add(userId);
processedCount++;
logger.debug("Streaming user created: {}", userId);
} catch (Exception e) {
logger.error("Error in streaming user creation", e);
// Continue processing other requests
}
}
@Override
public void onError(Throwable t) {
logger.error("Error in CreateUsers stream", t);
}
@Override
public void onCompleted() {
logger.info("CreateUsers streaming completed, processed {} users", processedCount);
CreateUsersResponse response = CreateUsersResponse.newBuilder()
.setCreatedCount(createdUserIds.size())
.addAllUserIds(createdUserIds)
.build();
responseObserver.onNext(response);
responseObserver.onCompleted();
}
};
}
@Override
public StreamObserver<ChatMessage> chat(StreamObserver<ChatMessage> responseObserver) {
logger.info("Chat bidirectional streaming started");
return new StreamObserver<ChatMessage>() {
@Override
public void onNext(ChatMessage message) {
logger.debug("Received chat message from {}: {}", 
message.getUserId(), message.getMessage());
// Echo the message back with timestamp
ChatMessage response = ChatMessage.newBuilder(message)
.setTimestamp(System.currentTimeMillis())
.build();
responseObserver.onNext(response);
}
@Override
public void onError(Throwable t) {
logger.error("Error in chat stream", t);
}
@Override
public void onCompleted() {
logger.info("Chat streaming completed");
responseObserver.onCompleted();
}
};
}
}
2. gRPC Client Service
package com.example.grpc.client;
import com.example.grpc.*;
import io.grpc.Channel;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import io.grpc.stub.StreamObserver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
@Service
public class UserServiceClient {
private static final Logger logger = LoggerFactory.getLogger(UserServiceClient.class);
private final UserServiceGrpc.UserServiceBlockingStub blockingStub;
private final UserServiceGrpc.UserServiceStub asyncStub;
public UserServiceClient(Channel channel) {
this.blockingStub = UserServiceGrpc.newBlockingStub(channel);
this.asyncStub = UserServiceGrpc.newStub(channel);
}
// Unary RPC methods
public UserResponse getUser(String userId) {
logger.info("Getting user: {}", userId);
try {
GetUserRequest request = GetUserRequest.newBuilder()
.setUserId(userId)
.build();
return blockingStub.getUser(request);
} catch (StatusRuntimeException e) {
logger.error("RPC failed: {}", e.getStatus());
throw new GrpcClientException("Failed to get user", e);
}
}
public UserResponse createUser(String name, String email, int age) {
logger.info("Creating user: {}", email);
try {
CreateUserRequest request = CreateUserRequest.newBuilder()
.setName(name)
.setEmail(email)
.setAge(age)
.build();
return blockingStub.createUser(request);
} catch (StatusRuntimeException e) {
logger.error("RPC failed: {}", e.getStatus());
throw new GrpcClientException("Failed to create user", e);
}
}
// Server streaming RPC
public List<UserResponse> listUsers(int pageSize) {
logger.info("Listing users with page size: {}", pageSize);
try {
ListUsersRequest request = ListUsersRequest.newBuilder()
.setPageSize(pageSize)
.build();
List<UserResponse> users = new ArrayList<>();
blockingStub.listUsers(request).forEachRemaining(users::add);
logger.info("Retrieved {} users", users.size());
return users;
} catch (StatusRuntimeException e) {
logger.error("RPC failed: {}", e.getStatus());
throw new GrpcClientException("Failed to list users", e);
}
}
// Client streaming RPC
public CreateUsersResponse createUsers(List<CreateUserRequest> userRequests) {
logger.info("Creating {} users via streaming", userRequests.size());
CountDownLatch finishLatch = new CountDownLatch(1);
AtomicReference<CreateUsersResponse> responseRef = new AtomicReference<>();
AtomicReference<Throwable> errorRef = new AtomicReference<>();
StreamObserver<CreateUserRequest> requestObserver = 
asyncStub.createUsers(new StreamObserver<CreateUsersResponse>() {
@Override
public void onNext(CreateUsersResponse response) {
responseRef.set(response);
}
@Override
public void onError(Throwable t) {
errorRef.set(t);
finishLatch.countDown();
}
@Override
public void onCompleted() {
finishLatch.countDown();
}
});
try {
// Send all requests
for (CreateUserRequest request : userRequests) {
requestObserver.onNext(request);
}
requestObserver.onCompleted();
// Wait for completion
if (!finishLatch.await(1, TimeUnit.MINUTES)) {
throw new GrpcClientException("CreateUsers timed out");
}
// Check for errors
if (errorRef.get() != null) {
throw new GrpcClientException("CreateUsers failed", errorRef.get());
}
return responseRef.get();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new GrpcClientException("CreateUsers interrupted", e);
}
}
// Bidirectional streaming RPC
public List<ChatMessage> chat(List<ChatMessage> messages) {
logger.info("Starting chat with {} messages", messages.size());
CountDownLatch finishLatch = new CountDownLatch(1);
List<ChatMessage> responses = new ArrayList<>();
AtomicReference<Throwable> errorRef = new AtomicReference<>();
StreamObserver<ChatMessage> requestObserver = 
asyncStub.chat(new StreamObserver<ChatMessage>() {
@Override
public void onNext(ChatMessage message) {
responses.add(message);
}
@Override
public void onError(Throwable t) {
errorRef.set(t);
finishLatch.countDown();
}
@Override
public void onCompleted() {
finishLatch.countDown();
}
});
try {
// Send all messages
for (ChatMessage message : messages) {
requestObserver.onNext(message);
}
requestObserver.onCompleted();
// Wait for completion
if (!finishLatch.await(30, TimeUnit.SECONDS)) {
throw new GrpcClientException("Chat timed out");
}
// Check for errors
if (errorRef.get() != null) {
throw new GrpcClientException("Chat failed", errorRef.get());
}
return responses;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new GrpcClientException("Chat interrupted", e);
}
}
}
class GrpcClientException extends RuntimeException {
public GrpcClientException(String message) {
super(message);
}
public GrpcClientException(String message, Throwable cause) {
super(message, cause);
}
}

gRPC Testing Framework

1. Base gRPC Test Configuration
package com.example.grpc.test;
import io.grpc.*;
import io.grpc.inprocess.InProcessChannelBuilder;
import io.grpc.inprocess.InProcessServerBuilder;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
/**
* Base class for gRPC in-process testing
*/
public abstract class GrpcTestBase {
private static final Logger logger = LoggerFactory.getLogger(GrpcTestBase.class);
protected Server server;
protected ManagedChannel channel;
protected String serverName;
@BeforeEach
void setUp() throws IOException {
serverName = InProcessServerBuilder.generateName();
// Create server
server = InProcessServerBuilder.forName(serverName)
.directExecutor()
.addService(createService())
.build()
.start();
// Create channel
channel = InProcessChannelBuilder.forName(serverName)
.directExecutor()
.build();
logger.info("gRPC in-process server started: {}", serverName);
}
@AfterEach
void tearDown() throws InterruptedException {
if (channel != null) {
channel.shutdown();
if (!channel.awaitTermination(5, TimeUnit.SECONDS)) {
channel.shutdownNow();
}
}
if (server != null) {
server.shutdown();
if (!server.awaitTermination(5, TimeUnit.SECONDS)) {
server.shutdownNow();
}
}
logger.info("gRPC in-process server stopped: {}", serverName);
}
/**
* Implement this method to provide the gRPC service for testing
*/
protected abstract BindableService createService();
}
2. Unit Tests for gRPC Service
package com.example.grpc.service;
import com.example.grpc.*;
import com.example.grpc.test.GrpcTestBase;
import io.grpc.BindableService;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import static org.assertj.core.api.Assertions.*;
import static org.junit.jupiter.api.Assertions.*;
class UserServiceTest extends GrpcTestBase {
private UserServiceGrpc.UserServiceBlockingStub blockingStub;
private UserServiceImpl userService;
@Override
protected BindableService createService() {
userService = new UserServiceImpl();
return userService;
}
@BeforeEach
void setUpStub() {
blockingStub = UserServiceGrpc.newBlockingStub(channel);
}
@Test
void testGetUser_Success() {
// Given - create a user first
CreateUserRequest createRequest = CreateUserRequest.newBuilder()
.setName("John Doe")
.setEmail("[email protected]")
.setAge(30)
.build();
UserResponse createdUser = blockingStub.createUser(createRequest);
// When
GetUserRequest request = GetUserRequest.newBuilder()
.setUserId(createdUser.getUserId())
.build();
UserResponse response = blockingStub.getUser(request);
// Then
assertThat(response).isNotNull();
assertThat(response.getUserId()).isEqualTo(createdUser.getUserId());
assertThat(response.getName()).isEqualTo("John Doe");
assertThat(response.getEmail()).isEqualTo("[email protected]");
assertThat(response.getAge()).isEqualTo(30);
}
@Test
void testGetUser_NotFound() {
// Given
GetUserRequest request = GetUserRequest.newBuilder()
.setUserId("non-existent-id")
.build();
// When / Then
StatusRuntimeException exception = catchThrowableOfType(
() -> blockingStub.getUser(request),
StatusRuntimeException.class
);
assertThat(exception.getStatus().getCode()).isEqualTo(Status.NOT_FOUND.getCode());
assertThat(exception.getStatus().getDescription()).contains("User not found");
}
@Test
void testCreateUser_Success() {
// Given
CreateUserRequest request = CreateUserRequest.newBuilder()
.setName("Jane Smith")
.setEmail("[email protected]")
.setAge(25)
.build();
// When
UserResponse response = blockingStub.createUser(request);
// Then
assertThat(response).isNotNull();
assertThat(response.getUserId()).isNotBlank();
assertThat(response.getName()).isEqualTo("Jane Smith");
assertThat(response.getEmail()).isEqualTo("[email protected]");
assertThat(response.getAge()).isEqualTo(25);
assertThat(response.getCreatedAt()).isNotBlank();
assertThat(response.getUpdatedAt()).isNotBlank();
}
@Test
void testCreateUser_ValidationFailure() {
// Given - missing required fields
CreateUserRequest request = CreateUserRequest.newBuilder()
.setAge(25)
.build();
// When / Then
StatusRuntimeException exception = catchThrowableOfType(
() -> blockingStub.createUser(request),
StatusRuntimeException.class
);
assertThat(exception.getStatus().getCode()).isEqualTo(Status.INVALID_ARGUMENT.getCode());
assertThat(exception.getStatus().getDescription()).contains("Name and email are required");
}
@Test
void testCreateUser_DuplicateEmail() {
// Given - create first user
CreateUserRequest firstRequest = CreateUserRequest.newBuilder()
.setName("First User")
.setEmail("[email protected]")
.setAge(30)
.build();
blockingStub.createUser(firstRequest);
// When / Then - try to create second user with same email
CreateUserRequest secondRequest = CreateUserRequest.newBuilder()
.setName("Second User")
.setEmail("[email protected]")
.setAge(35)
.build();
StatusRuntimeException exception = catchThrowableOfType(
() -> blockingStub.createUser(secondRequest),
StatusRuntimeException.class
);
assertThat(exception.getStatus().getCode()).isEqualTo(Status.ALREADY_EXISTS.getCode());
assertThat(exception.getStatus().getDescription()).contains("already exists");
}
@Test
void testUpdateUser_Success() {
// Given - create a user first
CreateUserRequest createRequest = CreateUserRequest.newBuilder()
.setName("Original Name")
.setEmail("[email protected]")
.setAge(30)
.build();
UserResponse createdUser = blockingStub.createUser(createRequest);
// When - update the user
UpdateUserRequest updateRequest = UpdateUserRequest.newBuilder()
.setUserId(createdUser.getUserId())
.setName("Updated Name")
.setEmail("[email protected]")
.setAge(35)
.build();
UserResponse updatedUser = blockingStub.updateUser(updateRequest);
// Then
assertThat(updatedUser).isNotNull();
assertThat(updatedUser.getUserId()).isEqualTo(createdUser.getUserId());
assertThat(updatedUser.getName()).isEqualTo("Updated Name");
assertThat(updatedUser.getEmail()).isEqualTo("[email protected]");
assertThat(updatedUser.getAge()).isEqualTo(35);
assertThat(updatedUser.getUpdatedAt()).isNotEqualTo(createdUser.getUpdatedAt());
}
@Test
void testDeleteUser_Success() {
// Given - create a user first
CreateUserRequest createRequest = CreateUserRequest.newBuilder()
.setName("To Delete")
.setEmail("[email protected]")
.setAge(30)
.build();
UserResponse createdUser = blockingStub.createUser(createRequest);
// When
DeleteUserRequest deleteRequest = DeleteUserRequest.newBuilder()
.setUserId(createdUser.getUserId())
.build();
DeleteUserResponse response = blockingStub.deleteUser(deleteRequest);
// Then
assertThat(response.getSuccess()).isTrue();
assertThat(response.getMessage()).contains("deleted successfully");
// Verify user is actually deleted
GetUserRequest getRequest = GetUserRequest.newBuilder()
.setUserId(createdUser.getUserId())
.build();
StatusRuntimeException exception = catchThrowableOfType(
() -> blockingStub.getUser(getRequest),
StatusRuntimeException.class
);
assertThat(exception.getStatus().getCode()).isEqualTo(Status.NOT_FOUND.getCode());
}
@Test
void testDeleteUser_NotFound() {
// Given
DeleteUserRequest request = DeleteUserRequest.newBuilder()
.setUserId("non-existent-id")
.build();
// When
DeleteUserResponse response = blockingStub.deleteUser(request);
// Then
assertThat(response.getSuccess()).isFalse();
assertThat(response.getMessage()).contains("not found");
}
@Test
void testListUsers_ServerStreaming() {
// Given - create multiple users
for (int i = 1; i <= 5; i++) {
CreateUserRequest request = CreateUserRequest.newBuilder()
.setName("User " + i)
.setEmail("user" + i + "@example.com")
.setAge(20 + i)
.build();
blockingStub.createUser(request);
}
// When
ListUsersRequest request = ListUsersRequest.newBuilder()
.setPageSize(3)
.build();
List<UserResponse> users = new ArrayList<>();
blockingStub.listUsers(request).forEachRemaining(users::add);
// Then
assertThat(users).hasSize(3);
assertThat(users).allSatisfy(user -> {
assertThat(user.getUserId()).isNotBlank();
assertThat(user.getName()).isNotBlank();
assertThat(user.getEmail()).isNotBlank();
});
}
}
3. Streaming Tests
package com.example.grpc.service;
import com.example.grpc.*;
import com.example.grpc.test.GrpcTestBase;
import io.grpc.BindableService;
import io.grpc.stub.StreamObserver;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import static org.assertj.core.api.Assertions.*;
import static org.junit.jupiter.api.Assertions.*;
class UserServiceStreamingTest extends GrpcTestBase {
private UserServiceGrpc.UserServiceStub asyncStub;
@Override
protected BindableService createService() {
return new UserServiceImpl();
}
@BeforeEach
void setUpStub() {
asyncStub = UserServiceGrpc.newStub(channel);
}
@Test
void testCreateUsers_ClientStreaming() throws InterruptedException {
// Given
List<CreateUserRequest> requests = List.of(
CreateUserRequest.newBuilder()
.setName("User 1")
.setEmail("[email protected]")
.setAge(25)
.build(),
CreateUserRequest.newBuilder()
.setName("User 2")
.setEmail("[email protected]")
.setAge(30)
.build(),
CreateUserRequest.newBuilder()
.setName("User 3")
.setEmail("[email protected]")
.setAge(35)
.build()
);
CountDownLatch finishLatch = new CountDownLatch(1);
AtomicReference<CreateUsersResponse> responseRef = new AtomicReference<>();
AtomicReference<Throwable> errorRef = new AtomicReference<>();
// When
StreamObserver<CreateUserRequest> requestObserver = 
asyncStub.createUsers(new StreamObserver<CreateUsersResponse>() {
@Override
public void onNext(CreateUsersResponse response) {
responseRef.set(response);
}
@Override
public void onError(Throwable t) {
errorRef.set(t);
finishLatch.countDown();
}
@Override
public void onCompleted() {
finishLatch.countDown();
}
});
// Send all requests
for (CreateUserRequest request : requests) {
requestObserver.onNext(request);
}
requestObserver.onCompleted();
// Wait for completion
assertTrue(finishLatch.await(5, TimeUnit.SECONDS), "Operation timed out");
// Then
assertThat(errorRef.get()).isNull();
assertThat(responseRef.get()).isNotNull();
assertThat(responseRef.get().getCreatedCount()).isEqualTo(3);
assertThat(responseRef.get().getUserIdsList()).hasSize(3);
}
@Test
void testChat_BidirectionalStreaming() throws InterruptedException {
// Given
List<ChatMessage> messagesToSend = List.of(
ChatMessage.newBuilder()
.setUserId("user1")
.setMessage("Hello")
.setTimestamp(System.currentTimeMillis())
.build(),
ChatMessage.newBuilder()
.setUserId("user1")
.setMessage("How are you?")
.setTimestamp(System.currentTimeMillis())
.build(),
ChatMessage.newBuilder()
.setUserId("user1")
.setMessage("Goodbye")
.setTimestamp(System.currentTimeMillis())
.build()
);
CountDownLatch finishLatch = new CountDownLatch(1);
List<ChatMessage> receivedMessages = new ArrayList<>();
AtomicReference<Throwable> errorRef = new AtomicReference<>();
// When
StreamObserver<ChatMessage> requestObserver = 
asyncStub.chat(new StreamObserver<ChatMessage>() {
@Override
public void onNext(ChatMessage message) {
receivedMessages.add(message);
}
@Override
public void onError(Throwable t) {
errorRef.set(t);
finishLatch.countDown();
}
@Override
public void onCompleted() {
finishLatch.countDown();
}
});
// Send all messages
for (ChatMessage message : messagesToSend) {
requestObserver.onNext(message);
}
requestObserver.onCompleted();
// Wait for completion
assertTrue(finishLatch.await(5, TimeUnit.SECONDS), "Operation timed out");
// Then
assertThat(errorRef.get()).isNull();
assertThat(receivedMessages).hasSize(3);
// Verify responses match sent messages
for (int i = 0; i < messagesToSend.size(); i++) {
ChatMessage sent = messagesToSend.get(i);
ChatMessage received = receivedMessages.get(i);
assertThat(received.getUserId()).isEqualTo(sent.getUserId());
assertThat(received.getMessage()).isEqualTo(sent.getMessage());
assertThat(received.getTimestamp()).isGreaterThan(0);
}
}
}
4. gRPC Client Tests
package com.example.grpc.client;
import com.example.grpc.*;
import com.example.grpc.test.GrpcTestBase;
import io.grpc.BindableService;
import io.grpc.StatusRuntimeException;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import java.util.List;
import static org.assertj.core.api.Assertions.*;
import static org.junit.jupiter.api.Assertions.*;
class UserServiceClientTest extends GrpcTestBase {
private UserServiceClient client;
private UserServiceGrpc.UserServiceBlockingStub blockingStub;
@Override
protected BindableService createService() {
return new UserServiceImpl();
}
@BeforeEach
void setUpClient() {
client = new UserServiceClient(channel);
blockingStub = UserServiceGrpc.newBlockingStub(channel);
}
@Test
void testGetUser_Success() {
// Given - create a user via blocking stub
CreateUserRequest createRequest = CreateUserRequest.newBuilder()
.setName("Test User")
.setEmail("[email protected]")
.setAge(30)
.build();
UserResponse createdUser = blockingStub.createUser(createRequest);
// When
UserResponse response = client.getUser(createdUser.getUserId());
// Then
assertThat(response).isNotNull();
assertThat(response.getUserId()).isEqualTo(createdUser.getUserId());
assertThat(response.getName()).isEqualTo("Test User");
assertThat(response.getEmail()).isEqualTo("[email protected]");
}
@Test
void testGetUser_NotFound() {
// When / Then
GrpcClientException exception = catchThrowableOfType(
() -> client.getUser("non-existent-id"),
GrpcClientException.class
);
assertThat(exception).hasMessageContaining("Failed to get user");
assertThat(exception.getCause()).isInstanceOf(StatusRuntimeException.class);
}
@Test
void testCreateUser_Success() {
// When
UserResponse response = client.createUser("New User", "[email protected]", 25);
// Then
assertThat(response).isNotNull();
assertThat(response.getName()).isEqualTo("New User");
assertThat(response.getEmail()).isEqualTo("[email protected]");
assertThat(response.getAge()).isEqualTo(25);
}
@Test
void testListUsers_Success() {
// Given - create multiple users
for (int i = 1; i <= 5; i++) {
blockingStub.createUser(CreateUserRequest.newBuilder()
.setName("User " + i)
.setEmail("user" + i + "@example.com")
.setAge(20 + i)
.build());
}
// When
List<UserResponse> users = client.listUsers(3);
// Then
assertThat(users).hasSize(3);
assertThat(users).allSatisfy(user -> {
assertThat(user.getUserId()).isNotBlank();
assertThat(user.getName()).isNotBlank();
assertThat(user.getEmail()).isNotBlank();
});
}
@Test
void testCreateUsers_ClientStreaming() {
// Given
List<CreateUserRequest> requests = List.of(
CreateUserRequest.newBuilder()
.setName("Stream User 1")
.setEmail("[email protected]")
.setAge(25)
.build(),
CreateUserRequest.newBuilder()
.setName("Stream User 2")
.setEmail("[email protected]")
.setAge(30)
.build()
);
// When
CreateUsersResponse response = client.createUsers(requests);
// Then
assertThat(response).isNotNull();
assertThat(response.getCreatedCount()).isEqualTo(2);
assertThat(response.getUserIdsList()).hasSize(2);
}
@Test
void testChat_BidirectionalStreaming() {
// Given
List<ChatMessage> messages = List.of(
ChatMessage.newBuilder()
.setUserId("test-user")
.setMessage("Hello")
.setTimestamp(System.currentTimeMillis())
.build(),
ChatMessage.newBuilder()
.setUserId("test-user")
.setMessage("Test message")
.setTimestamp(System.currentTimeMillis())
.build()
);
// When
List<ChatMessage> responses = client.chat(messages);
// Then
assertThat(responses).hasSize(2);
assertThat(responses.get(0).getMessage()).isEqualTo("Hello");
assertThat(responses.get(1).getMessage()).isEqualTo("Test message");
}
}
5. Mock Server Tests
package com.example.grpc.service;
import com.example.grpc.*;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;
import io.grpc.inprocess.InProcessChannelBuilder;
import io.grpc.testing.GrpcCleanupRule;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.AdditionalAnswers.delegatesTo;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class UserServiceMockTest {
private final UserServiceGrpc.UserServiceImplBase serviceImpl =
mock(UserServiceGrpc.UserServiceImplBase.class, delegatesTo(
new UserServiceGrpc.UserServiceImplBase() {
// Default implementations that can be overridden by Mockito
}
));
@Test
void testGetUserWithMock() throws IOException {
// Given
UserServiceGrpc.UserServiceImplBase service = 
mock(UserServiceGrpc.UserServiceImplBase.class);
UserResponse mockResponse = UserResponse.newBuilder()
.setUserId("mock-user")
.setName("Mock User")
.setEmail("[email protected]")
.setAge(30)
.setCreatedAt("123456789")
.setUpdatedAt("123456789")
.build();
// Set up mock behavior
doAnswer(invocation -> {
StreamObserver<UserResponse> responseObserver = invocation.getArgument(1);
responseObserver.onNext(mockResponse);
responseObserver.onCompleted();
return null;
}).when(service).getUser(any(GetUserRequest.class), any(StreamObserver.class));
// Create in-process server with mock service
String serverName = InProcessChannelBuilder.generateName();
GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
grpcCleanup.register(InProcessServerBuilder
.forName(serverName)
.directExecutor()
.addService(service)
.build()
.start());
UserServiceGrpc.UserServiceBlockingStub stub = UserServiceGrpc.newBlockingStub(
grpcCleanup.register(InProcessChannelBuilder
.forName(serverName)
.directExecutor()
.build()));
// When
GetUserRequest request = GetUserRequest.newBuilder()
.setUserId("test-user")
.build();
UserResponse response = stub.getUser(request);
// Then
assertThat(response).isEqualTo(mockResponse);
verify(service).getUser(any(GetUserRequest.class), any(StreamObserver.class));
}
@Test
void testGetUserErrorWithMock() throws IOException {
// Given
UserServiceGrpc.UserServiceImplBase service = 
mock(UserServiceGrpc.UserServiceImplBase.class);
// Set up mock to throw error
doAnswer(invocation -> {
StreamObserver<UserResponse> responseObserver = invocation.getArgument(1);
responseObserver.onError(Status.NOT_FOUND
.withDescription("User not found")
.asRuntimeException());
return null;
}).when(service).getUser(any(GetUserRequest.class), any(StreamObserver.class));
// Create in-process server with mock service
String serverName = InProcessChannelBuilder.generateName();
GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
grpcCleanup.register(InProcessServerBuilder
.forName(serverName)
.directExecutor()
.addService(service)
.build()
.start());
UserServiceGrpc.UserServiceBlockingStub stub = UserServiceGrpc.newBlockingStub(
grpcCleanup.register(InProcessChannelBuilder
.forName(serverName)
.directExecutor()
.build()));
// When / Then
GetUserRequest request = GetUserRequest.newBuilder()
.setUserId("non-existent")
.build();
assertThatThrownBy(() -> stub.getUser(request))
.isInstanceOf(io.grpc.StatusRuntimeException.class)
.hasMessageContaining("NOT_FOUND: User not found");
verify(service).getUser(any(GetUserRequest.class), any(StreamObserver.class));
}
@Test
void testListUsersStreamingWithMock() throws IOException {
// Given
UserServiceGrpc.UserServiceImplBase service = 
mock(UserServiceGrpc.UserServiceImplBase.class);
List<UserResponse> mockResponses = List.of(
UserResponse.newBuilder()
.setUserId("user1")
.setName("User One")
.setEmail("[email protected]")
.setAge(25)
.build(),
UserResponse.newBuilder()
.setUserId("user2")
.setName("User Two")
.setEmail("[email protected]")
.setAge(30)
.build()
);
// Set up mock behavior for streaming
doAnswer(invocation -> {
StreamObserver<UserResponse> responseObserver = invocation.getArgument(1);
for (UserResponse response : mockResponses) {
responseObserver.onNext(response);
}
responseObserver.onCompleted();
return null;
}).when(service).listUsers(any(ListUsersRequest.class), any(StreamObserver.class));
// Create in-process server with mock service
String serverName = InProcessChannelBuilder.generateName();
GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
grpcCleanup.register(InProcessServerBuilder
.forName(serverName)
.directExecutor()
.addService(service)
.build()
.start());
UserServiceGrpc.UserServiceBlockingStub stub = UserServiceGrpc.newBlockingStub(
grpcCleanup.register(InProcessChannelBuilder
.forName(serverName)
.directExecutor()
.build()));
// When
ListUsersRequest request = ListUsersRequest.newBuilder()
.setPageSize(10)
.build();
List<UserResponse> responses = new ArrayList<>();
stub.listUsers(request).forEachRemaining(responses::add);
// Then
assertThat(responses).hasSize(2);
assertThat(responses).containsExactlyElementsOf(mockResponses);
verify(service).listUsers(any(ListUsersRequest.class), any(StreamObserver.class));
}
}
6. Integration Tests with TestContainers
package com.example.grpc.integration;
import com.example.grpc.UserServiceGrpc;
import com.example.grpc.UserResponse;
import com.example.grpc.CreateUserRequest;
import com.example.grpc.GetUserRequest;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import org.junit.jupiter.api.Test;
import org.testcontainers.containers.GenericContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import org.testcontainers.utility.DockerImageName;
import static org.assertj.core.api.Assertions.assertThat;
@Testcontainers
class UserServiceIntegrationTest {
private static final int GRPC_PORT = 6565;
@Container
private static final GenericContainer<?> grpcServer = new GenericContainer<>(
DockerImageName.parse("my-grpc-server:latest"))
.withExposedPorts(GRPC_PORT)
.withEnv("SERVER_PORT", String.valueOf(GRPC_PORT));
@Test
void testGrpcServerIntegration() {
// Get mapped port
Integer mappedPort = grpcServer.getMappedPort(GRPC_PORT);
String host = grpcServer.getHost();
// Create channel to test container
ManagedChannel channel = ManagedChannelBuilder
.forAddress(host, mappedPort)
.usePlaintext()
.build();
try {
UserServiceGrpc.UserServiceBlockingStub stub = 
UserServiceGrpc.newBlockingStub(channel);
// Test create user
CreateUserRequest createRequest = CreateUserRequest.newBuilder()
.setName("Integration User")
.setEmail("[email protected]")
.setAge(35)
.build();
UserResponse createResponse = stub.createUser(createRequest);
assertThat(createResponse).isNotNull();
assertThat(createResponse.getName()).isEqualTo("Integration User");
assertThat(createResponse.getEmail()).isEqualTo("[email protected]");
// Test get user
GetUserRequest getRequest = GetUserRequest.newBuilder()
.setUserId(createResponse.getUserId())
.build();
UserResponse getResponse = stub.getUser(getRequest);
assertThat(getResponse).isNotNull();
assertThat(getResponse.getUserId()).isEqualTo(createResponse.getUserId());
} finally {
channel.shutdown();
}
}
}
7. Performance and Load Testing
package com.example.grpc.performance;
import com.example.grpc.*;
import com.example.grpc.test.GrpcTestBase;
import io.grpc.BindableService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import static org.assertj.core.api.Assertions.assertThat;
class UserServicePerformanceTest extends GrpcTestBase {
private UserServiceGrpc.UserServiceBlockingStub blockingStub;
private UserServiceGrpc.UserServiceStub asyncStub;
private ExecutorService executorService;
@Override
protected BindableService createService() {
return new UserServiceImpl();
}
@BeforeEach
void setUpStubs() {
blockingStub = UserServiceGrpc.newBlockingStub(channel);
asyncStub = UserServiceGrpc.newStub(channel);
executorService = Executors.newFixedThreadPool(10);
}
@Test
void testConcurrentUserCreations() throws InterruptedException {
int numberOfRequests = 100;
CountDownLatch latch = new CountDownLatch(numberOfRequests);
AtomicInteger successCount = new AtomicInteger(0);
AtomicInteger errorCount = new AtomicInteger(0);
// When - execute concurrent requests
for (int i = 0; i < numberOfRequests; i++) {
final int index = i;
executorService.submit(() -> {
try {
CreateUserRequest request = CreateUserRequest.newBuilder()
.setName("User " + index)
.setEmail("user" + index + "@example.com")
.setAge(20 + (index % 50))
.build();
blockingStub.createUser(request);
successCount.incrementAndGet();
} catch (Exception e) {
errorCount.incrementAndGet();
} finally {
latch.countDown();
}
});
}
// Then - wait for all requests to complete
assertThat(latch.await(30, TimeUnit.SECONDS)).isTrue();
System.out.printf("Performance test completed: %d success, %d errors%n", 
successCount.get(), errorCount.get());
assertThat(successCount.get()).isGreaterThan(0);
// Note: Some errors are expected due to duplicate email constraints
}
@Test
void testStreamingPerformance() throws InterruptedException {
int numberOfUsers = 50;
List<CreateUserRequest> requests = new ArrayList<>();
for (int i = 0; i < numberOfUsers; i++) {
requests.add(CreateUserRequest.newBuilder()
.setName("Stream User " + i)
.setEmail("stream" + i + "@example.com")
.setAge(25 + (i % 30))
.build());
}
long startTime = System.currentTimeMillis();
// When - use client streaming
CountDownLatch finishLatch = new CountDownLatch(1);
AtomicInteger responseCount = new AtomicInteger(0);
StreamObserver<CreateUserRequest> requestObserver = 
asyncStub.createUsers(new StreamObserver<CreateUsersResponse>() {
@Override
public void onNext(CreateUsersResponse response) {
responseCount.set(response.getCreatedCount());
}
@Override
public void onError(Throwable t) {
finishLatch.countDown();
}
@Override
public void onCompleted() {
finishLatch.countDown();
}
});
for (CreateUserRequest request : requests) {
requestObserver.onNext(request);
}
requestObserver.onCompleted();
// Wait for completion
assertThat(finishLatch.await(10, TimeUnit.SECONDS)).isTrue();
long endTime = System.currentTimeMillis();
long duration = endTime - startTime;
System.out.printf("Streaming performance: %d users in %d ms%n", 
responseCount.get(), duration);
assertThat(responseCount.get()).isGreaterThan(0);
assertThat(duration).isLessThan(5000); // Should complete within 5 seconds
}
}
8. Error Handling and Resilience Tests
package com.example.grpc.error;
import com.example.grpc.*;
import com.example.grpc.test.GrpcTestBase;
import io.grpc.BindableService;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import static org.assertj.core.api.Assertions.*;
class UserServiceErrorTest extends GrpcTestBase {
private UserServiceGrpc.UserServiceBlockingStub blockingStub;
// Service that throws various exceptions for testing
static class ErrorProneUserService extends UserServiceGrpc.UserServiceImplBase {
@Override
public void getUser(GetUserRequest request, StreamObserver<UserResponse> responseObserver) {
if ("timeout".equals(request.getUserId())) {
// Simulate timeout by not responding
return;
} else if ("internal-error".equals(request.getUserId())) {
responseObserver.onError(Status.INTERNAL
.withDescription("Internal server error")
.asRuntimeException());
} else if ("invalid-argument".equals(request.getUserId())) {
responseObserver.onError(Status.INVALID_ARGUMENT
.withDescription("Invalid user ID")
.asRuntimeException());
} else {
responseObserver.onError(Status.NOT_FOUND
.withDescription("User not found: " + request.getUserId())
.asRuntimeException());
}
}
}
@Override
protected BindableService createService() {
return new ErrorProneUserService();
}
@BeforeEach
void setUpStub() {
blockingStub = UserServiceGrpc.newBlockingStub(channel);
}
@Test
void testInternalError() {
GetUserRequest request = GetUserRequest.newBuilder()
.setUserId("internal-error")
.build();
StatusRuntimeException exception = catchThrowableOfType(
() -> blockingStub.getUser(request),
StatusRuntimeException.class
);
assertThat(exception.getStatus().getCode()).isEqualTo(Status.INTERNAL.getCode());
assertThat(exception.getStatus().getDescription()).contains("Internal server error");
}
@Test
void testInvalidArgumentError() {
GetUserRequest request = GetUserRequest.newBuilder()
.setUserId("invalid-argument")
.build();
StatusRuntimeException exception = catchThrowableOfType(
() -> blockingStub.getUser(request),
StatusRuntimeException.class
);
assertThat(exception.getStatus().getCode()).isEqualTo(Status.INVALID_ARGUMENT.getCode());
assertThat(exception.getStatus().getDescription()).contains("Invalid user ID");
}
@Test
void testNotFoundError() {
GetUserRequest request = GetUserRequest.newBuilder()
.setUserId("any-user")
.build();
StatusRuntimeException exception = catchThrowableOfType(
() -> blockingStub.getUser(request),
StatusRuntimeException.class
);
assertThat(exception.getStatus().getCode()).isEqualTo(Status.NOT_FOUND.getCode());
assertThat(exception.getStatus().getDescription()).contains("User not found");
}
}

Test Configuration

# src/test/resources/application-test.yml
grpc:
server:
port: 0  # Use random port for tests
in-process-name: test-server
logging:
level:
com.example.grpc: DEBUG
io.grpc: WARN

Best Practices

  1. Test All RPC Types: Cover unary, client streaming, server streaming, and bidirectional streaming
  2. Error Scenarios: Test various error conditions and status codes
  3. Concurrent Testing: Test under concurrent load
  4. Mock Appropriately: Use mocks for external dependencies
  5. Integration Testing: Test with real servers when possible
  6. Performance Testing: Include performance benchmarks
// Example of comprehensive test annotations
@GrpcTest
@ExtendWith({MockitoExtension.class, GrpcCleanupExtension.class})
@ActiveProfiles("test")
@Tag("grpc")
@Tag("integration")
class ComprehensiveGrpcTest {
// Tests covering all scenarios
}

Conclusion

gRPC testing in Java provides:

  • Comprehensive Coverage: Unit, integration, and performance testing
  • Multiple Testing Strategies: In-process, mock servers, TestContainers
  • Streaming Support: Full testing of streaming RPCs
  • Error Handling: Testing various gRPC status codes and error scenarios
  • Performance Validation: Load and concurrent testing capabilities

This comprehensive testing approach ensures your gRPC services are reliable, performant, and handle all edge cases correctly. The combination of in-process testing for fast unit tests and container-based testing for integration scenarios provides a robust testing strategy for gRPC-based microservices.

Pyroscope Profiling in Java
Explains how to use Pyroscope for continuous profiling in Java applications, helping developers analyze CPU and memory usage patterns to improve performance and identify bottlenecks.
https://macronepal.com/blog/pyroscope-profiling-in-java/

OpenTelemetry Metrics in Java: Comprehensive Guide
Provides a complete guide to collecting and exporting metrics in Java using OpenTelemetry, including counters, histograms, gauges, and integration with monitoring tools. (MACRO NEPAL)
https://macronepal.com/blog/opentelemetry-metrics-in-java-comprehensive-guide/

OTLP Exporter in Java: Complete Guide for OpenTelemetry
Explains how to configure OTLP exporters in Java to send telemetry data such as traces, metrics, and logs to monitoring systems using HTTP or gRPC protocols. (MACRO NEPAL)
https://macronepal.com/blog/otlp-exporter-in-java-complete-guide-for-opentelemetry/

Thanos Integration in Java: Global View of Metrics
Explains how to integrate Thanos with Java monitoring systems to create a scalable global metrics view across multiple Prometheus instances.

https://macronepal.com/blog/thanos-integration-in-java-global-view-of-metrics

Time Series with InfluxDB in Java: Complete Guide (Version 2)
Explains how to manage time-series data using InfluxDB in Java applications, including storing, querying, and analyzing metrics data.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide-2

Time Series with InfluxDB in Java: Complete Guide
Provides an overview of integrating InfluxDB with Java for time-series data handling, including monitoring applications and managing performance metrics.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide

Implementing Prometheus Remote Write in Java (Version 2)
Explains how to configure Java applications to send metrics data to Prometheus-compatible systems using the remote write feature for scalable monitoring.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide-2

Implementing Prometheus Remote Write in Java: Complete Guide
Provides instructions for sending metrics from Java services to Prometheus servers, enabling centralized monitoring and real-time analytics.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide

Building a TileServer GL in Java: Vector and Raster Tile Server
Explains how to build a TileServer GL in Java for serving vector and raster map tiles, useful for geographic visualization and mapping applications.

https://macronepal.com/blog/building-a-tileserver-gl-in-java-vector-and-raster-tile-server

Indoor Mapping in Java
Explains how to create indoor mapping systems in Java, including navigation inside buildings, spatial data handling, and visualization techniques.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper