Come testare il mio servlet usando JUnit


112

Ho creato un sistema web utilizzando Java Servlet e ora voglio fare il test di JUnit. Il mio dataManagerè solo un pezzo di codice di base che lo invia al database. Come testeresti un servlet con JUnit?

Il mio esempio di codice che consente a un utente di registrarsi / iscriversi, che viene inviato dalla mia pagina principale tramite 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);
    }  
}

Risposte:


169

Puoi farlo usando Mockito per fare in modo che il mock restituisca i parametri corretti, verificare che siano stati effettivamente chiamati (facoltativamente specificare il numero di volte), scrivere il "risultato" e verificare che sia corretto.

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

In questo modo, come assicurate che "Cache-Control" sia impostato sulla risposta?
Markus Schulte

34
Invece di stampare su un file effettivo su disco, è possibile utilizzare StringWriter (come parametro per il costruttore di PrintWriter). Dovresti quindi assertTrue (stringWriter.toString (). Contains ("My Expected String")); In questo modo, il test leggerà / scriverà la memoria invece del disco.
spg

@aaronvargas: grazie per la tua risposta! Ma quando eseguo il tuo codice, ottengo il seguente errore: java.util.MissingResourceException: Impossibile trovare il bundle per il nome di base javax.servlet.LocalStrings, locale de_DE - Si verifica durante l'esecuzione di new MyServlet (). DoPost ( ...). Qualche idea su cosa potrebbe essere rotto?
Benny Neugebauer

1
@BennyNeugebauer, sembra che il pacchetto non sia sul classpath. Scriverei un altro test JUnit che ottiene solo un valore dal bundle per isolare il problema.
aaronvargas

@aaronvargas, grazie per il tuo feedback! Ho trovato una soluzione per questo. Ho dovuto "javax.servlet-api" alle mie dipendenze nel mio pom.xml.
Benny Neugebauer

49

Prima di tutto, in un'applicazione reale, non si otterrebbero mai informazioni sulla connessione al database in un servlet; lo configureresti nel tuo server app.

Esistono, tuttavia, modi per testare i servlet senza avere un contenitore in esecuzione. Uno è usare oggetti fittizi. Spring fornisce una serie di mock molto utili per cose come HttpServletRequest, HttpServletResponse, HttpServletSession, ecc:

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

Usando questi mock, potresti testare cose come

Cosa succede se il nome utente non è nella richiesta?

Cosa succede se il nome utente è nella richiesta?

eccetera

Potresti quindi fare cose come:

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

Trovo che i test sul selenio siano più utili con i test di integrazione o funzionali (end-to-end). Sto lavorando cercando di utilizzare org.springframework.mock.web , ma non sono molto lontano. Allego un controller di esempio con una suite di test jMock .

Innanzitutto, il controller:

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

}

Successivamente, il 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));
        }

    }

Spero che questo possa aiutare.


3

Aggiornamento febbraio 2018: OpenBrace Limited è stato chiuso e il suo prodotto ObMimic non è più supportato.

Ecco un'altra alternativa, utilizzando la libreria ObMimic di OpenBrace delle API Servlet test-double (divulgazione: sono il suo sviluppatore).

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

    }

}

Appunti:

  • Ogni "mimic" ha un oggetto "mimicState" per il suo stato logico. Ciò fornisce una chiara distinzione tra i metodi API Servlet e la configurazione e l'ispezione dello stato interno del mimic.

  • Potresti essere sorpreso dal fatto che il controllo di Content-Type includa "charset = ISO-8859-1". Tuttavia, per il codice "doPost" dato, questo è come per Javadoc API Servlet, e il metodo getContentType di HttpServletResponse e l'effettiva intestazione Content-Type prodotta ad esempio su Glassfish 3. Potresti non rendertene conto se usi normali oggetti fittizi e il tuo proprie aspettative sul comportamento dell'API. In questo caso probabilmente non ha importanza, ma nei casi più complessi questo è il tipo di comportamento API imprevisto che può fare un po 'una presa in giro delle prese in giro!

  • L'ho usato response.getMimicState().getContentType()come il modo più semplice per controllare Content-Type e illustrare il punto precedente, ma potresti effettivamente controllare "text / html" da solo se lo desideri (usando response.getMimicState().getContentTypeMimeType()). Anche il controllo dell'intestazione Content-Type allo stesso modo dell'intestazione Cache-Control funziona.

  • Per questo esempio, il contenuto della risposta viene controllato come dati di carattere (utilizzando la codifica del writer). Potremmo anche controllare che il writer della risposta sia stato utilizzato anziché il suo OutputStream (utilizzando response.getMimicState().isWritingCharacterContent()), ma ho pensato che ci occupiamo solo dell'output risultante e non ci interessa quali chiamate API lo hanno prodotto (sebbene potrebbe essere controllato anche ...). È anche possibile recuperare il contenuto del corpo della risposta come byte, esaminare lo stato dettagliato di Writer / OutputStream ecc.

Sono disponibili tutti i dettagli di ObMimic e un download gratuito dal sito Web di OpenBrace . Oppure puoi contattarmi se hai domande (i dettagli di contatto sono sul sito web).


2

EDIT : Cactus è ora un progetto morto: http://attic.apache.org/projects/jakarta-cactus.html


Potresti voler guardare il cactus.

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

descrizione del progetto

Cactus è un semplice framework di test per il codice Java lato server di unit test (servlet, EJB, tag lib, filtri, ...).

L'intento di Cactus è quello di ridurre il costo di scrittura dei test per il codice lato server. Usa JUnit e lo estende.

Cactus implementa una strategia in-container, il che significa che i test vengono eseguiti all'interno del container.


2

Un altro approccio sarebbe quello di creare un server incorporato per "ospitare" il tuo servlet, permettendoti di scrivere chiamate contro di esso con librerie pensate per effettuare chiamate a server reali (l'utilità di questo approccio dipende in qualche modo dalla facilità con cui puoi rendere programmatico "legittimo" chiamate al server: stavo testando un punto di accesso JMS (Java Messaging Service), di cui abbondano i client).

Ci sono un paio di percorsi diversi che puoi percorrere: i soliti due sono tomcat e jetty.

Attenzione: qualcosa da tenere presente quando si sceglie il server da incorporare è la versione di servlet-api che si sta utilizzando (la libreria che fornisce classi come HttpServletRequest). Se stai usando 2.5, ho trovato che Jetty 6.x funziona bene (che è l'esempio che fornirò di seguito). Se stai usando servlet-api 3.0, la roba incorporata di tomcat-7 sembra essere una buona opzione, tuttavia ho dovuto abbandonare il mio tentativo di usarla, poiché l'applicazione che stavo testando utilizzava servlet-api 2.5. Il tentativo di mescolare i due comporterà NoSuchMethod e altre eccezioni simili quando si tenta di configurare o avviare il server.

Puoi configurare un server di questo tipo come questo (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();
}

Inoltre, se scegli di indagare sull'inserimento delle dipendenze, probabilmente ti imbatterai in Spring. Spring utilizza i contesti per cercare gli elementi iniettati. Se il tuo servlet finisce per utilizzare la primavera, puoi fornirgli lo stesso contesto del test aggiungendo quanto segue al metodo precedente (prima della chiamata di avvio): 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

Usa il selenio per gli unit test basati sul web. C'è un plugin per Firefox chiamato Selenium IDE che può registrare azioni sulla pagina web ed esportare in casi di prova JUnit che utilizza Selenium RC per eseguire il server di prova.


Grazie per questo sembra buono, ma non verifica davvero i metodi / il codice del servlet, non direttamente? o mi sbaglio.
Lunar

Lo fa, attivando le richieste HTTP a livello di programmazione.
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

Per prima cosa dovresti probabilmente rifattorizzare questo un po 'in modo che DataManager non venga creato nel codice doPost .. dovresti provare Dependency Injection per ottenere un'istanza. (Guarda il video di Guice per una bella introduzione a DI.). Se ti viene detto di iniziare a testare ogni cosa, allora DI è un must.

Una volta inserite le dipendenze, puoi testare la tua classe in isolamento.

Per testare effettivamente il servlet, ci sono altri thread meno recenti che hanno discusso di questo .. provare qui e qui .


Ok grazie per i tuoi commenti, stai dicendo che il DataManager dovrebbe essere creato all'interno di un metodo all'interno di quel servlet? Ho visto quel video e non l'ho capito davvero :( molto nuovo per java e non ho mai fatto alcun tipo di test.
Lunar

Dai un'occhiata a quel video di Guice (almeno all'inizio): spiega bene perché non vuoi mai creare un'istanza di un nuovo oggetto in una classe che prevedi di testare l'unità.
Roy Truelove
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.