test: add exercise tests

Genyus · Genyus · commit 8336aa34b6f0 · 2025-07-08T18:14:29.000+01:00
diff --git a/.github/workflows/classroom-autograding.yml b/.github/workflows/classroom-autograding.yml
@@ -9,7 +9,7 @@ env:
   GRADING_REPO: cbfacademy/autograding-java-exercises
   GRADING_REPO_PATH: grading-repo
   STUDENT_REPO_PATH: student-repo
-  MAX_TESTS: 0 # TODO: Update this to the actual number of tests available for the exercise
+  MAX_TESTS: 8
 
 jobs:
   autograding:
diff --git a/src/test/java/com/cbfacademy/AppTest.java b/src/test/java/com/cbfacademy/AppTest.java
@@ -2,6 +2,16 @@
 
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLConnection;
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.notNullValue;
@@ -10,11 +20,63 @@
 @DisplayName(value = "Basic Test Suite")
 public class AppTest {
 
+    private final PrintStream originalOut = System.out;
+    private ByteArrayOutputStream outputCapture;
+
+    @BeforeEach
+    public void setUp() {
+        // Set up output capture
+        outputCapture = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(outputCapture));
+    }
+
+    @AfterEach
+    public void tearDown() {
+        // Restore original System.out
+        System.setOut(originalOut);
+    }
+
     @Test
     @DisplayName("creates the app")
     public void createsAnApp() {
         final App app = new App();
 
         assertThat(app, is(notNullValue()));
     }
+
+    @Test
+    @DisplayName("main method outputs website content correctly")
+    public void mainMethodOutputsWebsiteContent() throws Exception {
+        // Call the main method (which will print to our captured output)
+        App.main(new String[]{});
+        
+        // Get the captured output
+        String actualOutput = outputCapture.toString();
+        
+        // Make our own request to get expected output
+        String expectedOutput = getExpectedWebsiteContent();
+        
+        // Compare the outputs
+        assertThat("Main method should output the same content as direct HTTP request", 
+                   actualOutput.trim(), is(expectedOutput.trim()));
+    }
+
+    private String getExpectedWebsiteContent() throws Exception {
+        URL url = new URI("https://codingblackfemales.com").toURL();
+        URLConnection connection = url.openConnection();
+        connection.connect();
+        
+        StringBuilder content = new StringBuilder();
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
+            String inputLine;
+            while ((inputLine = reader.readLine()) != null) {
+                content.append(inputLine);
+                if (reader.ready()) {
+                    content.append(System.lineSeparator());
+                }
+            }
+        }
+        
+        return content.toString();
+    }
 }
diff --git a/src/test/java/com/cbfacademy/SocketClientTest.java b/src/test/java/com/cbfacademy/SocketClientTest.java
@@ -0,0 +1,178 @@
+package com.cbfacademy;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+@DisplayName("Socket Client Test Suite")
+public class SocketClientTest {
+
+    private final PrintStream originalOut = System.out;
+    private ByteArrayOutputStream outputCapture;
+    private Thread mockServerThread;
+    private CountDownLatch serverReady;
+    private AtomicReference<String> receivedMessage;
+
+    @BeforeEach
+    public void setUp() {
+        // Set up output capture
+        outputCapture = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(outputCapture));
+        serverReady = new CountDownLatch(1);
+        receivedMessage = new AtomicReference<>();
+    }
+
+    @AfterEach
+    public void tearDown() {
+        // Stop mock server thread if running
+        if (mockServerThread != null && mockServerThread.isAlive()) {
+            mockServerThread.interrupt();
+            try {
+                mockServerThread.join(1000);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+        }
+        
+        // Restore original System.out
+        System.setOut(originalOut);
+    }
+
+    @Test
+    @DisplayName("client connects and sends correct message")
+    @Timeout(value = 10, unit = TimeUnit.SECONDS)
+    public void clientConnectsAndSendsMessage() throws Exception {
+        // Skip test if SocketClient class doesn't exist
+        assumeTrue(isSocketClientImplemented(), "SocketClient class must be implemented to run this test");
+        
+        // Start mock server
+        startMockServer();
+        
+        // Wait for server to be ready
+        assertThat("Mock server should start within timeout",
+                   serverReady.await(5, TimeUnit.SECONDS));
+        
+        // Run the client using reflection to avoid compilation dependency
+        runSocketClientMain();
+        
+        // Give time for message to be processed
+        Thread.sleep(100);
+        
+        // Verify client sent the expected message
+        assertThat("Client should send 'Hello, World!' message",
+                   receivedMessage.get(), is("Hello, World!"));
+        
+        // Verify console output
+        String output = outputCapture.toString();
+        assertThat("Client should log sent message",
+                   output, containsString("Sent message to server: Hello, World!"));
+    }
+
+    @Test
+    @DisplayName("client handles server connection successfully")
+    @Timeout(value = 10, unit = TimeUnit.SECONDS)
+    public void clientHandlesConnection() throws Exception {
+        // Skip test if SocketClient class doesn't exist
+        assumeTrue(isSocketClientImplemented(), "SocketClient class must be implemented to run this test");
+        
+        // Start mock server
+        startMockServer();
+        serverReady.await(5, TimeUnit.SECONDS);
+        
+        // Run client using reflection
+        runSocketClientMain();
+        Thread.sleep(100);
+        
+        // Verify no exceptions in output (no stack trace)
+        String output = outputCapture.toString();
+        assertThat("Client should connect without errors",
+                   !output.contains("Exception") && !output.contains("Error"));
+    }
+
+    @Test
+    @DisplayName("client sends message with proper formatting")
+    @Timeout(value = 10, unit = TimeUnit.SECONDS)
+    public void clientSendsProperlyFormattedMessage() throws Exception {
+        // Skip test if SocketClient class doesn't exist
+        assumeTrue(isSocketClientImplemented(), "SocketClient class must be implemented to run this test");
+        
+        startMockServer();
+        serverReady.await(5, TimeUnit.SECONDS);
+        
+        runSocketClientMain();
+        Thread.sleep(100);
+        
+        // Verify exact message content
+        String received = receivedMessage.get();
+        assertThat("Message should be exactly 'Hello, World!'",
+                   received, is("Hello, World!"));
+        assertThat("Message should not contain extra whitespace",
+                   received.trim(), is(received));
+    }
+
+    private void startMockServer() {
+        mockServerThread = new Thread(() -> {
+            try (ServerSocket serverSocket = new ServerSocket(4040)) {
+                // Signal that server is ready
+                serverReady.countDown();
+                
+                // Accept one connection and read the message
+                try (Socket clientSocket = serverSocket.accept();
+                     BufferedReader in = new BufferedReader(
+                         new InputStreamReader(clientSocket.getInputStream()))) {
+                    
+                    String message = in.readLine();
+                    receivedMessage.set(message);
+                }
+            } catch (IOException e) {
+                if (!Thread.currentThread().isInterrupted()) {
+                    e.printStackTrace();
+                }
+            }
+        });
+        
+        mockServerThread.setDaemon(true);
+        mockServerThread.start();
+    }
+
+    /**
+     * Helper method to run SocketClient.main() using reflection to avoid compilation dependency.
+     */
+    private void runSocketClientMain() throws Exception {
+        Class<?> clientClass = Class.forName("com.cbfacademy.SocketClient");
+        java.lang.reflect.Method mainMethod = clientClass.getMethod("main", String[].class);
+        mainMethod.invoke(null, (Object) new String[]{});
+    }
+
+    /**
+     * Helper method to check if SocketClient class is implemented.
+     * Tests will be skipped until the class exists.
+     */
+    static boolean isSocketClientImplemented() {
+        try {
+            Class.forName("com.cbfacademy.SocketClient");
+            return true; // Class exists, run tests
+        } catch (ClassNotFoundException e) {
+            return false; // Class doesn't exist, skip tests
+        }
+    }
+} 
diff --git a/src/test/java/com/cbfacademy/SocketServerTest.java b/src/test/java/com/cbfacademy/SocketServerTest.java
