Junit初级应用实例

Request：

public interface Request {
    String getName();
}

Response：

public interface Response {
    String getName();
}

RequestHandler：

public interface RequestHandler {
    Response process(Request request) throws Exception;
}

Controller：

public interface Controller {
    Response processRequest(Request request);

    void addHandler(Request request, RequestHandler requestHandler);
}

DefaultController：

import java.util.HashMap;
import java.util.Map;

public class DefaultController implements Controller{

    /*
        如果这个地方指明了RequestHandler的，可能会遇到一些泛型方面的问题。
        指明了RequestHandler，我能够将RequestHandler的子类放进这个map
        中么？

        这个地方我忘了，估计那部分还需要再阅读一遍
     */
    private Map<String,RequestHandler> requestHandlers = new HashMap<String, RequestHandler>();

    protected RequestHandler getHander(Request request) {
        if (!this.requestHandlers.containsKey(request.getName())) {
            String msg = "Can't find handler for request name.";
            throw new RuntimeException(msg);
        }
        return requestHandlers.get(request.getName());
    }

    public Response processRequest(Request request) {
        Response response;
        try{
            response = getHander(request).process(request);
        } catch (Exception e) {
            response = new ErrorResponse(request, e);
        }
        return response;
    }

    public void addHandler(Request request, RequestHandler requestHandler) {
        if (this.requestHandlers.containsKey(request.getName())) {
            String msg = "A request handler handler has "+
                    "already been registered for request "+
                    "["+request.getName()+"].";
            throw new RuntimeException(msg);
        }else {
            requestHandlers.put(request.getName(), requestHandler);
        }
    }
}

ErrorResponse：

public class ErrorResponse implements Response {
    private String name = "ErrorResponse";
    private Request originalRequest;
    private Exception originalException;

    public ErrorResponse(Request originalRequest, Exception originalException) {
        this.originalRequest = originalRequest;
        this.originalException = originalException;
    }

    public Request getOriginalRequest() {
        return originalRequest;
    }

    public Exception getOriginalException() {
        return originalException;
    }

    public String getName() {
        return name;
    }
}

DefaultControllerTest：

import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;

import static org.junit.Assert.*;

public class DefaultControllerTest {

    private DefaultController controller;
    private Request request;
    private RequestHandler handler;

    @Before
    public void instantiate() throws Exception{
        controller = new DefaultController();
        request = new SimpleRequest();
        handler = new SimpleRequestHandler();

        controller.addHandler(request, handler);
    }

    @Test
    public void testAddHandler(){
        RequestHandler handler2 = controller.getHander(request);
        assertSame("Should be same.",handler,handler2);
    }

    @Test
    public void testProcessRequest() {
        Response response = controller.processRequest(request);
        assertNotNull("Should not be null",response);
        assertEquals("shoue be same", new SimpleResponse(), response);
    }

    /*
        书上这部分有点乱，我只能自己来设计各个测试了，前面已经完成了
        诊断测试，现在主要完成各个异常测试：
            1.测试addHandler方法抛出的异常
            2.测试getHandler方法抛出的异常
            3.测试process方法抛出的异常，由于process方法的异常
                被DefaultController的processRequest方法给
                捕获了，所以需要测试processRequest返回的错误
                消息。
     */
    @Test
    public void testProcessAnswerErrorResponse(){
        SimpleRequest request = new SimpleRequest("testError");
        SimpleExceptionHandler handler = new SimpleExceptionHandler();
        controller.addHandler(request,handler);
        Response response = controller.processRequest(request);

        assertNotNull("Should not be noll", response);
        assertEquals("Should be the same.", ErrorResponse.class,response.getClass());
    }

    @Test(expected = RuntimeException.class)
    public void testGetHandlerNotDefined() {
        SimpleRequest request = new SimpleRequest("testNotDefined");

        controller.getHander(request);
    }

    @Test(expected = RuntimeException.class)
    public void testAddHandlerDuplicateName() {
        SimpleRequest request = new SimpleRequest();
        SimpleRequestHandler handler = new SimpleRequestHandler();

        controller.addHandler(request,handler);
    }

    /*
        测试超时
     */
    @Test(timeout = 130)
    @Ignore(value = "no need not.")
    public void testProcessMultipleRequestsTimeout() {
        Request request;
        Response simpleResponse = new SimpleResponse();
        SimpleRequestHandler handler = new SimpleRequestHandler();

        for (int i = 0; i < 99999; i++) {
            request = new SimpleRequest();
            controller.addHandler(request, handler);
            simpleResponse = controller.processRequest(request);
            assertNotNull(simpleResponse);
            assertNotSame(ErrorResponse.class,simpleResponse.getClass());
        }
    }

    private class SimpleRequest implements Request {

        private static final String NAME = "Test";

        private String name;

        public SimpleRequest(String name) {
            this.name = name;
        }

        public SimpleRequest() {
            this(NAME);
        }

        public String getName() {
            return name;
        }
    }

    private class SimpleResponse implements Response {

        private static final String NAME = "Test";

        public String getName() {
            return NAME;
        }

        @Override
        public boolean equals(Object obj) {
            boolean result = false;
            if (obj instanceof SimpleResponse) {
                result = ((SimpleResponse) obj).getName().equals(getName());
            }
            return result;
        }

        @Override
        public int hashCode() {
            return NAME.hashCode();
        }
    }

    private class SimpleRequestHandler implements RequestHandler {

        public Response process(Request request) throws Exception {
            return new SimpleResponse();
        }
    }

    private class SimpleExceptionHandler implements RequestHandler {

        public Response process(Request request) throws Exception {
            String msg = "error processing request";
            throw new Exception(msg);
        }
    }
}

《Junit实战》笔记