Servlet单元测试编写求助：获取application-jars真实路径

Hey there! Since you're new to Servlet unit testing, let's walk through how to test this init method—specifically handling the application-jars real path check. The key here is to mock the Servlet container dependencies (like ServletConfig and ServletContext) so you don't need to spin up a full server for unit tests. We'll use Mockito (a popular mocking framework) and JUnit for this.

Step 1: Add Required Dependencies #

First, make sure you have these dependencies in your build file (Maven example below):

<dependencies>
    <!-- JUnit 5 -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.9.2</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.9.2</version>
        <scope>test</scope>
    </dependency>
    <!-- Mockito for mocking Servlet dependencies -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>4.11.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-junit-jupiter</artifactId>
        <version>4.11.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Step 2: Write the Test Class #

Let's create a test class for your Servlet. We'll mock ServletConfig and ServletContext, then verify both success and failure scenarios for the application-jars path.

First, let's assume your Servlet class is named MyAppServlet. Here's the test code:

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
public class MyAppServletTest {

    // Mock the ServletConfig and ServletContext
    @Mock
    private ServletConfig mockServletConfig;
    @Mock
    private ServletContext mockServletContext;

    // Instance of your Servlet to test
    private MyAppServlet servlet = new MyAppServlet();

    @Test
    void init_ValidApplicationJarsPath_Succeeds() throws ServletException {
        // 1. Setup mock behavior: return a valid real path for "application-jars"
        String validJarPath = "/tmp/application-jars";
        when(mockServletConfig.getServletContext()).thenReturn(mockServletContext);
        when(mockServletContext.getRealPath("application-jars")).thenReturn(validJarPath);

        // 2. Mock other dependencies in your Servlet (if needed)
        // If loadProperties() and checkAppsExists() are external, use spy() to mock them:
        // MyAppServlet spyServlet = spy(servlet);
        // when(spyServlet.loadProperties()).thenReturn(new Properties());
        // when(spyServlet.checkAppsExists(any(Properties.class))).thenReturn("app1,app2");

        // 3. Call the init method
        servlet.init(mockServletConfig);

        // 4. Verify the behavior
        verify(mockServletContext).getRealPath("application-jars");
        // Optionally, assert the value of applicationjars if it's accessible:
        // assertEquals(validJarPath, servlet.applicationjars);
    }

    @Test
    void init_NullApplicationJarsPath_ThrowsServletException() {
        // 1. Setup mock behavior: return null for the real path
        when(mockServletConfig.getServletContext()).thenReturn(mockServletContext);
        when(mockServletContext.getRealPath("application-jars")).thenReturn(null);

        // 2. Execute and verify exception
        ServletException exception = assertThrows(ServletException.class, () -> {
            servlet.init(mockServletConfig);
        });

        assertEquals("Cannot find path for application jars", exception.getMessage());
    }
}

Key Explanations #

• Mocking: We use @Mock to create fake versions of ServletConfig and ServletContext. This lets us control their behavior without relying on a real server.
• Success Scenario: We tell the mock ServletContext to return a valid path, then confirm the init method runs without errors and interacts with the mocks as expected.
• Failure Scenario: We make getRealPath return null, then verify that the correct ServletException is thrown with the right message.
• Handling Other Dependencies: If loadProperties() or checkAppsExists() call external services/files, use Mockito.spy() on your Servlet to mock those methods and return fixed values—this keeps your test focused on the application-jars path logic.

Tips for Newbies #

• Keep tests focused: Each test should verify one specific behavior (like success vs failure here).
• Avoid testing container logic: Unit tests should only validate your code, not how the Servlet container works.
• For more complex Servlet logic later, look into embedded containers like Jetty for integration tests—but Mockito-based unit tests are perfect for isolating logic like this.

内容的提问来源于stack exchange，提问作者Pooja Sharma