Feature/add unit tests

pom.xml

@@ -19,9 +19,10 @@
         <maven.compiler.release>17</maven.compiler.release>
         <maven.compiler.target>17</maven.compiler.target>
         <maven.compiler.source>17</maven.compiler.source>
-        <sonar.projectKey>elysium</sonar.projectKey>
-        <sonar.projectName>elysium</sonar.projectName> 
-        <sonar.host.url>http://localhost:9000</sonar.host.url>
+        <sonar.organization>ander-ECI</sonar.organization>
+        <sonar.projectKey>Prometeo-Back</sonar.projectKey>
+        <sonar.projectName>Prometeo-Back</sonar.projectName> 
+        <sonar.host.url>https://sonarcloud.io</sonar.host.url>
         <sonar.coverage.jacoco.xmlReportPaths>target/site/jacoco/jacoco.xml</sonar.coverage.jacoco.xmlReportPaths>
         <sonar.coverage.exclusions>src//configurators/*</sonar.coverage.exclusions>
         <spring-cloud.version>2024.0.1</spring-cloud.version>

src/test/java/edu/eci/cvds/prometeo/controller/UserControllerTest.java

@@ -2,6 +2,7 @@
 
 import edu.eci.cvds.prometeo.dto.*;
 import edu.eci.cvds.prometeo.model.*;
+import edu.eci.cvds.prometeo.model.enums.ReportFormat;
 import edu.eci.cvds.prometeo.repository.RoutineExerciseRepository;
 import edu.eci.cvds.prometeo.repository.RoutineRepository;
 import edu.eci.cvds.prometeo.service.*;
@@ -12,7 +13,9 @@
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@@ -47,6 +50,9 @@ class UserControllerTest {
     @Mock
     private GymSessionService gymSessionService;
 
+    @Mock
+    private ReportService reportService;
+
     @InjectMocks
     private UserController userController;
 
@@ -1432,4 +1438,105 @@ public void testLambdaCreateCustomRoutine() {
         // Verify the lambda did the transformation correctly
         verify(userService).createCustomRoutine(eq(userId), any(Routine.class));
     }
+
+    @Test
+    public void testGetUserProgressReport() {
+        // Prepare test data
+        UUID userId = UUID.randomUUID();
+        ReportFormat format = ReportFormat.PDF;
+        byte[] mockReportData = "mock report data".getBytes();
+
+        when(reportService.generateUserProgressReport(userId, format)).thenReturn(mockReportData);
+
+        ResponseEntity<byte[]> response = userController.getUserProgressReport(userId, format);
+
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals(mockReportData, response.getBody());
+
+        // Verify the correct content type is set for PDF
+        HttpHeaders headers = response.getHeaders();
+        assertEquals(MediaType.APPLICATION_PDF, headers.getContentType());
+        assertTrue(headers.getContentDisposition().toString().contains("attachment"));
+        assertTrue(headers.getContentDisposition().toString().contains("user_progress_report.pdf"));
+
+        verify(reportService).generateUserProgressReport(userId, format);
+    }
+
+    @Test
+    public void testGetGymUsageReport() {
+        // Prepare test data
+        LocalDate startDate = LocalDate.now().minusMonths(1);
+        LocalDate endDate = LocalDate.now();
+        ReportFormat format = ReportFormat.XLSX;
+        byte[] mockReportData = "mock gym usage report data".getBytes();
+
+        when(reportService.generateGymUsageReport(startDate, endDate, format)).thenReturn(mockReportData);
+
+        ResponseEntity<byte[]> response = userController.getGymUsageReport(startDate, endDate, format);
+
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals(mockReportData, response.getBody());
+
+        // Verify the correct content type is set for XLSX
+        HttpHeaders headers = response.getHeaders();
+        assertEquals(MediaType.parseMediaType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"), 
+                     headers.getContentType());
+        assertTrue(headers.getContentDisposition().toString().contains("attachment"));
+        assertTrue(headers.getContentDisposition().toString().contains("gym_usage_report.xlsx"));
+
+        verify(reportService).generateGymUsageReport(startDate, endDate, format);
+    }
+
+    @Test
+    public void testGetAttendanceReport() {
+        // Prepare test data
+        LocalDate startDate = LocalDate.now().minusMonths(1);
+        LocalDate endDate = LocalDate.now();
+        ReportFormat format = ReportFormat.CSV;
+        byte[] mockReportData = "date,attendance\n2023-01-01,42".getBytes();
+
+        when(reportService.getAttendanceStatistics(startDate, endDate, format)).thenReturn(mockReportData);
+
+        ResponseEntity<byte[]> response = userController.getAttendanceReport(startDate, endDate, format);
+
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals(mockReportData, response.getBody());
+
+        // Verify the correct content type is set for CSV
+        HttpHeaders headers = response.getHeaders();
+        assertEquals(MediaType.parseMediaType("text/csv"), headers.getContentType());
+        assertTrue(headers.getContentDisposition().toString().contains("attachment"));
+        assertTrue(headers.getContentDisposition().toString().contains("attendance_report.csv"));
+
+        verify(reportService).getAttendanceStatistics(startDate, endDate, format);
+    }
+
+    @Test
+    public void testBuildResponseWithJSON() {
+        // Use reflection to access the private method
+        ReportFormat format = ReportFormat.JSON;
+        byte[] content = "{\"data\": \"test\"}".getBytes();
+        String filenameBase = "test_report";
+
+        // Create a method that directly invokes buildResponse using reflection
+        ResponseEntity<byte[]> response = null;
+        try {
+            java.lang.reflect.Method buildResponseMethod = UserController.class.getDeclaredMethod(
+                "buildResponse", byte[].class, ReportFormat.class, String.class);
+            buildResponseMethod.setAccessible(true);
+            response = (ResponseEntity<byte[]>) buildResponseMethod.invoke(userController, content, format, filenameBase);
+        } catch (Exception e) {
+            fail("Failed to invoke buildResponse method: " + e.getMessage());
+        }
+
+        assertNotNull(response);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals(content, response.getBody());
+
+        // Verify JSON content type
+        HttpHeaders headers = response.getHeaders();
+        assertEquals(MediaType.APPLICATION_JSON, headers.getContentType());
+        assertTrue(headers.getContentDisposition().toString().contains("attachment"));
+        assertTrue(headers.getContentDisposition().toString().contains("test_report.json"));
+    }
 }

src/test/java/edu/eci/cvds/prometeo/model/enums/ReportFormatTest.java

@@ -0,0 +1,41 @@
+package edu.eci.cvds.prometeo.model.enums;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+
+public class ReportFormatTest {
+
+    @Test
+    public void testEnumValues() {
+        // Test that the enum has the expected number of values
+        assertEquals(4, ReportFormat.values().length);
+
+        // Test that each expected value exists
+        assertNotNull(ReportFormat.CSV);
+        assertNotNull(ReportFormat.PDF);
+        assertNotNull(ReportFormat.XLSX);
+        assertNotNull(ReportFormat.JSON);
+    }
+
+    @Test
+    public void testValueOf() {
+        // Test that valueOf returns the correct enum value for each expected string
+        assertEquals(ReportFormat.CSV, ReportFormat.valueOf("CSV"));
+        assertEquals(ReportFormat.PDF, ReportFormat.valueOf("PDF"));
+        assertEquals(ReportFormat.XLSX, ReportFormat.valueOf("XLSX"));
+        assertEquals(ReportFormat.JSON, ReportFormat.valueOf("JSON"));
+    }
+
+
+    @Test
+    public void testEnumValuesContent() {
+        // Test that values() returns all expected values
+        ReportFormat[] formats = ReportFormat.values();
+
+        assertEquals(ReportFormat.CSV, formats[0]);
+        assertEquals(ReportFormat.PDF, formats[1]);
+        assertEquals(ReportFormat.XLSX, formats[2]);
+        assertEquals(ReportFormat.JSON, formats[3]);
+    }
+}