Question

我有一堂课

public class RequestHandler implements HttpHandler {
  public void handleRequest(HttpServerExchange serverContext) throws Exception {
    serverContext.dispatch(() -> serverContext.getRequestReceiver()
        .receiveFullBytes((httpServerExchange, reqBytes) -> {

          // business logic along with few function call

        }
      )
    );

  }
}

我想编写一个单元测试用例来测试我的业务逻辑。我不确定如何在调度程序内部使用2个级别的lambda表达式来执行此操作？有人可以建议写测试用例的好方法吗？

我知道我们可以将业务逻辑转移到新的类中并可以对其进行测试（我认为它的设计更好），但是很好奇，如果它是某些旧代码的一部分或者我们无法更改的内容，该如何测试？它吗？

Answer 1

假设在业务逻辑中某处您将接收到的消息（或与之相关的任何内容）转发到其他地方，则只需照常测试代码即可。

请注意，HttpServerExchange是最后一堂课，因此您需要使用支持final模拟的Mockito版本-您必须按照here的说明启用它。

要绕过lambda表达式，您需要使用thenAnswer或doAnswer来手动触发正确的接口方法的调用。

一个简单的例子可能像这样：

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.stubbing.Answer;

import io.undertow.io.Receiver;
import io.undertow.io.Receiver.FullBytesCallback;
import io.undertow.server.HttpHandler;
import io.undertow.server.HttpServerExchange;

@ExtendWith(MockitoExtension.class)
public class RequestHandlerTest {

    static class BuisnessLogic {
        public void someMethod(HttpServerExchange httpServerExchange, byte[] reqBytes) {
        }
    }

    static class RequestHandler implements HttpHandler {

        BuisnessLogic logic;

        public void handleRequest(HttpServerExchange serverContext) throws Exception {
            serverContext.dispatch(
                () -> serverContext.getRequestReceiver().receiveFullBytes(
                    (httpServerExchange, reqBytes) -> {
                        logic.someMethod(httpServerExchange, reqBytes);
                    }
                )
            );
        }
    }

    @Mock
    BuisnessLogic logic;

    @InjectMocks
    RequestHandler handler;

    @Test
    public void test() throws Exception {

        byte[] message = new byte[] {1,2,3};
        HttpServerExchange serverContext = Mockito.mock(HttpServerExchange.class);

        // 1st lambda
        Mockito.when(serverContext.dispatch(Mockito.any(Runnable.class)))
               .thenAnswer((Answer<HttpServerExchange>) invocation -> {

            Runnable runnable = invocation.getArgument(0);
            runnable.run();

            return serverContext;
        });

        // 2nd lambda
        Receiver receiver = Mockito.mock(Receiver.class);
        Mockito.doAnswer((Answer<Void>) invocation -> {

            FullBytesCallback callback = invocation.getArgument(0);
            callback.handle(serverContext, message);

            return null;

        }).when(receiver).receiveFullBytes(Mockito.any(FullBytesCallback.class));

        Mockito.when(serverContext.getRequestReceiver()).thenReturn(receiver);

        // class under test - method invocation
        handler.handleRequest(serverContext);

        // buisness logic call verification
        ArgumentCaptor<HttpServerExchange> captor1 = ArgumentCaptor.forClass(HttpServerExchange.class);
        ArgumentCaptor<byte[]> captor2 = ArgumentCaptor.forClass(byte[].class);

        Mockito.verify(logic).someMethod(captor1.capture(), captor2.capture());

        Assertions.assertEquals(serverContext, captor1.getValue());
        Assertions.assertEquals(message, captor2.getValue());
    }
}

正如其他人已经提到的那样，您应该只将这种方法用于遗留代码。

简单的重构可以将您需要测试的整个部分推入自己的方法中，在上面的示例中，这只是业务逻辑本身。

没有明确的必要自己测试undertow框架。

Java：调度程序内部的单元测试Lambda表达式

1 个答案: