《Java 服务端通信工程》15.2 联调、验收清单与故障注入

package com.plume.linkd.v3.contract;

import com.plume.linkd.v3.api.Book;
import com.plume.linkd.v3.api.GetBookRequest;
import com.plume.linkd.v3.api.LibraryGrpc;
import com.plume.linkd.v3.server.BookRepository;
import com.plume.linkd.v3.server.LibraryService;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

class LibraryContractTest {

    private Server server;
    private ManagedChannel channel;
    private LibraryGrpc.LibraryBlockingStub stub;

    @BeforeEach
    void setUp() throws IOException {
        server = ServerBuilder.forPort(0)
                .addService(new LibraryService(new FakeBookRepository()))
                .build()
                .start();
        channel = ManagedChannelBuilder.forAddress("127.0.0.1", server.getPort())
                .usePlaintext()
                .build();
        stub = LibraryGrpc.newBlockingStub(channel);
    }

    @AfterEach
    void tearDown() throws InterruptedException {
        channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
        server.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
    }

    @Test
    void getBookReturnsAllContractFields() {
        Book book = stub.getBook(
                GetBookRequest.newBuilder().setIsbn("978-7-111-00001-1").build());
        assertEquals("978-7-111-00001-1", book.getIsbn());
        assertEquals("通信工程", book.getTitle());
        assertEquals("Leeting", book.getAuthor());
        assertTrue(book.getStock() >= 0);
    }

    @Test
    void expiredDeadlineFailsFast() {
        StatusRuntimeException error = assertThrows(StatusRuntimeException.class, () ->
                stub.withDeadlineAfter(1, TimeUnit.NANOSECONDS)
                        .getBook(GetBookRequest.newBuilder().setIsbn("missing").build()));
        assertEquals(Status.Code.DEADLINE_EXCEEDED, error.getStatus().getCode());
    }

    @Test
    void unknownIsbnMapsToNotFound() {
        StatusRuntimeException error = assertThrows(StatusRuntimeException.class, () ->
                stub.getBook(GetBookRequest.newBuilder().setIsbn("unknown").build()));
        assertEquals(Status.Code.NOT_FOUND, error.getStatus().getCode());
    }
}

final class FakeBookRepository implements BookRepository {

    @Override
    public CompletableFuture<Book> find(String isbn, long budgetMs) {
        if ("unknown".equals(isbn)) {
            return CompletableFuture.failedFuture(
                    Status.NOT_FOUND.withDescription("unknown isbn").asRuntimeException());
        }
        return CompletableFuture.completedFuture(Book.newBuilder()
                .setIsbn(isbn)
                .setTitle("通信工程")
                .setAuthor("Leeting")
                .setStock(3)
                .build());
    }
}

package com.plume.linkd.v3.contract;

import com.plume.linkd.v3.api.GetBookRequest;
import com.plume.linkd.v3.api.LibraryGrpc;
import com.plume.linkd.v3.chaos.FaultInjectingServerInterceptor;
import com.plume.linkd.v3.server.LibraryService;
import io.grpc.CallOptions;
import io.grpc.Channel;
import io.grpc.ClientCall;
import io.grpc.ClientInterceptor;
import io.grpc.ForwardingClientCall;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.Metadata;
import io.grpc.MethodDescriptor;
import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import org.junit.jupiter.api.Test;

import java.util.concurrent.TimeUnit;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

class FaultAcceptanceTest {

    @Test
    void injectedUnavailableIsMappedTo503() throws Exception {
        Server server = ServerBuilder.forPort(0)
                .addService(new LibraryService(new FakeBookRepository()))
                .intercept(new FaultInjectingServerInterceptor(true, 1L))
                .build()
                .start();
        ManagedChannel channel = ManagedChannelBuilder
                .forAddress("127.0.0.1", server.getPort())
                .usePlaintext()
                .build();
        try {
            LibraryGrpc.LibraryBlockingStub stub = LibraryGrpc.newBlockingStub(channel)
                    .withInterceptors(new DrillHeaders("abort:UNAVAILABLE"));
            StatusRuntimeException error = assertThrows(StatusRuntimeException.class, () ->
                    stub.withDeadlineAfter(800, TimeUnit.MILLISECONDS)
                            .getBook(GetBookRequest.newBuilder().setIsbn("x").build()));
            assertEquals(Status.Code.UNAVAILABLE, error.getStatus().getCode());
        } finally {
            channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
            server.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
        }
    }

    private static final class DrillHeaders implements ClientInterceptor {
        private final String spec;

        private DrillHeaders(String spec) {
            this.spec = spec;
        }

        @Override
        public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
                MethodDescriptor<ReqT, RespT> method, CallOptions options, Channel next) {
            Metadata.Key<String> tenant =
                    Metadata.Key.of("x-tenant-id", Metadata.ASCII_STRING_MARSHALLER);
            Metadata.Key<String> fault =
                    Metadata.Key.of("x-fault", Metadata.ASCII_STRING_MARSHALLER);
            Metadata.Key<String> ratio =
                    Metadata.Key.of("x-fault-ratio", Metadata.ASCII_STRING_MARSHALLER);
            return new ForwardingClientCall.SimpleForwardingClientCall<>(
                    next.newCall(method, options)) {
                @Override
                public void start(Listener<RespT> listener, Metadata headers) {
                    headers.put(tenant, "tenant-drill");
                    headers.put(fault, spec);
                    headers.put(ratio, "100");
                    super.start(listener, headers);
                }
            };
        }
    }
}