Jupiter Parameterized Test

import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

import java.util.stream.Stream;

public class ServerStreamingInputValidationTest extends AbstractTest {

    @ParameterizedTest
    @MethodSource("testData")
    void testBlockingInputValidation(WithdrawRequest request, Status.Code code) {
        var ex = Assertions.assertThrows(StatusRuntimeException.class, () -> this.blockingStub.withdraw(request).hasNext());
        Assertions.assertEquals(code, ex.getStatus().getCode());
    }

    @ParameterizedTest
    @MethodSource("testData")
    void testAsyncInputValidation(WithdrawRequest request, Status.Code code) {
        var observer = new ResponseObserver<Money>();
        this.asyncStub.withdraw(request, observer);
        observer.await();

        Assertions.assertTrue(observer.getItems().isEmpty());
        Assertions.assertNotNull(observer.getThrowable());
        Assertions.assertEquals(code, ((StatusRuntimeException) observer.getThrowable()).getStatus().getCode());
    }

    private Stream<Arguments> testData() {
        return Stream.of(
                // input, expectation
                Arguments.of(WithdrawRequest.newBuilder().setAccountNumber(11).setAmount(10).build(), Status.Code.INVALID_ARGUMENT),
                Arguments.of(WithdrawRequest.newBuilder().setAccountNumber(1).setAmount(17).build(), Status.Code.INVALID_ARGUMENT),
                Arguments.of(WithdrawRequest.newBuilder().setAccountNumber(1).setAmount(120).build(), Status.Code.FAILED_PRECONDITION)
        );
    }
}

Kill process in Windows & Linux

Windows:

> netstat -ano | findstr :8080

> taskkill PID <pid> /F

Linux:

> sudo lsof -i 8080

> sudo kill -9 <pid>

Proto vs Json performance test

 

public class PerformanceTest {
    private static final Logger LOGGER = LoggerFactory.getLogger(PerformanceTest.class);
    private static final ObjectMapper MAPPER = new ObjectMapper();

    public static void main(String[] args) throws Exception {
        var protoPerson = Person.newBuilder()
                .setLastName("T")
                .setAge(32)
                .setEmail("t@email.com")
                .setEmployed(true)
                .setSalary(123004.5)
                .setBankAccountNumber(38495959093040944L)
                .setBalance(-100)
                .build();
        LOGGER.info("how many bytes protoPerson has? {}", protoPerson.toByteArray().length); // 41

        var jsonPerson = new JsonPerson("T", 32, "t@email.com", true, 123004.5, 38495959093040944L, -100);
        var bytes = MAPPER.writeValueAsBytes(jsonPerson);
        LOGGER.info("how many bytes jsonPerson has? {}", bytes.length); // 130 = 3x more!

        for (int i=0; i<5; i++) { // first run to be ignored (warmup JVM)
            runTest("json", () -> json(jsonPerson));
            runTest("proto", () -> proto(protoPerson));  // 7x faster!
        }
    }

    private static void runTest(String testName, Runnable runnable) {
        var start = System.currentTimeMillis();
        for (int i=0; i<5_000_000; i++) {
            runnable.run();
        }
        var end = System.currentTimeMillis();
        LOGGER.info("time taken for {} = {} ms", testName, (end - start));
    }

    private static void proto(Person person)  {
        try {
            var bytes = person.toByteArray();
            Person.parseFrom(bytes);
        } catch (InvalidProtocolBufferException e) {
            throw new RuntimeException(e);
        }
    }

    private static void json(JsonPerson person) {
        try {
            var bytes = MAPPER.writeValueAsBytes(person);
            MAPPER.readValue(bytes, JsonPerson.class);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}