วิธีทดสอบ servlet ของฉันโดยใช้ JUnit

ฉันได้สร้างระบบเว็บโดยใช้ Java Servlets และตอนนี้ต้องการทำการทดสอบ JUnit ของฉันdataManagerเป็นเพียงส่วนพื้นฐานของรหัสที่ส่งไปยังฐานข้อมูล คุณจะทดสอบ Servlet กับ JUnit ได้อย่างไร

ตัวอย่างรหัสของฉันที่อนุญาตให้ผู้ใช้ลงทะเบียน / สมัครซึ่งส่งมาจากหน้าหลักของฉันผ่าน AJAX:

public void doPost(HttpServletRequest request, HttpServletResponse response) 
         throws ServletException, IOException{

    // Get parameters
    String userName = request.getParameter("username");
    String password = request.getParameter("password");
    String name = request.getParameter("name");

    try {

        // Load the database driver
        Class.forName("com.mysql.jdbc.Driver");

        //pass reg details to datamanager       
        dataManager = new DataManager();
        //store result as string
        String result = dataManager.register(userName, password, name);

        //set response to html + no cache
        response.setContentType("text/html");
        response.setHeader("Cache-Control", "no-cache");
        //send response with register result
        response.getWriter().write(result);

    } catch(Exception e){
        System.out.println("Exception is :" + e);
    }  
}

คุณสามารถทำได้โดยใช้Mockitoเพื่อให้การจำลองส่งคืนพารามิเตอร์ที่ถูกต้องตรวจสอบว่าถูกเรียกจริง (ระบุจำนวนครั้งหรือไม่ก็ได้) เขียน 'ผลลัพธ์' และตรวจสอบว่าถูกต้อง

import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.io.*;
import javax.servlet.http.*;
import org.apache.commons.io.FileUtils;
import org.junit.Test;

public class TestMyServlet extends Mockito{

    @Test
    public void testServlet() throws Exception {
        HttpServletRequest request = mock(HttpServletRequest.class);       
        HttpServletResponse response = mock(HttpServletResponse.class);    

        when(request.getParameter("username")).thenReturn("me");
        when(request.getParameter("password")).thenReturn("secret");

        StringWriter stringWriter = new StringWriter();
        PrintWriter writer = new PrintWriter(stringWriter);
        when(response.getWriter()).thenReturn(writer);

        new MyServlet().doPost(request, response);

        verify(request, atLeast(1)).getParameter("username"); // only if you want to verify username was called...
        writer.flush(); // it may not have been flushed yet...
        assertTrue(stringWriter.toString().contains("My expected string"));
    }
}

ก่อนอื่นในแอปพลิเคชันจริงคุณจะไม่ได้รับข้อมูลการเชื่อมต่อฐานข้อมูลใน servlet คุณจะกำหนดค่าในเซิร์ฟเวอร์แอปของคุณ

อย่างไรก็ตามมีหลายวิธีในการทดสอบ Servlets โดยไม่ต้องใช้คอนเทนเนอร์ หนึ่งคือการใช้วัตถุจำลอง Spring มีชุดล้อเลียนที่มีประโยชน์มากสำหรับสิ่งต่างๆเช่น HttpServletRequest, HttpServletResponse, HttpServletSession ฯลฯ :

http://static.springsource.org/spring/docs/3.0.x/api/org/springframework/mock/web/package-summary.html

ใช้ล้อเลียนเหล่านี้คุณสามารถทดสอบสิ่งต่างๆเช่น

จะเกิดอะไรขึ้นหากชื่อผู้ใช้ไม่อยู่ในคำขอ

จะเกิดอะไรขึ้นหากชื่อผู้ใช้อยู่ในคำขอ

ฯลฯ

จากนั้นคุณสามารถทำสิ่งต่างๆเช่น:

import static org.junit.Assert.assertEquals;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.junit.Before;
import org.junit.Test;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;

public class MyServletTest {
    private MyServlet servlet;
    private MockHttpServletRequest request;
    private MockHttpServletResponse response;

    @Before
    public void setUp() {
        servlet = new MyServlet();
        request = new MockHttpServletRequest();
        response = new MockHttpServletResponse();
    }

    @Test
    public void correctUsernameInRequest() throws ServletException, IOException {
        request.addParameter("username", "scott");
        request.addParameter("password", "tiger");

        servlet.doPost(request, response);

        assertEquals("text/html", response.getContentType());

        // ... etc
    }
}

ฉันพบว่าการทดสอบซีลีเนียมมีประโยชน์มากกว่าเมื่อใช้การทดสอบการรวมหรือฟังก์ชัน (end-to-end) ฉันทำงานโดยพยายามใช้org.springframework.mock.webแต่ฉันอยู่ไม่ไกลมากนัก ฉันกำลังแนบตัวควบคุมตัวอย่างกับjMockชุดทดสอบ

อันดับแรกตัวควบคุม:

package com.company.admin.web;

import javax.validation.Valid;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.SessionAttributes;
import org.springframework.web.bind.support.SessionStatus;

import com.company.admin.domain.PaymentDetail;
import com.company.admin.service.PaymentSearchService;
import com.company.admin.service.UserRequestAuditTrail;
import com.company.admin.web.form.SearchCriteria;

/**
 * Controls the interactions regarding to the refunds.
 * 
 * @author slgelma
 *
 */
@Controller
@SessionAttributes({"user", "authorization"})
public class SearchTransactionController {

    public static final String SEARCH_TRANSACTION_PAGE = "searchtransaction";

    private PaymentSearchService searchService;
    //private Validator searchCriteriaValidator;
    private UserRequestAuditTrail notifications;

    @Autowired
    public void setSearchService(PaymentSearchService searchService) {
        this.searchService = searchService;
    }

    @Autowired
    public void setNotifications(UserRequestAuditTrail notifications) {
        this.notifications = notifications;
    }

    @RequestMapping(value="/" + SEARCH_TRANSACTION_PAGE)
    public String setUpTransactionSearch(Model model) {
        SearchCriteria searchCriteria = new SearchCriteria();
        model.addAttribute("searchCriteria", searchCriteria);
        notifications.transferTo(SEARCH_TRANSACTION_PAGE);
        return SEARCH_TRANSACTION_PAGE;
    }

    @RequestMapping(value="/" + SEARCH_TRANSACTION_PAGE, method=RequestMethod.POST, params="cancel")
    public String cancelSearch() {
        notifications.redirectTo(HomeController.HOME_PAGE);
        return "redirect:/" + HomeController.HOME_PAGE;
    }

    @RequestMapping(value="/" + SEARCH_TRANSACTION_PAGE, method=RequestMethod.POST, params="execute")
    public String executeSearch(
            @ModelAttribute("searchCriteria") @Valid SearchCriteria searchCriteria,
            BindingResult result, Model model,
            SessionStatus status) {
        //searchCriteriaValidator.validate(criteria, result);
        if (result.hasErrors()) {
            notifications.transferTo(SEARCH_TRANSACTION_PAGE);
            return SEARCH_TRANSACTION_PAGE;
        } else {
            PaymentDetail payment = 
                searchService.getAuthorizationFor(searchCriteria.geteWiseTransactionId());
            if (payment == null) {
                ObjectError error = new ObjectError(
                        "eWiseTransactionId", "Transaction not found");
                result.addError(error);
                model.addAttribute("searchCriteria", searchCriteria);
                notifications.transferTo(SEARCH_TRANSACTION_PAGE);
                return SEARCH_TRANSACTION_PAGE;
            } else {
                model.addAttribute("authorization", payment);
                notifications.redirectTo(PaymentDetailController.PAYMENT_DETAIL_PAGE);
                return "redirect:/" + PaymentDetailController.PAYMENT_DETAIL_PAGE;
            }
        }
    }

}

ถัดไปการทดสอบ:

    package test.unit.com.company.admin.web;

    import static org.hamcrest.Matchers.containsString;
    import static org.hamcrest.Matchers.equalTo;
    import static org.junit.Assert.assertThat;

    import org.jmock.Expectations;
    import org.jmock.Mockery;
    import org.jmock.integration.junit4.JMock;
    import org.jmock.integration.junit4.JUnit4Mockery;
    import org.junit.Before;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.ui.Model;
    import org.springframework.validation.BindingResult;
    import org.springframework.validation.ObjectError;
    import org.springframework.web.bind.support.SessionStatus;

    import com.company.admin.domain.PaymentDetail;
    import com.company.admin.service.PaymentSearchService;
    import com.company.admin.service.UserRequestAuditTrail;
    import com.company.admin.web.HomeController;
    import com.company.admin.web.PaymentDetailController;
    import com.company.admin.web.SearchTransactionController;
    import com.company.admin.web.form.SearchCriteria;

    /**
     * Tests the behavior of the SearchTransactionController.
     * @author slgelma
     *
     */
    @RunWith(JMock.class)
    public class SearchTransactionControllerTest {

        private final Mockery context = new JUnit4Mockery(); 
        private final SearchTransactionController controller = new SearchTransactionController();
        private final PaymentSearchService searchService = context.mock(PaymentSearchService.class);
        private final UserRequestAuditTrail notifications = context.mock(UserRequestAuditTrail.class);
        private final Model model = context.mock(Model.class);


        /**
         * @throws java.lang.Exception
         */
        @Before
        public void setUp() throws Exception {
            controller.setSearchService(searchService);
            controller.setNotifications(notifications);
        }

        @Test
        public void setUpTheSearchForm() {

            final String target = SearchTransactionController.SEARCH_TRANSACTION_PAGE;

            context.checking(new Expectations() {{
                oneOf(model).addAttribute(
                        with(any(String.class)), with(any(Object.class)));
                oneOf(notifications).transferTo(with(any(String.class)));
            }});

            String nextPage = controller.setUpTransactionSearch(model);
            assertThat("Controller is not requesting the correct form", 
                    target, equalTo(nextPage));
        }

        @Test
        public void cancelSearchTest() {

            final String target = HomeController.HOME_PAGE;

            context.checking(new Expectations(){{
                never(model).addAttribute(with(any(String.class)), with(any(Object.class)));
                oneOf(notifications).redirectTo(with(any(String.class)));
            }});

            String nextPage = controller.cancelSearch();
            assertThat("Controller is not requesting the correct form", 
                    nextPage, containsString(target));
        }

        @Test
        public void executeSearchWithNullTransaction() {

            final String target = SearchTransactionController.SEARCH_TRANSACTION_PAGE;

            final SearchCriteria searchCriteria = new SearchCriteria();
            searchCriteria.seteWiseTransactionId(null);

            final BindingResult result = context.mock(BindingResult.class);
            final SessionStatus status = context.mock(SessionStatus.class);

            context.checking(new Expectations() {{
                allowing(result).hasErrors(); will(returnValue(true));
                never(model).addAttribute(with(any(String.class)), with(any(Object.class)));
                never(searchService).getAuthorizationFor(searchCriteria.geteWiseTransactionId());
                oneOf(notifications).transferTo(with(any(String.class)));
            }});

            String nextPage = controller.executeSearch(searchCriteria, result, model, status);
            assertThat("Controller is not requesting the correct form", 
                    target, equalTo(nextPage));
        }

        @Test
        public void executeSearchWithEmptyTransaction() {

            final String target = SearchTransactionController.SEARCH_TRANSACTION_PAGE;

            final SearchCriteria searchCriteria = new SearchCriteria();
            searchCriteria.seteWiseTransactionId("");

            final BindingResult result = context.mock(BindingResult.class);
            final SessionStatus status = context.mock(SessionStatus.class);

            context.checking(new Expectations() {{
                allowing(result).hasErrors(); will(returnValue(true));
                never(model).addAttribute(with(any(String.class)), with(any(Object.class)));
                never(searchService).getAuthorizationFor(searchCriteria.geteWiseTransactionId());
                oneOf(notifications).transferTo(with(any(String.class)));
            }});

            String nextPage = controller.executeSearch(searchCriteria, result, model, status);
            assertThat("Controller is not requesting the correct form", 
                    target, equalTo(nextPage));
        }

        @Test
        public void executeSearchWithTransactionNotFound() {

            final String target = SearchTransactionController.SEARCH_TRANSACTION_PAGE;
            final String badTransactionId = "badboy"; 
            final PaymentDetail transactionNotFound = null;

            final SearchCriteria searchCriteria = new SearchCriteria();
            searchCriteria.seteWiseTransactionId(badTransactionId);

            final BindingResult result = context.mock(BindingResult.class);
            final SessionStatus status = context.mock(SessionStatus.class);

            context.checking(new Expectations() {{
                allowing(result).hasErrors(); will(returnValue(false));
                atLeast(1).of(model).addAttribute(with(any(String.class)), with(any(Object.class)));
                oneOf(searchService).getAuthorizationFor(with(any(String.class)));
                    will(returnValue(transactionNotFound));
                oneOf(result).addError(with(any(ObjectError.class)));
                oneOf(notifications).transferTo(with(any(String.class)));
            }});

            String nextPage = controller.executeSearch(searchCriteria, result, model, status);
            assertThat("Controller is not requesting the correct form", 
                    target, equalTo(nextPage));
        }

        @Test
        public void executeSearchWithTransactionFound() {

            final String target = PaymentDetailController.PAYMENT_DETAIL_PAGE;
            final String goodTransactionId = "100000010";
            final PaymentDetail transactionFound = context.mock(PaymentDetail.class);

            final SearchCriteria searchCriteria = new SearchCriteria();
            searchCriteria.seteWiseTransactionId(goodTransactionId);

            final BindingResult result = context.mock(BindingResult.class);
            final SessionStatus status = context.mock(SessionStatus.class);

            context.checking(new Expectations() {{
                allowing(result).hasErrors(); will(returnValue(false));
                atLeast(1).of(model).addAttribute(with(any(String.class)), with(any(Object.class)));
                oneOf(searchService).getAuthorizationFor(with(any(String.class)));
                    will(returnValue(transactionFound));
                oneOf(notifications).redirectTo(with(any(String.class)));
            }});

            String nextPage = controller.executeSearch(searchCriteria, result, model, status);
            assertThat("Controller is not requesting the correct form", 
                    nextPage, containsString(target));
        }

    }

ฉันหวังว่านี่อาจช่วยได้

อัปเดตเมื่อกุมภาพันธ์ 2018: OpenBrace Limited ได้ปิดตัวลงและผลิตภัณฑ์ ObMimic ไม่ได้รับการสนับสนุนอีกต่อไป

นี่เป็นอีกทางเลือกหนึ่งโดยใช้ไลบรารี ObMimic ของOpenBraceของ Servlet API test-doubles (การเปิดเผย: ฉันเป็นผู้พัฒนา)

package com.openbrace.experiments.examplecode.stackoverflow5434419;

import static org.junit.Assert.*;
import com.openbrace.experiments.examplecode.stackoverflow5434419.YourServlet;
import com.openbrace.obmimic.mimic.servlet.ServletConfigMimic;
import com.openbrace.obmimic.mimic.servlet.http.HttpServletRequestMimic;
import com.openbrace.obmimic.mimic.servlet.http.HttpServletResponseMimic;
import com.openbrace.obmimic.substate.servlet.RequestParameters;
import org.junit.Before;
import org.junit.Test;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * Example tests for {@link YourServlet#doPost(HttpServletRequest,
 * HttpServletResponse)}.
 *
 * @author Mike Kaufman, OpenBrace Limited
 */
public class YourServletTest {

    /** The servlet to be tested by this instance's test. */
    private YourServlet servlet;

    /** The "mimic" request to be used in this instance's test. */
    private HttpServletRequestMimic request;

    /** The "mimic" response to be used in this instance's test. */
    private HttpServletResponseMimic response;

    /**
     * Create an initialized servlet and a request and response for this
     * instance's test.
     *
     * @throws ServletException if the servlet's init method throws such an
     *     exception.
     */
    @Before
    public void setUp() throws ServletException {
        /*
         * Note that for the simple servlet and tests involved:
         * - We don't need anything particular in the servlet's ServletConfig.
         * - The ServletContext isn't relevant, so ObMimic can be left to use
         *   its default ServletContext for everything.
         */
        servlet = new YourServlet();
        servlet.init(new ServletConfigMimic());
        request = new HttpServletRequestMimic();
        response = new HttpServletResponseMimic();
    }

    /**
     * Test the doPost method with example argument values.
     *
     * @throws ServletException if the servlet throws such an exception.
     * @throws IOException if the servlet throws such an exception.
     */
    @Test
    public void testYourServletDoPostWithExampleArguments()
            throws ServletException, IOException {

        // Configure the request. In this case, all we need are the three
        // request parameters.
        RequestParameters parameters
            = request.getMimicState().getRequestParameters();
        parameters.set("username", "mike");
        parameters.set("password", "xyz#zyx");
        parameters.set("name", "Mike");

        // Run the "doPost".
        servlet.doPost(request, response);

        // Check the response's Content-Type, Cache-Control header and
        // body content.
        assertEquals("text/html; charset=ISO-8859-1",
            response.getMimicState().getContentType());
        assertArrayEquals(new String[] { "no-cache" },
            response.getMimicState().getHeaders().getValues("Cache-Control"));
        assertEquals("...expected result from dataManager.register...",
            response.getMimicState().getBodyContentAsString());

    }

}

หมายเหตุ:

• "mimic" แต่ละตัวมีออบเจ็กต์ "mimicState" สำหรับสถานะทางตรรกะ สิ่งนี้ให้ความแตกต่างที่ชัดเจนระหว่างวิธีการ Servlet API กับการกำหนดค่าและการตรวจสอบสถานะภายในของเลียนแบบ

• คุณอาจแปลกใจที่การตรวจสอบประเภทเนื้อหามี "charset = ISO-8859-1" อย่างไรก็ตามสำหรับโค้ด "doPost" ที่กำหนดนี้เป็นไปตาม Servlet API Javadoc และเมธอด getContentType ของ HttpServletResponse และส่วนหัว Content-Type จริงที่สร้างขึ้นบนเช่น Glassfish 3 คุณอาจไม่ตระหนักถึงสิ่งนี้หากใช้วัตถุจำลองปกติและของคุณ ความคาดหวังของตัวเองเกี่ยวกับพฤติกรรมของ API ในกรณีนี้อาจไม่สำคัญ แต่ในกรณีที่ซับซ้อนมากขึ้นนี่คือพฤติกรรม API ที่ไม่คาดคิดซึ่งสามารถสร้างความเยาะเย้ยได้เล็กน้อย!

• ฉันใช้response.getMimicState().getContentType()เป็นวิธีที่ง่ายที่สุดในการตรวจสอบประเภทเนื้อหาและแสดงประเด็นข้างต้น แต่คุณสามารถตรวจสอบ "text / html" ได้ด้วยตัวเองหากคุณต้องการ (ใช้response.getMimicState().getContentTypeMimeType()) การตรวจสอบส่วนหัว Content-Type ในลักษณะเดียวกับส่วนหัว Cache-Control ก็ใช้ได้เช่นกัน

• สำหรับตัวอย่างนี้เนื้อหาตอบกลับจะถูกตรวจสอบเป็นข้อมูลอักขระ (โดยใช้การเข้ารหัสของนักเขียน) นอกจากนี้เรายังสามารถตรวจสอบได้ว่า Writer ของการตอบกลับถูกใช้มากกว่า OutputStream (ใช้response.getMimicState().isWritingCharacterContent()) แต่ฉันได้พิจารณาแล้วว่าเราเกี่ยวข้องกับผลลัพธ์ที่ได้เท่านั้นและไม่สนใจว่าการเรียก API ใดที่สร้างขึ้น (แม้ว่าจะเป็นเช่นนั้นก็ตาม ตรวจสอบด้วย ... ). นอกจากนี้ยังสามารถดึงเนื้อหาของการตอบสนองเป็นไบต์ตรวจสอบสถานะโดยละเอียดของ Writer / OutputStream เป็นต้น

มีรายละเอียดทั้งหมดของ ObMimic และดาวน์โหลดได้ฟรีที่เว็บไซต์OpenBrace หรือคุณสามารถติดต่อฉันหากคุณมีคำถามใด ๆ (รายละเอียดการติดต่ออยู่ในเว็บไซต์)

แก้ไข : ตอนนี้ Cactus เป็นโครงการที่ตายแล้ว: http://attic.apache.org/projects/jakarta-cactus.html

คุณอาจอยากดูกระบองเพชร

http://jakarta.apache.org/cactus/

คำอธิบายโครงการ

Cactus เป็นกรอบการทดสอบอย่างง่ายสำหรับการทดสอบหน่วยโค้ด java ฝั่งเซิร์ฟเวอร์ (Servlets, EJBs, Tag Libs, Filters, ... )

จุดประสงค์ของ Cactus คือลดต้นทุนในการเขียนทดสอบโค้ดฝั่งเซิร์ฟเวอร์ ใช้ JUnit และขยาย

แคคตัสใช้กลยุทธ์ในตู้คอนเทนเนอร์ซึ่งหมายความว่าจะมีการทดสอบภายในคอนเทนเนอร์

อีกวิธีหนึ่งคือการสร้างเซิร์ฟเวอร์แบบฝังเพื่อ "โฮสต์" servlet ของคุณทำให้คุณสามารถเขียนการโทรกับมันด้วยไลบรารีที่หมายถึงการโทรไปยังเซิร์ฟเวอร์จริง (ประโยชน์ของวิธีนี้จะขึ้นอยู่กับว่าคุณสามารถสร้างโปรแกรมที่ "ถูกต้อง" ได้ง่ายเพียงใด โทรไปยังเซิร์ฟเวอร์ - ฉันกำลังทดสอบจุดเชื่อมต่อ JMS (Java Messaging Service) ซึ่งมีไคลเอ็นต์อยู่มาก)

มีเส้นทางที่แตกต่างกันสองสามเส้นทางที่คุณสามารถไปได้โดยปกติสองเส้นทางคือแมวตัวผู้และท่าเทียบเรือ

คำเตือน: สิ่งที่ควรคำนึงถึงเมื่อเลือกเซิร์ฟเวอร์ที่จะฝังคือเวอร์ชันของ servlet-api ที่คุณใช้ (ไลบรารีที่มีคลาสเช่น HttpServletRequest) หากคุณใช้ 2.5 ฉันพบว่า Jetty 6.x ทำงานได้ดี (ซึ่งเป็นตัวอย่างที่ฉันจะให้ด้านล่าง) หากคุณใช้ servlet-api 3.0 สิ่งที่ฝังไว้ tomcat-7 ดูเหมือนจะเป็นตัวเลือกที่ดี แต่ฉันต้องละทิ้งความพยายามที่จะใช้เนื่องจากแอปพลิเคชันที่ฉันกำลังทดสอบใช้ servlet-api 2.5 การพยายามผสมทั้งสองอย่างจะส่งผลให้เกิด NoSuchMethod และข้อยกเว้นอื่น ๆ เมื่อพยายามกำหนดค่าหรือเริ่มเซิร์ฟเวอร์

คุณสามารถตั้งค่าเซิร์ฟเวอร์เช่นนี้ได้ (Jetty 6.1.26, servlet-api 2.5):

public void startServer(int port, Servlet yourServletInstance){
    Server server = new Server(port);
    Context root = new Context(server, "/", Context.SESSIONS);

    root.addServlet(new ServletHolder(yourServletInstance), "/servlet/context/path");

    //If you need the servlet context for anything, such as spring wiring, you coudl get it like this
    //ServletContext servletContext = root.getServletContext();

    server.start();
}

ใช้ซีลีเนียมสำหรับการทดสอบหน่วยบนเว็บ มีปลั๊กอิน Firefox ที่เรียกว่าSelenium IDEซึ่งสามารถบันทึกการกระทำบนหน้าเว็บและส่งออกไปยัง JUnit testcases ซึ่งใช้Selenium RCเพื่อเรียกใช้เซิร์ฟเวอร์ทดสอบ

 public class WishServletTest {
 WishServlet wishServlet;
 HttpServletRequest mockhttpServletRequest;
 HttpServletResponse mockhttpServletResponse;

@Before
public void setUp(){
    wishServlet=new WishServlet();
    mockhttpServletRequest=createNiceMock(HttpServletRequest.class);
    mockhttpServletResponse=createNiceMock(HttpServletResponse.class);
}

@Test
public void testService()throws Exception{
    File file= new File("Sample.txt");
    File.createTempFile("ashok","txt");
    expect(mockhttpServletRequest.getParameter("username")).andReturn("ashok");
    expect(mockhttpServletResponse.getWriter()).andReturn(new PrintWriter(file));
    replay(mockhttpServletRequest);
    replay(mockhttpServletResponse);
    wishServlet.doGet(mockhttpServletRequest, mockhttpServletResponse);
    FileReader fileReader=new FileReader(file);
    int count = 0;
    String str = "";
    while ( (count=fileReader.read())!=-1){
        str=str+(char)count;
    }

    Assert.assertTrue(str.trim().equals("Helloashok"));
    verify(mockhttpServletRequest);
    verify(mockhttpServletResponse);

}

}

ก่อนอื่นคุณควร refactor เล็กน้อยเพื่อไม่ให้ DataManager สร้างขึ้นในโค้ด doPost .. คุณควรลอง Dependency Injection เพื่อรับอินสแตนซ์ (ดูGuiceวิดีโอสำหรับคำแนะนำที่ดีสำหรับ DI) หากคุณได้รับคำสั่งให้เริ่มการทดสอบหน่วยทุกอย่าง DI คือสิ่งที่ต้องมี

เมื่อการพึ่งพาของคุณถูกฉีดแล้วคุณสามารถทดสอบชั้นเรียนของคุณแยกกันได้

ที่จริงการทดสอบเซิร์ฟเล็ตมีหัวข้อเก่าอื่น ๆ ที่ได้กล่าวถึงนี้ .. ลองที่นี่และที่นี่