jack-killian · devin-ai-integration · Jan 20, 2026
diff --git a/pom.xml b/pom.xml
@@ -17,11 +17,17 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.11.0</version>
                 <configuration>
-                    <source>17</source>
-                    <target>17</target>
+                    <source>21</source>
+                    <target>21</target>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.1.2</version>
+            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-shade-plugin</artifactId>
@@ -125,5 +131,18 @@
             <artifactId>compiler</artifactId>
             <version>0.9.14</version>
         </dependency>
+
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.10.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.5.0</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
-</project>
+</project>
diff --git a/src/test/java/com/deere/isg/examples/ApplicationTest.java b/src/test/java/com/deere/isg/examples/ApplicationTest.java
@@ -0,0 +1,94 @@
+package com.deere.isg.examples;
+
+import io.javalin.http.Context;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+class ApplicationTest {
+
+    private Application application;
+    private Context mockContext;
+
+    @BeforeEach
+    void setUp() {
+        application = new Application();
+        mockContext = mock(Context.class);
+    }
+
+    @Test
+    void testIndexRendersMainTemplate() {
+        application.index(mockContext);
+
+        ArgumentCaptor<String> templateCaptor = ArgumentCaptor.forClass(String.class);
+        ArgumentCaptor<Map> modelCaptor = ArgumentCaptor.forClass(Map.class);
+
+        verify(mockContext).render(templateCaptor.capture(), modelCaptor.capture());
+
+        assertEquals("main.mustache", templateCaptor.getValue());
+        assertTrue(modelCaptor.getValue().containsKey("settings"));
+    }
+
+    @Test
+    void testCallbackWithErrorQueryParam() {
+        when(mockContext.queryParam("error")).thenReturn("access_denied");
+        when(mockContext.queryParam("error_description")).thenReturn("User denied access");
+
+        java.lang.reflect.Method processCallbackMethod;
+        try {
+            processCallbackMethod = Application.class.getDeclaredMethod("processCallback", Context.class);
+            processCallbackMethod.setAccessible(true);
+            processCallbackMethod.invoke(application, mockContext);
+        } catch (Exception e) {
+            fail("Failed to invoke processCallback: " + e.getMessage());
+        }
+
+        ArgumentCaptor<String> templateCaptor = ArgumentCaptor.forClass(String.class);
+        ArgumentCaptor<Map> modelCaptor = ArgumentCaptor.forClass(Map.class);
+
+        verify(mockContext).render(templateCaptor.capture(), modelCaptor.capture());
+
+        assertEquals("error.mustache", templateCaptor.getValue());
+        assertTrue(modelCaptor.getValue().containsKey("error"));
+    }
+
+    @Test
+    void testRenderErrorMethod() throws Exception {
+        java.lang.reflect.Method renderErrorMethod = Application.class.getDeclaredMethod("renderError", Context.class, String.class);
+        renderErrorMethod.setAccessible(true);
+
+        String testErrorMessage = "Test error message";
+        renderErrorMethod.invoke(application, mockContext, testErrorMessage);
+
+        ArgumentCaptor<String> templateCaptor = ArgumentCaptor.forClass(String.class);
+        ArgumentCaptor<Map> modelCaptor = ArgumentCaptor.forClass(Map.class);
+
+        verify(mockContext).render(templateCaptor.capture(), modelCaptor.capture());
+
+        assertEquals("error.mustache", templateCaptor.getValue());
+        Map<String, String> model = modelCaptor.getValue();
+        assertEquals(testErrorMessage, model.get("error"));
+    }
+
+    @Test
+    void testRenderErrorWithNullMessage() throws Exception {
+        java.lang.reflect.Method renderErrorMethod = Application.class.getDeclaredMethod("renderError", Context.class, String.class);
+        renderErrorMethod.setAccessible(true);
+
+        renderErrorMethod.invoke(application, mockContext, null);
+
+        ArgumentCaptor<String> templateCaptor = ArgumentCaptor.forClass(String.class);
+        ArgumentCaptor<Map> modelCaptor = ArgumentCaptor.forClass(Map.class);
+
+        verify(mockContext).render(templateCaptor.capture(), modelCaptor.capture());
+
+        assertEquals("error.mustache", templateCaptor.getValue());
+        Map<String, String> model = modelCaptor.getValue();
+        assertEquals("", model.get("error"));
+    }
+}
diff --git a/src/test/java/com/deere/isg/examples/SettingsTest.java b/src/test/java/com/deere/isg/examples/SettingsTest.java
@@ -0,0 +1,123 @@
+package com.deere.isg.examples;
+
+import io.javalin.http.Context;
+import kong.unirest.core.json.JSONObject;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Base64;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+class SettingsTest {
+
+    private Settings settings;
+
+    @BeforeEach
+    void setUp() {
+        settings = new Settings();
+    }
+
+    @Test
+    void testDefaultValues() {
+        assertEquals("http://localhost:9090", Settings.SERVER_URL);
+        assertEquals("", settings.clientId);
+        assertEquals("", settings.clientSecret);
+        assertEquals("https://signin.johndeere.com/oauth2/aus78tnlaysMraFhC1t7/.well-known/oauth-authorization-server", settings.wellKnown);
+        assertEquals("https://sandboxapi.deere.com/platform", settings.apiUrl);
+        assertEquals("http://localhost:9090/callback", settings.callbackUrl);
+        assertEquals("openid profile offline_access ag1 eq1", settings.scopes);
+        assertNotNull(settings.state);
+    }
+
+    @Test
+    void testPopulateFromContext() {
+        Context mockContext = mock(Context.class);
+
+        when(mockContext.formParam("clientId")).thenReturn("test-client-id");
+        when(mockContext.formParam("clientSecret")).thenReturn("test-client-secret");
+        when(mockContext.formParam("wellKnown")).thenReturn("https://test.wellknown.url");
+        when(mockContext.formParam("callbackUrl")).thenReturn("http://localhost:8080/callback");
+        when(mockContext.formParam("scopes")).thenReturn("openid profile");
+        when(mockContext.formParam("state")).thenReturn("test-state-123");
+
+        settings.populate(mockContext);
+
+        assertEquals("test-client-id", settings.clientId);
+        assertEquals("test-client-secret", settings.clientSecret);
+        assertEquals("https://test.wellknown.url", settings.wellKnown);
+        assertEquals("http://localhost:8080/callback", settings.callbackUrl);
+        assertEquals("openid profile", settings.scopes);
+        assertEquals("test-state-123", settings.state);
+    }
+
+    @Test
+    void testGetBasicAuthHeader() {
+        settings.clientId = "myClientId";
+        settings.clientSecret = "myClientSecret";
+
+        String expectedHeader = Base64.getEncoder().encodeToString("myClientId:myClientSecret".getBytes());
+
+        assertEquals(expectedHeader, settings.getBasicAuthHeader());
+    }
+
+    @Test
+    void testUpdateTokenInfo() {
+        JSONObject tokenResponse = new JSONObject();
+        tokenResponse.put("id_token", "test-id-token");
+        tokenResponse.put("access_token", "test-access-token");
+        tokenResponse.put("refresh_token", "test-refresh-token");
+        tokenResponse.put("expires_in", 3600L);
+
+        settings.updateTokenInfo(tokenResponse);
+
+        assertEquals("test-id-token", settings.idToken);
+        assertEquals("test-access-token", settings.accessToken);
+        assertEquals("test-refresh-token", settings.refreshToken);
+        assertEquals(3600L, settings.exp);
+    }
+
+    @Test
+    void testUpdateTokenInfoWithMissingFields() {
+        JSONObject tokenResponse = new JSONObject();
+        tokenResponse.put("access_token", "only-access-token");
+
+        settings.updateTokenInfo(tokenResponse);
+
+        assertEquals("only-access-token", settings.accessToken);
+        assertEquals("", settings.idToken);
+        assertEquals("", settings.refreshToken);
+    }
+
+    @Test
+    void testGetAccessTokenDetailsReturnsNullWhenNoToken() {
+        settings.accessToken = null;
+        assertNull(settings.getAccessTokenDetails());
+
+        settings.accessToken = "";
+        assertNull(settings.getAccessTokenDetails());
+    }
+
+    @Test
+    void testGetExpirationReturnsNullWhenNoExp() {
+        settings.exp = null;
+        assertNull(settings.getExpiration());
+    }
+
+    @Test
+    void testGetExpirationReturnsDateTimeWhenExpSet() {
+        settings.exp = 3600L;
+        String expiration = settings.getExpiration();
+
+        assertNotNull(expiration);
+        assertTrue(expiration.contains("T"));
+    }
+
+    @Test
+    void testStateIsUUID() {
+        Settings newSettings = new Settings();
+        assertNotNull(newSettings.state);
+        assertDoesNotThrow(() -> java.util.UUID.fromString(newSettings.state));
+    }
+}