Treat warnings as errors (#5)

* adr: Treat warnings as errors

* build: Treat warnings as errors

* fix: Compilation warnings

buildSrc/src/main/kotlin/org.projectcheckins.java-common-conventions.gradle.kts

@@ -35,4 +35,10 @@ tasks.check {
 java {
     sourceCompatibility = JavaVersion.toVersion("21")
     targetCompatibility = JavaVersion.toVersion("21")
-}
+}
+
+tasks.withType<JavaCompile> {
+	val compilerArgs = options.compilerArgs
+	compilerArgs.add("-Werror")
+	compilerArgs.add("-Xlint:all,-serial,-processing")
+}

doc/adr/0018-treat-warnings-as-errors.md

@@ -0,0 +1,36 @@
+# 18. Treat Warnings as Errors
+
+Date: 2024-02-28
+Creator: Guillermo Calvo
+Reviewer: Sergio del Amo
+
+## Status
+
+Accepted
+
+
+## Context
+
+We want to avoid as many bugs as possible.
+
+Some compilation warnings rarely cause any problems, but some others can lead to program malfunction.
+
+There are codebases in which a regular compilation generates a lot of "known warnings" that have to be ignored.
+In those scenarios, new warnings tend to be completely ignored.
+
+We'd like to make sure that new compilation warnings are looked into.
+
+While a sensible correction of the offending code is the most desirable outcome of the research,
+it is possible that the specific warning has to be suppressed via Java annotations or a similar mechanism.
+In any case, solving or suppressing each warning must be the result of a thoughtful decision.
+
+
+## Decision
+
+We will treat all compilation warnings as errors.
+
+
+## Consequences
+
+- The build will fail if changes introduce any compilation warnings.
+- Adopting this philosophy early in the project will make it easier to maintain overall quality throughout development.

http/src/main/java/org/projectcheckins/http/exceptionshandlers/QuestionNotFoundExceptionHandler.java

@@ -9,28 +9,28 @@
 import io.micronaut.http.server.exceptions.ExceptionHandler;
 import io.micronaut.http.server.exceptions.response.ErrorContext;
 import io.micronaut.http.server.exceptions.response.ErrorResponseProcessor;
-import io.micronaut.views.ModelAndView;
 import io.micronaut.views.ViewsRenderer;
 import jakarta.inject.Singleton;
+import java.util.Map;
 import org.projectcheckins.core.exceptions.QuestionNotFoundException;
 
 import java.util.Collections;
 
 @Produces
 @Singleton
-public class QuestionNotFoundExceptionHandler implements ExceptionHandler<QuestionNotFoundException, HttpResponse> {
+public class QuestionNotFoundExceptionHandler implements ExceptionHandler<QuestionNotFoundException, HttpResponse<?>> {
 
     private final ErrorResponseProcessor<?> errorResponseProcessor;
-    private final ViewsRenderer viewsRenderer;
+    private final ViewsRenderer<Map<?, ?>, HttpRequest<?>> viewsRenderer;
 
     public QuestionNotFoundExceptionHandler(ErrorResponseProcessor<?> errorResponseProcessor,
-                                            ViewsRenderer viewsRenderer) {
+                                            ViewsRenderer<Map<?, ?>, HttpRequest<?>> viewsRenderer) {
         this.errorResponseProcessor = errorResponseProcessor;
         this.viewsRenderer = viewsRenderer;
     }
 
     @Override
-    public HttpResponse<?> handle(HttpRequest request, QuestionNotFoundException e) {
+    public HttpResponse<?> handle(@SuppressWarnings("rawtypes") HttpRequest request, QuestionNotFoundException e) {
         if (acceptHtml(request)) {
             Writable writable = viewsRenderer.render("error/404", Collections.emptyMap(), request);
             return HttpResponse.notFound(writable)

security/src/test/java/org/projectcheckins/security/DelegatingAuthenticationProviderTest.java

@@ -29,7 +29,7 @@ class DelegatingAuthenticationProviderTest {
     private static final String WRONG_PASSWORD = "wrongpassword";
 
     @Test
-    void testUserNotFoundAuthentication(DelegatingAuthenticationProvider authenticationProvider) {
+    void testUserNotFoundAuthentication(DelegatingAuthenticationProvider<?> authenticationProvider) {
         UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(NOT_FOUND_EMAIL, CORRECT_PASSWORD);
         assertThat(authenticationProvider.authenticate(null, credentials))
             .matches(not(AuthenticationResponse::isAuthenticated))
@@ -39,7 +39,7 @@ void testUserNotFoundAuthentication(DelegatingAuthenticationProvider authenticat
     }
 
     @Test
-    void testUserCredentialsDontMatch(DelegatingAuthenticationProvider authenticationProvider) {
+    void testUserCredentialsDontMatch(DelegatingAuthenticationProvider<?> authenticationProvider) {
         UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(FOUND_EMAIL, WRONG_PASSWORD);
         assertThat(authenticationProvider.authenticate(null, credentials))
             .matches(not(AuthenticationResponse::isAuthenticated))
@@ -49,7 +49,7 @@ void testUserCredentialsDontMatch(DelegatingAuthenticationProvider authenticatio
     }
 
     @Test
-    void testUserFoundAuthentication(DelegatingAuthenticationProvider authenticationProvider) {
+    void testUserFoundAuthentication(DelegatingAuthenticationProvider<?> authenticationProvider) {
         UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(FOUND_EMAIL, CORRECT_PASSWORD);
         assertThat(authenticationProvider.authenticate(null, credentials))
             .matches(AuthenticationResponse::isAuthenticated)