Apache Http test cases using Junit

Your mocking is unfortunately not used, because the method to test creates its own CloseableHttpClient. Fortunately, HttpClient has something for this. With these, you can send actual HTTP requests, but to a test server that only exists while each test is running.

HttpClient 4.x

Since the tags include "apache-httpclient-4.x" I'll that with that.

First you need a dependency with the same version as the HttpClient you're using:

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <classifier>tests</classifier>
            <scope>test</scope>
        </dependency>

This gives you access to class LocalServerTestBase. This is meant to be extended by your own test classes. If that's not possible you need to create a little helper class that exposes a protected field you need:

final class HttpServer extends LocalServerTestBase {

    ServerBootstrap serverBootStrap() {
        return serverBootstrap;
    }
}

If you're using JUnit 4, the LocalServerTestBase comes with its own @Before and @After methods. If you're using JUnit 5 you need to call these explicitly:

// if needed, include this
//private Server server = new Server();

@BeforeEach
protected void startServer() {
    // The setUp method is annotated with JUnit 4's @Before
    assertDoesNotThrow(this::setUp);
}

@AfterEach
protected void shutdownServer() {
    // The setUp method is annotated with JUnit 4's @After
    assertDoesNotThrow(this::shutDown);
}

In your test methods you can now register a handler that determines the response:

// use server.serverBootStrap() if you didn't extend LocalServerTestBase
serverBootStrap.registerHandler("/path-to-test", (request, response, context -> {
    // setup your response here
    response.setStatusCode(200);
});

After that's done, you must call start() (or server.start()). That returns an HttpHost that you can use to get its port etc. It has method toURI that gives you a URI if you prefer that.

HttpHost host = assertDoesNotThrow(this::start);

Now that you have that, you can set the apiUrl of your userServiceClient.

If you need the host for the apiUrl in your existing @BeforeEach method, you can move some stuff around so you can call server.start() there. That does mean setting up the handler in your @BeforeEach method. That makes it less flexible.

HttpClient 5.x

HttpClient 5.x has something similar. You again need a dependency with the same version as the HttpClient you're using:

        <dependency>
            <groupId>org.apache.httpcomponents.client5</groupId>
            <artifactId>httpclient5-testing</artifactId>
            <scope>test</scope>
        </dependency>

Unlike HttpClient 4'x LocalServerTestBase, HttpClient 5's ClassicTestServer was always meant to be included. And unlike localServerTestBase, you can register handlers after starting. That makes it simpler to use.

Setup this server in your test class:

private ClassicTestServer server = new ClassicTestServer();
private String hostname;

@BeforeEach
protected void start(TestInfo testInfo) {
    assertDoesNotThrow(() -> server.start());

    InetAddress address = server.getInetAddress();
    // you can now get the port and hostname for the apiUrl from address
    hostname = address.getHostAddress();
}

@AfterEach
protected void shutdown() {
    server.shutdown(CloseMode.GRACEFUL);
}

In your test methods you can now register a handler that determines the response:

server.registerHandlerVirtual(hostname, "/path-to-test", (request, response, context -> {
    // setup your response here
    response.setCode(200);
});