JUnit का उपयोग करके मेरे सर्वलेट का परीक्षण कैसे करें

Question

मैंने जावा सर्वलेट्स का उपयोग करके एक वेब सिस्टम बनाया है और अब JUnit परीक्षण करना चाहता हूं। मेरा dataManagerकोड का एक मूल टुकड़ा है जो इसे डेटाबेस में जमा करता है। आप 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);
    }  
}

Answer 1

आप मॉकिटो का उपयोग करके मॉक को सही पैरामन्स वापस कर सकते हैं, सत्यापित करें कि उन्हें वास्तव में बुलाया गया था (वैकल्पिक रूप से संख्या निर्दिष्ट करें), 'परिणाम' लिखें और यह सत्यापित करें कि यह सही है।

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

Comments

इस तरह, आप प्रतिक्रिया पर सेट किए जा रहे "कैश-कंट्रोल" का बीमा कैसे करते हैं?

— मार्कस शुल्ते

डिस्क पर एक वास्तविक फ़ाइल को प्रिंट करने के बजाय, आप StringWriter (PrintWiter के निर्माता के लिए एक पैरामीटर के रूप में) का उपयोग कर सकते हैं। आप तब जोर देंगे (stringWriter.toString ()। ("मेरी उम्मीद की स्ट्रिंग") शामिल हैं); इस तरह, परीक्षण डिस्क के बजाय मेमोरी को पढ़ / लिख देगा।

— एसपीजी

@ARonvargas: आप जवाब के लिए धन्यवाद! लेकिन जब मैं आपके कोड को निष्पादित करता हूं, तो मुझे निम्न त्रुटि मिलती है: java.util.MissingResourceException: आधार नाम javax.servlet.LocalStrings, locale de_DE के लिए बंडल नहीं मिल सकता है - यह नए MyServlet () doPost () के निष्पादन के दौरान होता है। ...)। किसी भी विचार को क्या तोड़ा जा सकता है?

— बेनी न्युगबॉएर

@ बेनीइजेनबॉयर, लगता है जैसे बंडल क्लासपाथ पर नहीं है। मैं एक और JUnit परीक्षण लिखूंगा जो समस्या को अलग करने के लिए केवल बंडल से एक मान प्राप्त करता है।

— अनारोन्वार्गस १५'१४

@ARonvargas, आपकी प्रतिक्रिया के लिए धन्यवाद! मुझे इसका हल मिल गया। मुझे अपने pom.xml में अपनी निर्भरता के लिए "javax.servlet-api" करना पड़ा।

— बेनी न्युगबॉएर

Answer 2

सबसे पहले, एक वास्तविक एप्लिकेशन में, आपको एक सर्वलेट में डेटाबेस कनेक्शन की जानकारी कभी नहीं मिलेगी; आप इसे अपने ऐप सर्वर में कॉन्फ़िगर करेंगे।

हालांकि, कंटेनर चलाने के बिना सर्वलेट्स के परीक्षण के तरीके हैं। एक नकली वस्तुओं का उपयोग करना है। वसंत 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
    }
}

Answer 3

मुझे लगता है कि सेलेनियम परीक्षण एकीकरण या कार्यात्मक (एंड-टू-एंड) परीक्षण के साथ अधिक उपयोगी हैं। मैं 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));
        }

    }

मुझे उम्मीद है कि यह मदद कर सकता है।

Answer 4

फरवरी 2018 को अपडेट किया गया: ओपनब्रेस लिमिटेड बंद हो गया है , और इसका ओबामिक उत्पाद अब समर्थित नहीं है।

यहाँ एक और विकल्प है, OpenBrace की ObMimic लाइब्रेरी का सर्वलेट एपीआई टेस्ट-डबल्स का उपयोग करते हुए (प्रकटीकरण: मैं इसका डेवलपर हूँ)।

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

    }

}

टिप्पणियाँ:

• प्रत्येक "मिमिक" में अपनी तार्किक स्थिति के लिए "मिमिकस्टेट" ऑब्जेक्ट होता है। यह सर्वलेट एपीआई विधियों और मिमिक की आंतरिक स्थिति के कॉन्फ़िगरेशन और निरीक्षण के बीच एक स्पष्ट अंतर प्रदान करता है।

• आपको आश्चर्य हो सकता है कि सामग्री-प्रकार की जांच में "charset = ISO-8859-1" शामिल है। हालाँकि, दिए गए "doPost" कोड के लिए यह सर्वलेट API Javadoc, और HttpServletResponse की अपनी getContentType विधि और उदाहरण के लिए ग्लासफिश पर निर्मित वास्तविक सामग्री-प्रकार हेडर के अनुसार है। आपको यह महसूस नहीं हो सकता है कि सामान्य नकली वस्तुओं और आपके उपयोग से एपीआई के व्यवहार की अपनी अपेक्षाएं। इस मामले में यह शायद कोई फर्क नहीं पड़ता, लेकिन अधिक जटिल मामलों में यह अप्रत्याशित एपीआई व्यवहार की तरह है जो नकली का एक सा बना सकता है!

• मैंने response.getMimicState().getContentType()सामग्री-प्रकार की जाँच करने और उपरोक्त बिंदु को स्पष्ट करने के लिए सबसे सरल तरीके के रूप में उपयोग किया है , लेकिन आप वास्तव में "टेक्स्ट / एचटीएमएल" की जांच कर सकते हैं यदि आप चाहते थे (उपयोग कर रहे हैं response.getMimicState().getContentTypeMimeType())। सामग्री-प्रकार के हेडर की जाँच उसी तरह से की जाती है जैसे कैश-कंट्रोल हेडर भी काम करता है।

• इस उदाहरण के लिए प्रतिक्रिया सामग्री को चरित्र डेटा (लेखक के एन्कोडिंग का उपयोग करने के साथ) के रूप में जांच की जाती है। हम यह भी जांच सकते हैं कि प्रतिक्रिया का लेखक इसके आउटपुटस्ट्रीम (प्रयोग response.getMimicState().isWritingCharacterContent()) के बजाय उपयोग किया गया था , लेकिन मैंने इसे लिया है कि हम केवल परिणामी आउटपुट से चिंतित हैं, और परवाह नहीं करते हैं कि एपीआई कॉल ने इसका उत्पादन किया (हालांकि यह हो सकता है) जाँच भी ...)। प्रतिक्रिया की शरीर सामग्री को बाइट्स के रूप में पुनः प्राप्त करना भी संभव है, लेखक / आउटपुटस्ट्रीम आदि की विस्तृत स्थिति की जांच करें।

ObMimic की पूरी जानकारी और OpenBrace वेबसाइट पर एक मुफ्त डाउनलोड है । यदि आपके कोई प्रश्न हों (वेबसाइट पर संपर्क विवरण हो) तो आप मुझसे संपर्क कर सकते हैं।

Answer 5

संपादित करें : कैक्टस अब एक मृत परियोजना है: http://attic.apache.org/projects/jakarta-cact.ru.html

---

आप कैक्टस को देखना चाह सकते हैं।

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

परियोजना विवरण

कैक्टस यूनिट टेस्टिंग सर्वर-साइड जावा कोड (सर्वलेट्स, ईजेबी, टैग लिब, फिल्टर, ...) के लिए एक सरल परीक्षण ढांचा है।

कैक्टस का इरादा सर्वर-साइड कोड के लिए परीक्षण परीक्षण की लागत को कम करना है। यह JUnit का उपयोग करता है और इसका विस्तार करता है।

कैक्टस इन-कंटेनर रणनीति को लागू करता है, जिसका अर्थ है कि परीक्षण कंटेनर के अंदर निष्पादित किए जाते हैं।

Answer 6

एक अन्य तरीका यह होगा कि आप अपने सर्वलेट को "होस्ट" करने के लिए एक एम्बेडेड सर्वर बनाएं, जिससे आपको इसके खिलाफ कॉल लिखने की इजाजत दी जा सके कि पुस्तकालयों का मतलब वास्तविक सर्वर से कॉल करना है (इस दृष्टिकोण की उपयोगिता कुछ हद तक इस बात पर निर्भर करती है कि आप कितनी आसानी से "वैध" प्रोग्राम बना सकते हैं। सर्वर पर कॉल - मैं एक JMS (जावा मैसेजिंग सर्विस) एक्सेस प्वाइंट का परीक्षण कर रहा था, जिसके लिए ग्राहक लाजिमी हैं)।

अलग-अलग मार्गों के एक जोड़े हैं जो आप जा सकते हैं - सामान्य दो टोमैट और जेट्टी हैं।

चेतावनी: एम्बेड करने के लिए सर्वर का चयन करते समय कुछ ध्यान रखें कि आपके द्वारा उपयोग किया जा रहा सर्वलेट-एपीआई का संस्करण है (लाइब्रेरी जो कि HttpServletRequest जैसी कक्षाएं प्रदान करता है)। यदि आप 2.5 का उपयोग कर रहे हैं, तो मुझे जेटी 6.x अच्छी तरह से काम करने के लिए मिला (जो कि नीचे दिए गए उदाहरण है)। यदि आप सर्वलेट-एआई 3.0 का उपयोग कर रहे हैं, तो टॉमकट -7 एम्बेडेड सामान एक अच्छा विकल्प प्रतीत होता है, हालांकि मुझे इसका उपयोग करने के लिए अपने प्रयास को छोड़ना पड़ा, क्योंकि मैं जिस एप्लिकेशन का उपयोग कर रहा था, वह सर्वलेट-एपी 2.5 का परीक्षण कर रहा था। सर्वर को कॉन्फ़िगर या प्रारंभ करने का प्रयास करते समय दोनों को मिलाने की कोशिश में NoSuchMethod और अन्य ऐसे अपवाद होंगे।

आप इस तरह का सर्वर सेट कर सकते हैं (जेटी 6.1.26, सर्वलेट-एपी 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();
}

Comments

इसके अलावा, यदि आप जांच निर्भरता इंजेक्शन में चुनते हैं, तो आप संभवतः स्प्रिंग में चलेंगे। वसंत इंजेक्शन वस्तुओं को देखने के लिए संदर्भों का उपयोग करता है। यदि आपका सर्वलेट वसंत का उपयोग करके समाप्त हो जाता है, तो आप इसे उपरोक्त विधि (निम्न आरंभ करने से पहले) जोड़कर परीक्षण के समान संदर्भ प्रदान कर सकते हैं: XmlWebApplicationContext wctx = new XmlWebApplicationContext (); wctx.setParent (yourAppContext); wctx.setConfigLocation ( ""); wctx.setServletContext (ServletContext); wctx.refresh (); servletContext.setAttribute (WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, wctx);

— रोमिया

Answer 7

वेबबेड यूनिट परीक्षणों के लिए सेलेनियम का उपयोग करें । सेलेनियम आईडीई नामक एक फ़ायरफ़ॉक्स प्लगइन है जो वेबपेज पर क्रियाओं को रिकॉर्ड कर सकता है और जेयूनेट टेस्टकेस को निर्यात कर सकता है जो टेस्ट सर्वर को चलाने के लिए सेलेनियम आरसी का उपयोग करता है।

Comments

इसके लिए धन्यवाद अच्छा लग रहा है, लेकिन यह वास्तव में तरीकों का परीक्षण नहीं करता है / सर्वलेट कोड इसे करता है, सीधे नहीं? या मैं गलत हूँ।

— चंद्र

यह HTTP अनुरोधों को प्रोग्रामेटिक रूप से फायर करके करता है।

— बालुसक

Answer 8

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

}

}

Answer 9

सबसे पहले आपको शायद इसे थोड़ा रिफ्लेक्टर करना चाहिए ताकि डेट मैन कोड में डेटा मैनजर न बने .. आपको एक उदाहरण प्राप्त करने के लिए डिपेंडेंसी इंजेक्शन की कोशिश करनी चाहिए। ( DI के लिए एक अच्छा परिचय के लिए गिटार वीडियो देखें ।) अगर आपको यूनिट टेस्टिंग सब कुछ शुरू करने के लिए कहा जा रहा है, तो DI एक जरूरी है।

एक बार जब आपकी निर्भरता इंजेक्ट हो जाती है तो आप अलगाव में अपनी कक्षा का परीक्षण कर सकते हैं।

वास्तव में सर्वलेट का परीक्षण करने के लिए, अन्य पुराने धागे हैं जिन्होंने इस पर चर्चा की है .. यहां और यहां प्रयास करें ।

Comments

आपकी टिप्पणियों के लिए ठीक है धन्यवाद, क्या आप कह रहे हैं कि DataManager को उस सर्वलेट के भीतर एक विधि के भीतर बनाया जाना चाहिए? मैंने उस वीडियो को देखा और वास्तव में इसे समझ नहीं पाया :( जावा के लिए बहुत नया, और किसी भी तरह का परीक्षण कभी नहीं किया है।

— Lunar

उस Guice वीडियो (कम से कम शुरुआत) पर एक नज़र डालें - यह समझाने का एक अच्छा काम करता है कि आप कभी भी एक नई वस्तु को उस कक्षा में क्यों नहीं चाहते हैं जिसे आप इकाई परीक्षण पर योजना बनाते हैं।

— रॉय Truelove