JUnit kullanarak sunucu uygulamamı nasıl test ederim

Java Servlet kullanarak bir web sistemi oluşturdum ve şimdi JUnit testi yapmak istiyorum. My dataManager, onu veritabanına gönderen basit bir kod parçasıdır. JUnit ile bir Servlet'i nasıl test edersiniz?

Ana sayfamdan AJAX aracılığıyla gönderilen bir kullanıcının kaydolmasına / kaydolmasına izin veren kod örneğim:

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);
    }  
}

Bunu Mockito'yu kullanarak , taklidin doğru parametreleri döndürmesini, gerçekten çağrıldıklarını doğrulayın (isteğe bağlı olarak sayısını belirtin), 'sonucu' yazın ve doğru olduğunu doğrulayın.

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"));
    }
}

Öncelikle, gerçek bir uygulamada, bir sunucu uygulamasında veritabanı bağlantı bilgilerini asla alamazsınız; bunu uygulama sunucunuzda yapılandırırsınız.

Bununla birlikte, bir konteyner çalıştırmadan Servlet'leri test etmenin yolları vardır. Biri, sahte nesneler kullanmaktır. Spring, HttpServletRequest, HttpServletResponse, HttpServletSession, vb. Gibi şeyler için çok faydalı bir dizi alay sağlar:

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

Bu taklitleri kullanarak aşağıdaki gibi şeyleri test edebilirsiniz:

İstekte kullanıcı adı yoksa ne olur?

İstekte kullanıcı adı varsa ne olur?

vb

Daha sonra aşağıdaki gibi şeyler yapabilirsiniz:

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
    }
}

Selenium testlerini entegrasyon veya işlevsel (uçtan uca) testlerle daha kullanışlı buluyorum. Org.springframework.mock.web'i kullanmaya çalışıyorum , ancak çok uzak değilim. Bir jMock test paketine sahip bir örnek denetleyici ekliyorum .

İlk olarak, Denetleyici:

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;
            }
        }
    }

}

Ardından test:

    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));
        }

    }

Umarım bu yardımcı olabilir.

Şubat 2018'de güncellendi: OpenBrace Limited kapandı ve ObMimic ürünü artık desteklenmiyor.

İşte başka bir alternatif, OpenBrace'in ObMimic Servlet API test çiftleri kütüphanesini kullanarak (açıklama: Ben onun geliştiricisiyim).

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());

    }

}

Notlar:

• Her "mimic", mantıksal durumu için bir "mimicState" nesnesine sahiptir. Bu, Servlet API yöntemleri ile taklitin dahili durumunun yapılandırılması ve incelenmesi arasında açık bir ayrım sağlar.

• Content-Type kontrolünün "charset = ISO-8859-1" içermesine şaşırmış olabilirsiniz. Bununla birlikte, verilen "doPost" kodu için bu, Servlet API Javadoc'a ve HttpServletResponse'nin kendi getContentType yöntemine ve örneğin Glassfish 3'te üretilen gerçek Content-Type üstbilgisine uygundur. Normal sahte nesneler ve API'nin davranışına ilişkin kendi beklentileri. Bu durumda muhtemelen önemli değildir, ancak daha karmaşık durumlarda bu, biraz alaycı bir alay haline gelebilecek bir tür beklenmedik API davranışıdır!

• response.getMimicState().getContentType()Content-Type'ı kontrol etmenin ve yukarıdaki noktayı göstermenin en basit yolu olarak kullandım , ancak isterseniz (kullanarak response.getMimicState().getContentTypeMimeType()) "text / html" yi kendi başına kontrol edebilirsiniz . Content-Type başlığını Cache-Control başlığıyla aynı şekilde kontrol etmek de işe yarar.

• Bu örnek için yanıt içeriği karakter verileri olarak kontrol edilir (bununla Writer'ın kodlaması kullanılır). Ayrıca yanıtın Writer'ının OutputStream (kullanıyor response.getMimicState().isWritingCharacterContent()) yerine kullanıldığını kontrol edebilirdik , ancak sonuçta ortaya çıkan çıktıyla ilgilendiğimizi ve onu hangi API çağrılarının ürettiğini umursamadığımızı anladım (gerçi bu çok kontrol edildi ...). Ayrıca yanıtın gövde içeriğini bayt olarak almak, Writer / OutputStream'in ayrıntılı durumunu incelemek vb. Mümkündür.

ObMimic'in tüm detayları ve OpenBrace web sitesinde ücretsiz olarak indirilebilir . Veya herhangi bir sorunuz olursa benimle iletişime geçebilirsiniz (iletişim bilgileri web sitesinde yer almaktadır).

DÜZENLE : Cactus artık ölü bir proje: http://attic.apache.org/projects/jakarta-cactus.html

Kaktüse bakmak isteyebilirsiniz.

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

Proje Açıklaması

Cactus, sunucu tarafı java kodunu (Servletler, EJB'ler, Etiket Kitaplıkları, Filtreler, ...) birim testi için basit bir test çerçevesidir.

Cactus'un amacı, sunucu tarafı kod için test yazma maliyetini düşürmektir. JUnit kullanır ve onu genişletir.

Cactus, konteyner içinde bir strateji uygular, yani testler konteynerin içinde yürütülür.

Başka bir yaklaşım, sunucu uygulamanızı "barındırmak" için gömülü bir sunucu oluşturmaktır ve gerçek sunuculara çağrı yapmak için kütüphanelerle ona karşı çağrılar yazmanıza olanak tanır (bu yaklaşımın kullanışlılığı bir şekilde ne kadar kolay "meşru" programatik yapabileceğinize bağlıdır. sunucuya yapılan aramalar - İstemcilerin bol olduğu bir JMS (Java Messaging Service) erişim noktasını test ediyordum.

Gidebileceğiniz birkaç farklı rota var - normal ikisi tomcat ve iskele.

Uyarı: Gömülecek sunucuyu seçerken dikkat etmeniz gereken bir şey, kullandığınız servlet-api sürümüdür (HttpServletRequest gibi sınıflar sağlayan kitaplık). 2.5 kullanıyorsanız, Jetty 6.x'in iyi çalıştığını buldum (aşağıda vereceğim örnek budur). Servlet-api 3.0 kullanıyorsanız, tomcat-7 gömülü şeyler iyi bir seçenek gibi görünüyor, ancak test ettiğim uygulama servlet-api 2.5 kullandığından, onu kullanma girişimimi terk etmem gerekti. İkisini karıştırmaya çalışmak, sunucuyu yapılandırmaya veya başlatmaya çalışırken NoSuchMethod ve diğer bu tür istisnalarla sonuçlanacaktır.

Böyle bir sunucu kurabilirsiniz (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();
}

Web tabanlı birim testleri için Selenium kullanın . Web sayfasındaki eylemleri kaydedebilen ve test sunucusunu çalıştırmak için Selenium RC kullanan JUnit test olaylarına aktarabilen Selenium IDE adlı bir Firefox eklentisi var .

 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);

}

}

Öncelikle, DataManager'ın doPost kodunda oluşturulmaması için muhtemelen bunu biraz yeniden düzenlemelisiniz .. Bir örnek almak için Bağımlılık Enjeksiyonunu denemelisiniz. ( DI'ye güzel bir giriş için Guice videosuna bakın .). Her şeyi birim test etmeye başlamanız söylendiyse, DI sahip olmanız gereken bir şeydir.

Bağımlılıklarınız enjekte edildikten sonra sınıfınızı izole olarak test edebilirsiniz.

Sunucuyu gerçekten test etmek için, bunu tartışan daha eski iş parçacıkları var .. burada ve burada deneyin .