[HttpServer series] Testing the server
Tags: java, learning, frameworks
Published: 2024-01-10 10:18:10

---
title: [HttpServer series] Testing the server
published: true
date: 2024-01-10 06:30:11 UTC
tags: java, learning, frameworks 
canonical_url: https://blog.mandraketech.in/httpserver-series-testing-the-server
series: Project No-Web-Framework-No-Annotations using Java
---

As I started the journey down the test route, the first thought was to unit test the individual Handlers. This required the implementation of a `HttpExchange` object. As I delved into the specific APIs to be implemented for a `MockHttpExchange` it turned out that there is a specific set of sequence the APIs should be called. As per the documentation, the `sendResponseHeaders` needs to be called before the `getResponseBody` stream. But, in the actual implementation in the JRE, that need not be the case. So, my Mocks broke my implementation that works in production. Hah !!!

Then I looked at testing the registration of the endpoints, and that lead me to implement a `MockHttpServer` that would accept the context registrations. Again, implementing that API felt like I was not getting any testing done really. Everything was in my mock, so the production would feel very different, and possibly break.

So, I dropped the "unit test", and worked on the integration test. My tests bring up an Http Server in the test environment, hit the 2 APIs ( ping and 404, for everything else) that have been implemented, and stop the server after that.

I am fairly satisfied with this approach for now. It allows me to move on to the next step.

The test looks like this:

```
class PingAndRootEndpointTest { static App app; static final int PORT = 9090; static String baseAddress = "http://localhost:%d".formatted(PORT); @BeforeAll public static void initializeApp() throws IOException { app = new App(PORT); app.start(); } @AfterAll public static void stopApp() { app.stop(0); app = null; } @Test void testPingHandler() throws IOException, InterruptedException { var client = HttpClient.newHttpClient(); var uri = URI.create("%s/%s".formatted(baseAddress, "ping")); var response = client.send( HttpRequest.newBuilder().GET().uri(uri).build(), BodyHandlers.ofString()); assertEquals(200, response.statusCode()); assertEquals("pong", response.body()); } @Test void testRootHandler() throws IOException, InterruptedException { var client = HttpClient.newHttpClient(); var uri = URI.create("%s/%s".formatted(baseAddress, "404")); var response = client.send( HttpRequest.newBuilder().GET().uri(uri).build(), BodyHandlers.ofString()); assertEquals(404, response.statusCode()); assertEquals("Not Found !!!", response.body()); } }
```

The code for the tests are in this Merge Request: [https://gitlab.com/mandraketech/httpserver-based-todo-app/-/merge\_requests/5](https://gitlab.com/mandraketech/httpserver-based-todo-app/-/merge_requests/5)

Yeah, I know, **Annotations.** These are for Junit 5. And there is no way to avoid them. Thankfully, they do not add anything to the class files. Only used for lookup using reflection, when running them.

I did not know about IntegrationTests, or IT, plugin called [Maven Failsafe](https://maven.apache.org/surefire/maven-failsafe-plugin) at the time I merged the request. Will rename the test at an appropriate time and integrate this plugin too. Need to be able to differentiate between Unit Tests and Integration Tests.

Along the way, I got some cleanup, and simplifications on the Docker images, for dev as well as prod environments. They now use the alpine versions of the JRE, and VSCode is happy working in them. So, I just trimmed down the release image to under 300MB, down from over 600 earlier. The dev environment is down from over 900 MB earlier to under 600MB too. The changes are in the ([https://gitlab.com/mandraketech/java-vscode-dev](https://gitlab.com/mandraketech/java-vscode-dev)) if you want to take from there.

We have "Water Though the Pipe" now, and the learnings from these are as follows:

- The HttpServer "context" can be used to wire up separate processing units, but each context will need a "Router" for itself, just like all the other frameworks. For example, creating a context handler for serving static files, and another for endpoints that server JSON, vs those that server html / templates.

- This will require writing a basic router that can handle the Todo endpoints. Given that the HttpServer context exposes the very fundamental constructs, it will help if we can wrap up the request, response and some request context into the handler api. This will allow cleanly handling any error conditions, and ensuring that the response stream is not polluted in the handler.

- This will also allow us to write "preprocessors" or "middleware" to handle security, sanitising the request, and similar activities.

- I will look for inspiration in the implementation to the Servlet API, and the Fastify framework ( Node ecosystem ).

It has been quite a journey so far. Until next time.