Comment tester mon servlet à l'aide de JUnit


112

J'ai créé un système Web en utilisant des servlets Java et je souhaite maintenant faire des tests JUnit. My dataManagerest juste un morceau de code de base qui le soumet à la base de données. Comment testeriez-vous un servlet avec JUnit?

Mon exemple de code qui permet à un utilisateur de s'inscrire / s'inscrire, qui est soumis depuis ma page principale via 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);
    }  
}

Réponses:


169

Vous pouvez le faire en utilisant Mockito pour que le simulacre renvoie les paramètres corrects, vérifiez qu'ils ont bien été appelés (spécifiez éventuellement le nombre de fois), écrivez le «résultat» et vérifiez qu'il est correct.

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

De cette façon, comment vous assurez-vous que "Cache-Control" est défini sur la réponse?
Markus Schulte

34
Au lieu d'imprimer dans un fichier réel sur le disque, vous pouvez utiliser un StringWriter (comme paramètre du constructeur de PrintWriter). Vous devrez alors assertTrue (stringWriter.toString (). Contains ("My Attendu String")); De cette façon, le test lit / écrit la mémoire au lieu du disque.
spg

@aaronvargas: Merci pour votre réponse! Mais lorsque j'exécute votre code, j'obtiens l'erreur suivante: java.util.MissingResourceException: Impossible de trouver le bundle pour le nom de base javax.servlet.LocalStrings, locale de_DE - Cela se produit lors de l'exécution du nouveau MyServlet (). DoPost ( ...). Une idée de ce qui pourrait être cassé?
Benny Neugebauer le

1
@BennyNeugebauer, on dirait que le bundle n'est pas sur le chemin des classes. J'écrirais un autre test JUnit qui n'obtient qu'une valeur du Bundle pour isoler le problème.
aaronvargas

@aaronvargas, merci pour vos commentaires! J'ai trouvé une solution pour cela. J'ai dû "javax.servlet-api" à mes dépendances dans mon pom.xml.
Benny Neugebauer

49

Tout d'abord, dans une application réelle, vous n'obtiendrez jamais d'informations de connexion à la base de données dans un servlet; vous le configureriez dans votre serveur d'application.

Il existe cependant des moyens de tester des servlets sans qu'un conteneur ne soit en cours d'exécution. La première consiste à utiliser des objets simulés. Spring fournit un ensemble de simulations très utiles pour des choses comme HttpServletRequest, HttpServletResponse, HttpServletSession, etc.:

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

En utilisant ces simulations, vous pouvez tester des choses comme

Que se passe-t-il si le nom d'utilisateur ne figure pas dans la demande?

Que se passe-t-il si le nom d'utilisateur figure dans la demande?

etc

Vous pouvez alors faire des choses comme:

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

3

Je trouve les tests Selenium plus utiles avec l'intégration ou les tests fonctionnels (de bout en bout). Je travaille avec essayer d'utiliser org.springframework.mock.web , mais je ne suis pas très loin. Je joins un exemple de contrôleur à une suite de tests jMock .

Tout d'abord, le contrôleur:

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

}

Ensuite, le 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));
        }

    }

J'espère que cela pourrait aider.


3

Mise à jour en février 2018: OpenBrace Limited a fermé ses portes et son produit ObMimic n'est plus pris en charge.

Voici une autre alternative, en utilisant la bibliothèque ObMimic d' OpenBrace de test-doubles de l'API Servlet (divulgation: je suis son développeur).

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

    }

}

Remarques:

  • Chaque "mimic" a un objet "mimicState" pour son état logique. Cela permet une distinction claire entre les méthodes de l'API Servlet et la configuration et l'inspection de l'état interne du synoptique.

  • Vous pourriez être surpris que la vérification de Content-Type inclut "charset = ISO-8859-1". Cependant, pour le code "doPost" donné, c'est selon le Javadoc de l'API Servlet, et la propre méthode getContentType de HttpServletResponse, et l'en-tête Content-Type réel produit par exemple sur Glassfish 3. Vous pourriez ne pas vous en rendre compte si vous utilisez des objets fictifs normaux et votre propres attentes du comportement de l'API. Dans ce cas, cela n'a probablement pas d'importance, mais dans les cas plus complexes, c'est le genre de comportement d'API imprévu qui peut faire un peu une moquerie!

  • J'ai utilisé response.getMimicState().getContentType()comme moyen le plus simple de vérifier Content-Type et d'illustrer le point ci-dessus, mais vous pouvez en effet vérifier "text / html" seul si vous le souhaitez (en utilisant response.getMimicState().getContentTypeMimeType()). La vérification de l'en-tête Content-Type de la même manière que pour l'en-tête Cache-Control fonctionne également.

  • Pour cet exemple, le contenu de la réponse est vérifié en tant que données de caractère (avec cela en utilisant le codage de Writer). Nous pourrions également vérifier que le Writer de la réponse a été utilisé plutôt que son OutputStream (en utilisant response.getMimicState().isWritingCharacterContent()), mais j'ai supposé que nous ne sommes préoccupés que par la sortie résultante, et ne nous soucions pas des appels d'API qui l'ont produit (bien que cela puisse être vérifié aussi ...). Il est également possible de récupérer le contenu du corps de la réponse sous forme d'octets, d'examiner l'état détaillé du Writer / OutputStream, etc.

Vous trouverez tous les détails d'ObMimic et un téléchargement gratuit sur le site Web d' OpenBrace . Ou vous pouvez me contacter si vous avez des questions (les coordonnées sont sur le site).


2

EDIT : Cactus est maintenant un projet mort: http://attic.apache.org/projects/jakarta-cactus.html


Vous voudrez peut-être regarder les cactus.

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

Description du projet

Cactus est un framework de test simple pour les tests unitaires de code java côté serveur (Servlets, EJB, Tag Libs, Filters, ...).

L'intention de Cactus est de réduire le coût d'écriture des tests pour le code côté serveur. Il utilise JUnit et l'étend.

Cactus implémente une stratégie dans le conteneur, ce qui signifie que les tests sont exécutés à l'intérieur du conteneur.


2

Une autre approche consisterait à créer un serveur intégré pour "héberger" votre servlet, vous permettant d'écrire des appels contre lui avec des bibliothèques destinées à faire des appels à des serveurs réels (l'utilité de cette approche dépend quelque peu de la facilité avec laquelle vous pouvez créer des programmes "légitimes". appels au serveur - je testais un point d'accès JMS (Java Messaging Service), pour lequel les clients abondent).

Il y a deux itinéraires différents que vous pouvez emprunter - les deux habituels sont Tomcat et Jetty.

Attention: la version de servlet-api que vous utilisez (la bibliothèque qui fournit des classes comme HttpServletRequest) doit être prise en compte lors du choix du serveur à intégrer. Si vous utilisez 2.5, j'ai trouvé que Jetty 6.x fonctionnait bien (qui est l'exemple que je donnerai ci-dessous). Si vous utilisez servlet-api 3.0, le truc intégré tomcat-7 semble être une bonne option, mais j'ai dû abandonner ma tentative de l'utiliser, car l'application que je testais utilisait servlet-api 2.5. Essayer de mélanger les deux entraînera NoSuchMethod et d'autres exceptions similaires lors de la tentative de configuration ou de démarrage du serveur.

Vous pouvez configurer un tel serveur comme celui-ci (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();
}

De plus, si vous choisissez d'investiguer l'injection de dépendances, vous rencontrerez probablement Spring. Spring utilise des contextes pour rechercher des éléments injectés. Si votre servlet finit par utiliser spring, vous pouvez lui fournir le même contexte que le test en ajoutant ce qui suit à la méthode ci-dessus (avant l'appel de démarrage): XmlWebApplicationContext wctx = new XmlWebApplicationContext (); wctx.setParent (yourAppContext); wctx.setConfigLocation (""); wctx.setServletContext (servletContext); wctx.refresh (); servletContext.setAttribute (WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, wctx);
romeara

1

Utilisez Selenium pour les tests unitaires sur le Web. Il existe un plugin Firefox appelé Selenium IDE qui peut enregistrer des actions sur la page Web et les exporter vers des cas de test JUnit qui utilise Selenium RC pour exécuter le serveur de test.


Merci pour cela semble bon, mais cela ne teste pas vraiment les méthodes / le code du servlet, pas directement? ou ai-je tort.
lunaire

Il le fait, en déclenchant des requêtes HTTP par programme.
BalusC

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

}

}

0

D'abord, vous devriez probablement refactoriser cela un peu pour que le DataManager ne soit pas créé dans le code doPost .. vous devriez essayer Dependency Injection pour obtenir une instance. (Voir la vidéo Guice pour une belle introduction à DI.). Si on vous dit de commencer à tout tester unitaire, alors DI est un incontournable.

Une fois vos dépendances injectées, vous pouvez tester votre classe de manière isolée.

Pour tester réellement le servlet, il y a d'autres threads plus anciens qui en ont discuté .. essayez ici et ici .


Ok merci pour vos commentaires, dites-vous que le DataManager devrait être créé dans une méthode au sein de ce servlet? J'ai regardé cette vidéo et je ne l'ai pas vraiment comprise: (très nouveau sur java, et je n'ai jamais fait de test.
Lunar

Jetez un œil à cette vidéo Guice (au moins le début) - elle explique bien pourquoi vous ne voulez jamais instancier un nouvel objet dans une classe que vous prévoyez de tester unitaire.
Roy Truelove
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.