gRPC Spring Boot Starter

You can test components by mocking the gRPC stub and injecting it via a setter. This approach is fast and works well with standard mocking frameworks, but it requires extra configuration to handle final classes/methods and does not work for beans using stubs in @PostConstruct or via indirect injection.

Implementation Steps:

1. Add mockito to your dependencies.
2. Create src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker with the content mock-maker-inline to allow mocking final classes/methods.
3. Mock the stub and use a setter to inject it into your component.

public class MyComponentTest {

    private MyComponent myComponent = new MyComponent();
    private ChatServiceBlockingStub chatService = Mockito.mock(ChatServiceBlockingStub.class);

    @BeforeEach
    void setup() {
        myComponent.setChatService(chatService);
    }

    @Test
    void testSayHello() {
        Mockito.when(chatService.sayHello(...)).thenAnswer(...);
        assertThat(myComponent.sayHello("ThisIsMyName")).contains("ThisIsMyName");
    }

}

The Interface Project requires protobuf and gRPC dependencies to generate Java classes from .proto files.

Important: For Java 9+ compatibility, use jakarta.annotation-api version 1.3.5 and do not update it to 2.0.0.

### Maven (Interface)
```xml
<properties>
    <protobuf.version>3.23.4</protobuf.version>
    <protobuf-plugin.version>0.6.1</protobuf-plugin.version>
    <grpc.version>1.58.0</grpc.version>
</properties>

<dependencies>
    <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>jakarta.annotation</groupId>
        <artifactId>jakarta.annotation-api</artifactId>
        <version>1.3.5</version>
        <optional>true</optional>
    </dependency>
</dependencies>

<build>
    <extensions>
        <extension>
            <groupId>kr.motd.maven</groupId>
            <artifactId>os-maven-plugin</artifactId>
            <version>1.7.0</version>
        </extension>
    </extensions>
    <plugins>
        <plugin>
            <groupId>org.xolstice.maven.plugins</groupId>
            <artifactId>protobuf-maven-plugin</artifactId>
            <version>${protobuf-plugin.version}</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>

Gradle (Interface)

buildscript {
    ext {
        protobufVersion = '3.23.4'
        protobufPluginVersion = '0.8.18'
        grpcVersion = '1.58.0'
    }
}

plugins {
    id 'java-library'
    id 'com.google.protobuf' version "${protobufPluginVersion}"
}

repositories {
    mavenCentral()
}

dependencies {
    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
    implementation "io.grpc:grpc-stub:${grpcVersion}"
    compileOnly 'jakarta.annotation:jakarta.annotation-api:1.3.5'
}

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:${protobufVersion}"
    }
    generatedFilesBaseDir = "$projectDir/src/generated"
    clean {
        delete generatedFilesBaseDir
    }
    plugins {
        grpc {
            artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}"
        }
    }
    generateProtoTasks {
        all()*.plugins {
            grpc {}
        }
    }
}

By default, if grpc-netty-shaded is on the classpath, this library favors it. To force the use of the non-shaded grpc-netty, you must explicitly include it and exclude grpc-netty-shaded from the grpc-spring-boot-starter (or the specific server/client starter) dependencies.

Maven Example:

<dependency>
    <groupId>io.grpc</groupId>
    <artifactId>grpc-netty</artifactId>
    <version>${grpcVersion}</version>
</dependency>

<dependency>
    <groupId>net.devh</groupId>
    <artifactId>grpc-spring-boot-starter</artifactId>
    <version>...</version>
    <exclusions>
        <exclusion>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-netty-shaded</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Gradle Example:

implementation "io.grpc:grpc-netty:${grpcVersion}"

implementation 'net.devh:grpc-spring-boot-starter:...' exclude group: 'io.grpc', module: 'grpc-netty-shaded'