Enhancement/404 page not found (#53)

* Add 404 error handling to `StaticFileHandler` with fallback page

* Add test coverage for `StaticFileHandler` and improve constructor flexibility

- Introduced a new constructor in `StaticFileHandler` to support custom web root paths, improving testability.
- Added `StaticFileHandlerTest` to validate static file serving and error handling logic.

* Add test for 404 handling in `StaticFileHandler`

- Added a test to ensure nonexistent files return a 404 response.
- Utilized a temporary directory and fallback file for improved test isolation.

* Verify `Content-Type` header in `StaticFileHandlerTest` after running Pittest, mutations survived where setHeaders could be removed without test failure.

* Remove unused `.btn` styles from `pageNotFound.html`

* Improve 404 handling in `StaticFileHandler`: add fallback to plain text response if `pageNotFound.html` is missing, and fix typo in `pageNotFound.html`, after comments from CodeRabbit.

Author: codebyNorthsteep

src/main/java/org/example/StaticFileHandler.java

@@ -10,21 +10,42 @@
 import java.util.Map;
 
 public class StaticFileHandler {
-    private static final String WEB_ROOT = "www";
+    private final String WEB_ROOT;
     private byte[] fileBytes;
+    private int statusCode;
 
-    public StaticFileHandler(){}
+    //Constructor for production
+    public StaticFileHandler() {
+        WEB_ROOT = "www";
+    }
+
+    //Constructor for tests, otherwise the www folder won't be seen
+    public StaticFileHandler(String webRoot){
+        WEB_ROOT = webRoot;
+    }
 
     private void handleGetRequest(String uri) throws IOException {
 
         File file = new File(WEB_ROOT, uri);
-        fileBytes = Files.readAllBytes(file.toPath());
-
+        if(file.exists()) {
+            fileBytes = Files.readAllBytes(file.toPath());
+            statusCode = 200;
+        } else {
+            File errorFile = new File(WEB_ROOT, "pageNotFound.html");
+            if(errorFile.exists()) {
+                fileBytes = Files.readAllBytes(errorFile.toPath());
+            } else {
+                fileBytes = "404 Not Found".getBytes();
+            }
+            statusCode = 404;
+        }
     }
 
     public void sendGetRequest(OutputStream outputStream, String uri) throws IOException{
         handleGetRequest(uri);
+
         HttpResponseBuilder response = new HttpResponseBuilder();
+        response.setStatusCode(statusCode);
         response.setHeaders(Map.of("Content-Type", "text/html; charset=utf-8"));
         response.setBody(fileBytes);
         PrintWriter writer = new PrintWriter(outputStream, true);

src/test/java/org/example/StaticFileHandlerTest.java

@@ -0,0 +1,79 @@
+package org.example;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Unit test class for verifying the behavior of the StaticFileHandler class.
+ *
+ * This test class ensures that StaticFileHandler correctly handles GET requests
+ * for static files, including both cases where the requested file exists and
+ * where it does not. Temporary directories and files are utilized in tests to
+ * ensure no actual file system dependencies during test execution.
+ *
+ * Key functional aspects being tested include:
+ * - Correct response status code and content for an existing file.
+ * - Correct response status code and fallback behavior for a missing file.
+ */
+class StaticFileHandlerTest {
+
+    //Junit creates a temporary folder which can be filled with temporary files that gets removed after tests
+    @TempDir
+    Path tempDir;
+
+
+    @Test
+    void test_file_that_exists_should_return_200() throws IOException {
+        //Arrange
+        Path testFile = tempDir.resolve("test.html"); // Defines the path in the temp directory
+        Files.writeString(testFile, "Hello Test"); // Creates a text in that file
+
+        //Using the new constructor in StaticFileHandler to reroute so the tests uses the temporary folder instead of the hardcoded www
+        StaticFileHandler staticFileHandler = new StaticFileHandler(tempDir.toString());
+
+        //Using ByteArrayOutputStream instead of Outputstream during tests to capture the servers response in memory, fake stream
+        ByteArrayOutputStream fakeOutput = new ByteArrayOutputStream();
+
+        //Act
+        staticFileHandler.sendGetRequest(fakeOutput, "test.html"); //Get test.html and write the answer to fakeOutput
+
+        //Assert
+        String response = fakeOutput.toString();//Converts the captured byte stream into a String for verification
+
+        assertTrue(response.contains("HTTP/1.1 200 OK")); // Assert the status
+        assertTrue(response.contains("Hello Test")); //Assert the content in the file
+
+        assertTrue(response.contains("Content-Type: text/html; charset=utf-8")); // Verify the correct Content-type header
+
+    }
+
+    @Test
+    void test_file_that_does_not_exists_should_return_404() throws IOException {
+        //Arrange
+        // Pre-create the mandatory error page in the temp directory to prevent NoSuchFileException
+        Path testFile = tempDir.resolve("pageNotFound.html");
+        Files.writeString(testFile, "Fallback page");
+
+        //Using the new constructor in StaticFileHandler to reroute so the tests uses the temporary folder instead of the hardcoded www
+        StaticFileHandler staticFileHandler = new StaticFileHandler(tempDir.toString());
+
+        //Using ByteArrayOutputStream instead of Outputstream during tests to capture the servers response in memory, fake stream
+        ByteArrayOutputStream fakeOutput = new ByteArrayOutputStream();
+
+        //Act
+        staticFileHandler.sendGetRequest(fakeOutput, "notExistingFile.html"); // Request a file that clearly doesn't exist to trigger the 404 logic
+
+        //Assert
+        String response = fakeOutput.toString();//Converts the captured byte stream into a String for verification
+
+        assertTrue(response.contains("HTTP/1.1 404 Not Found")); // Assert the status
+
+    }
+
+}

www/pageNotFound.html

@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>404 - Page Not Found</title>
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background-color: #f4f7f6;
+            color: #333;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            height: 100vh;
+            margin: 0;
+            text-align: center;
+        }
+        .container {
+            max-width: 600px;
+            padding: 40px;
+            background: white;
+            border-radius: 12px;
+            box-shadow: 0 10px 25px rgba(0,0,0,0.1);
+        }
+        h1 {
+            font-size: 100px;
+            margin: 0;
+            color: rgba(109, 21, 181, 0.6);
+            line-height: 1;
+        }
+        h2 {
+            font-size: 24px;
+            margin-bottom: 20px;
+        }
+        p {
+            color: #666;
+            margin-bottom: 30px;
+            line-height: 1.6;
+        }
+        .icon {
+            font-size: 50px;
+            margin-bottom: 20px;
+        }
+    </style>
+</head>
+<body>
+<div class="container">
+    <div class="icon">🚀</div>
+    <h1>404</h1>
+    <h2>Woopsie daisy! Page went to the moon.</h2>
+    <p>We cannot find the page you were looking for. Might have been moved, removed, or maybe it was kind of a useless link to begin with.</p>
+</div>
+</body>
+</html>