grpc java_如何对grpc-java服务器实现函数进行单元测试？

使用上面Eric提到的InProcess传输，单元测试非常简单。下面是一个例子了一下代码更明确：

我们测试基于此protobuff定义一个服务：

syntax = "proto3";

option java_multiple_files = true;

option java_package = "servers.dummy";

option java_outer_classname = "DummyProto";

option objc_class_prefix = "DMYS";

package dummy;

import "general.proto";

// The dummy service definition.

service DummyService {

// # Misc

// Returns the server version

rpc getVersion (Empty) returns (ServerVersion) {}

// Returns the java version

rpc getJava (Empty) returns (JavaVersion) {}

}

// Transmission data types

(包括下面的文件上面:)

syntax = "proto3";

option java_multiple_files = true;

option java_package = "general";

option java_outer_classname = "General";

option objc_class_prefix = "G";

// Transmission data types

message Empty {} // Empty Request or Reply

message ServerVersion {

string version = 1;

}

message JavaVersion {

string version = 1;

}

的DummyService基于从Protoc编译器生成的Java是如下：

package servers.dummy;

import java.util.logging.Logger;

import general.Empty;

import general.JavaVersion;

import general.ServerVersion;

import io.grpc.stub.StreamObserver;

public class DummyService extends DummyServiceGrpc.DummyServiceImplBase {

private static final Logger logger = Logger.getLogger(DummyService.class.getName());

@Override

public void getVersion(Empty req, StreamObserver responseObserver) {

logger.info("Server Version-Request received...");

ServerVersion version = ServerVersion.newBuilder().setVersion("1.0.0").build();

responseObserver.onNext(version);

responseObserver.onCompleted();

}

@Override

public void getJava(Empty req, StreamObserver responseObserver) {

logger.info("Java Version Request received...");

JavaVersion version = JavaVersion.newBuilder().setVersion(Runtime.class.getPackage().getImplementationVersion() + " (" + Runtime.class.getPackage().getImplementationVendor() + ")").build();

responseObserver.onNext(version);

responseObserver.onCompleted();

}

}

现在我们建立一个运行我们的虚拟服务的InProcessServer(或任何你想要的其他服务进行测试)：

package servers;

import io.grpc.Server;

import io.grpc.inprocess.InProcessServerBuilder;

import java.io.IOException;

import java.util.logging.Logger;

import servers.util.PortServer;

/**

* InProcessServer that manages startup/shutdown of a service within the same process as the client is running. Used for unit testing purposes.

* @author be

*/

public class InProcessServer {

private static final Logger logger = Logger.getLogger(PortServer.class.getName());

private Server server;

private Class clazz;

public InProcessServer(Class clazz){

this.clazz = clazz;

}

public void start() throws IOException, InstantiationException, IllegalAccessException {

server = InProcessServerBuilder.forName("test").directExecutor().addService(clazz.newInstance()).build().start();

logger.info("InProcessServer started.");

Runtime.getRuntime().addShutdownHook(new Thread() {

@Override

public void run() {

// Use stderr here since the logger may have been reset by its JVM shutdown hook.

System.err.println("*** shutting down gRPC server since JVM is shutting down");

InProcessServer.this.stop();

System.err.println("*** server shut down");

}

});

}

void stop() {

if (server != null) {

server.shutdown();

}

}

/**

* Await termination on the main thread since the grpc library uses daemon threads.

*/

public void blockUntilShutdown() throws InterruptedException {

if (server != null) {

server.awaitTermination();

}

}

}

现在，我们可以使用下面的单元测试测试服务：

package servers;

import static org.junit.Assert.*;

import general.ServerVersion;

import io.grpc.ManagedChannel;

import io.grpc.StatusRuntimeException;

import io.grpc.inprocess.InProcessChannelBuilder;

import java.io.IOException;

import java.util.concurrent.TimeUnit;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import servers.dummy.DummyService;

import servers.dummy.DummyServiceGrpc;

import servers.dummy.DummyServiceGrpc.DummyServiceBlockingStub;

import servers.dummy.DummyServiceGrpc.DummyServiceStub;

public class InProcessServerTest {

private static final Logger logger = Logger.getLogger(InProcessServerTest.class.getName());

private InProcessServer inprocessServer;

private ManagedChannel channel;

private DummyServiceBlockingStub blockingStub;

private DummyServiceStub asyncStub;

public InProcessServerTest() {

super();

}

@Test

public void testInProcessServer() throws InterruptedException{

try {

String version = getServerVersion();

assertTrue(version == "1.0.0");

} finally {

shutdown();

}

}

/** Ask for the server version */

public String getServerVersion() {

logger.info("Will try to get server version...");

ServerVersion response;

try {

response = blockingStub.getVersion(null);

} catch (StatusRuntimeException e) {

logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());

fail();

return "";

}

return response.getVersion();

}

@Before

public void beforeEachTest() throws InstantiationException, IllegalAccessException, IOException{

inprocessServer = new InProcessServer(DummyService.class);

inprocessServer.start();

channel = InProcessChannelBuilder.forName("test").directExecutor()

// Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid

// needing certificates.

.usePlaintext(true).build();

blockingStub = DummyServiceGrpc.newBlockingStub(channel);

asyncStub = DummyServiceGrpc.newStub(channel);

}

@After

public void afterEachTest(){

channel.shutdownNow();

inprocessServer.stop();

}

public void shutdown() throws InterruptedException {

channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);

}

}

测试只做测试两种方法之一，因为它仅用于说明目的。另一种方法可以进行相应的测试。