Test server endpoints

pom.xml

@@ -112,6 +112,12 @@
             <artifactId>slf4j-api</artifactId>
             <version>2.0.13</version>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-params</artifactId>
+            <version>5.10.0</version>
+            <scope>test</scope>
+        </dependency>
 
 
     </dependencies>

src/main/java/Main.java

@@ -31,7 +31,7 @@ public static void main(String[] args) {
             throw new RuntimeException(e);
         }
 
-        new Server(endpointProvider).start(8080);
+        new Server(endpointProvider).start();
 
         try {
             SubmissionService.reRunSubmissionsInQueue();

src/main/java/edu/byu/cs/controller/UserController.java

@@ -18,16 +18,16 @@
 import static spark.Spark.halt;
 
 public class UserController {
-    public static final Route repoPatch = (req, res) -> {
+    public static final Route setRepoUrl = (req, res) -> {
         User user = req.session().attribute("user");
-        applyRepoPatch(user.netId(), null, req, res);
+        setRepoUrl(user.netId(), null, req, res);
         return "Successfully updated repoUrl";
     };
 
-    public static final Route repoPatchAdmin = (req, res) -> {
+    public static final Route setRepoUrlAdmin = (req, res) -> {
         User admin = req.session().attribute("user");
         String studentNetId = req.params(":netId");
-        applyRepoPatch(studentNetId, admin.netId(), req, res);
+        setRepoUrl(studentNetId, admin.netId(), req, res);
         return "Successfully updated repoUrl for user: " + studentNetId;
     };
 
@@ -52,7 +52,7 @@ public class UserController {
         return Serializer.serialize(updates);
     };
 
-    private static void applyRepoPatch(String studentNetId, String adminNetId, Request req, Response res) {
+    private static void setRepoUrl(String studentNetId, String adminNetId, Request req, Response res) {
         JsonObject jsonObject = new Gson().fromJson(req.body(), JsonObject.class);
         String repoUrl = new Gson().fromJson(jsonObject.get("repoUrl"), String.class);
 

src/main/java/edu/byu/cs/server/Server.java

@@ -4,6 +4,7 @@
 import edu.byu.cs.server.endpointprovider.EndpointProvider;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import spark.Spark;
 
 import static spark.Spark.*;
 
@@ -16,12 +17,20 @@ public Server(EndpointProvider endpointProvider) {
         this.provider = endpointProvider;
     }
 
+    public int start() {
+        return start(0);
+    }
+
     public int start(int desiredPort) {
         int chosenPort = setupEndpoints(desiredPort);
         LOGGER.info("Server started on port {}", chosenPort);
         return chosenPort;
     }
 
+    public void stop() {
+        Spark.stop();
+    }
+
     private int setupEndpoints(int port) {
         port(port);
 
@@ -45,7 +54,7 @@ private int setupEndpoints(int port) {
                 if (!req.requestMethod().equals("OPTIONS")) provider.verifyAuthenticatedMiddleware().handle(req, res);
             });
 
-            patch("/repo", provider.repoPatch());
+            post("/repo", provider.setRepoUrl());
 
             get("/submit", provider.submitGet());
             post("/submit", provider.submitPost());
@@ -64,7 +73,7 @@ private int setupEndpoints(int port) {
                     if (!req.requestMethod().equals("OPTIONS")) provider.verifyAdminMiddleware().handle(req, res);
                 });
 
-                patch("/repo/:netId", provider.repoPatchAdmin());
+                post("/repo/:netId", provider.setRepoUrlAdmin());
 
                 get("/repo/history", provider.repoHistoryAdminGet());
 
@@ -118,6 +127,8 @@ private int setupEndpoints(int port) {
 
         init();
 
+        awaitInitialization();
+
         return port();
     }
 }

src/main/java/edu/byu/cs/server/endpointprovider/EndpointProvider.java

@@ -58,7 +58,7 @@ public interface EndpointProvider {
 
     // UserController
 
-    Route repoPatch();
-    Route repoPatchAdmin();
+    Route setRepoUrl();
+    Route setRepoUrlAdmin();
     Route repoHistoryAdminGet();
 }

src/main/java/edu/byu/cs/server/endpointprovider/EndpointProviderImpl.java

@@ -13,7 +13,7 @@ public class EndpointProviderImpl implements EndpointProvider {
     public Filter beforeAll() {
         return (request, response) -> {
             response.header("Access-Control-Allow-Headers", "Authorization,Content-Type");
-            response.header("Access-Control-Allow-Methods", "GET,PUT,POST,DELETE,PATCH,OPTIONS");
+            response.header("Access-Control-Allow-Methods", "GET,PUT,POST,DELETE,OPTIONS");
             response.header("Access-Control-Allow-Credentials", "true");
             response.header("Access-Control-Allow-Origin", ApplicationProperties.frontendUrl());
         };
@@ -195,13 +195,13 @@ public Route submissionsReRunPost() {
     // UserController
 
     @Override
-    public Route repoPatch() {
-        return UserController.repoPatch;
+    public Route setRepoUrl() {
+        return UserController.setRepoUrl;
     }
 
     @Override
-    public Route repoPatchAdmin() {
-        return UserController.repoPatchAdmin;
+    public Route setRepoUrlAdmin() {
+        return UserController.setRepoUrlAdmin;
     }
 
     @Override

src/test/java/edu/byu/cs/server/ServerTest.java

@@ -0,0 +1,151 @@
+package edu.byu.cs.server;
+
+import edu.byu.cs.server.endpointprovider.MockEndpointProvider;
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.InOrder;
+
+import java.io.IOException;
+import java.util.*;
+import java.util.stream.Stream;
+
+import static org.mockito.Mockito.*;
+
+class ServerTest {
+    private static TestServerFacade serverFacade;
+    private static Server server;
+
+    private static final MockEndpointProvider mockedMockProvider = spy(new MockEndpointProvider());
+
+    public static Stream<Arguments> getPathParamEndpoints() {
+        return Stream.of(
+                Arguments.of( "GET", "/api/submission", "submissionXGet", ":phase"),
+                Arguments.of( "GET", "/api/admin/analytics/commit", "commitAnalyticsGet", ":option"),
+                Arguments.of("POST", "/api/admin/repo", "setRepoUrlAdmin", ":netid"),
+                Arguments.of( "GET", "/api/admin/honorChecker/zip", "honorCheckerZipGet", ":section"),
+                Arguments.of( "GET", "/api/admin/submissions/latest", "latestSubmissionsGet", ":count"),
+                Arguments.of( "GET", "/api/admin/submissions/student", "studentSubmissionsGet", ":netid")
+        );
+        // api/admin/config/penalties
+    }
+
+    public static Stream<Arguments> getEndpoints() {
+        return Stream.of(
+                Arguments.of( "GET", "/auth/callback", "callbackGet"),
+                Arguments.of( "GET", "/auth/login", "loginGet"),
+                Arguments.of("POST", "/auth/logout", "logoutPost"),
+
+                Arguments.of( "GET", "/api/config", "getConfigStudent"),
+                Arguments.of( "GET", "/api/latest", "latestSubmissionForMeGet"),
+                Arguments.of( "GET", "/api/me", "meGet"),
+                Arguments.of("POST", "/api/repo", "setRepoUrl"),
+                Arguments.of( "GET", "/api/submission", "submissionXGet"),
+                Arguments.of( "GET", "/api/submit", "submitGet"),
+                Arguments.of("POST", "/api/submit", "submitPost"),
+
+                Arguments.of( "GET", "/api/admin/config", "getConfigAdmin"),
+                Arguments.of("POST", "/api/admin/config/banner", "updateBannerMessage"),
+                Arguments.of("POST", "/api/admin/config/courseIds", "updateCourseIdsPost"),
+                Arguments.of( "GET", "/api/admin/config/courseIds", "updateCourseIdsUsingCanvasGet"),
+                Arguments.of("POST", "/api/admin/config/penalties", "updatePenalties"),
+                Arguments.of("POST", "/api/admin/config/phases", "updateLivePhases"),
+                Arguments.of("POST", "/api/admin/config/phases/shutdown", "scheduleShutdown"),
+
+                Arguments.of( "GET", "/api/admin/submissions/active", "submissionsActiveGet"),
+                Arguments.of("POST", "/api/admin/submissions/approve", "approveSubmissionPost"),
+                Arguments.of( "GET", "/api/admin/submissions/latest", "latestSubmissionsGet"),
+                Arguments.of("POST", "/api/admin/submissions/rerun", "submissionsReRunPost"),
+                Arguments.of("POST", "/api/admin/submit", "adminRepoSubmitPost"),
+
+                Arguments.of( "GET", "/api/admin/analytics/commit", "commitAnalyticsGet"),
+                Arguments.of( "GET", "/api/admin/repo/history", "repoHistoryAdminGet"),
+                Arguments.of( "GET", "/api/admin/sections", "sectionsGet"),
+                Arguments.of( "GET", "/api/admin/test_mode", "testModeGet"),
+                Arguments.of( "GET", "/api/admin/users", "usersGet")
+                );
+    }
+
+    @AfterAll
+    static void stopServer() {
+        server.stop();
+    }
+
+    @BeforeAll
+    public static void init() {
+        server = new Server(mockedMockProvider);
+        int port = server.start();
+        System.out.println("Started test HTTP server on " + port);
+
+        serverFacade = new TestServerFacade("localhost", port);
+    }
+
+    @AfterEach
+    public void tearDown() {
+        reset(mockedMockProvider);
+    }
+
+    @ParameterizedTest
+    @MethodSource("getEndpoints")
+    public void verifyEndpointCallsItsHandlersExactlyOnceInOrder(String method, String path, String endpointName) throws IOException {
+        // When
+        serverFacade.makeRequest(method, path);
+
+        InOrder inOrder = inOrder(mockedMockProvider);
+
+        // Then
+        inOrder.verify(mockedMockProvider, times(1)).runHandler("beforeAll");
+        this.verifyInOrder_authenticationMiddleware(path, inOrder);
+        inOrder.verify(mockedMockProvider, times(1)).runHandler(endpointName);
+        inOrder.verify(mockedMockProvider, times(1)).runHandler("afterAll");
+    }
+
+    @ParameterizedTest
+    @MethodSource("getPathParamEndpoints")
+    public void verifyPathParameterHasAValueWhenGivenOne(String method, String path, String endpointName,
+            String pathParamName) throws IOException {
+        // Given
+        String fullPath = path + "/testParamValue";
+
+        // When
+        serverFacade.makeRequest(method, fullPath);
+
+        // Then
+        verify(mockedMockProvider, times(1)).hasPathParam(endpointName, pathParamName, "testParamValue");
+    }
+
+    private void verifyInOrder_authenticationMiddleware(String path, InOrder inOrder) {
+        List<String> pathNodes = Arrays.stream(path.split("/")).toList();
+
+        if (!pathNodes.contains("api")) {
+            return;
+        }
+
+        if (!pathNodes.contains("auth")) {
+            // Requires authentication
+            inOrder.verify(mockedMockProvider, times(1)).runHandler("verifyAuthenticatedMiddleware");
+        }
+
+        if (pathNodes.contains("admin")) {
+            // Requires admin
+            inOrder.verify(mockedMockProvider, times(1)).runHandler("verifyAdminMiddleware");
+        }
+    }
+
+    @Test
+    void nonexistent_GET_endpoint_calls_beforeAll_then_defaultGet_then_afterAll_exactly_once_in_order() throws IOException {
+        serverFacade.makeRequest("GET", "/iDoNotExist");
+
+        // Verify they ran in order
+        InOrder inOrder = inOrder(mockedMockProvider);
+        inOrder.verify(mockedMockProvider).runHandler("beforeAll");
+        inOrder.verify(mockedMockProvider).runHandler("defaultGet");
+        inOrder.verify(mockedMockProvider).runHandler("afterAll");
+
+        // Verify they only ran once
+        verify(mockedMockProvider, times(1)).runHandler("beforeAll");
+        verify(mockedMockProvider, times(1)).runHandler("defaultGet");
+        verify(mockedMockProvider, times(1)).runHandler("afterAll");
+    }
+}