Remote enquirer

src/main/java/us/muit/fs/a4i/model/remote/ExtraccionMetricas.java

@@ -0,0 +1,104 @@
+package us.muit.fs.a4i.model.remote;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+
+import org.kohsuke.github.GHIssue;
+import org.kohsuke.github.GHRepository;
+import org.kohsuke.github.GitHub;
+import org.kohsuke.github.GitHubBuilder;
+
+import us.muit.fs.a4i.exceptions.MetricException;
+import us.muit.fs.a4i.model.entities.ReportItemI;
+import us.muit.fs.a4i.model.entities.ReportItem.ReportItemBuilder;
+import us.muit.fs.a4i.model.entities.Report;
+import us.muit.fs.a4i.model.entities.ReportI;
+
+
+public class ExtraccionMetricas implements RemoteEnquirer {
+
+    private static final List<String> SUPPORTED_METRICS = Arrays.asList("totalIssues", "labeledIssues");
+
+	@Override
+	public ReportI buildReport(String entityId) {
+        try {
+            Report report = new Report(ReportI.ReportType.REPOSITORY, entityId);
+
+            for (String metric : getAvailableMetrics()) {
+                ReportItemI<?> item = getMetric(metric, entityId);
+                report.addMetric(item);
+            }
+
+            return report;
+
+        } catch (MetricException e) {
+            throw new RuntimeException("Error al construir el informe: " + e.getMessage(), e);
+        }
+	}
+
+	@Override
+    public ReportItemI getMetric(String metricName, String entityId) throws MetricException {
+        if (!SUPPORTED_METRICS.contains(metricName)) {
+            throw new MetricException("Métrica no soportada: " + metricName);
+        }
+
+        if (!entityId.contains("/")) {
+            entityId = entityId + "/Audit4Improve-API";
+        }
+
+        try {
+        	GitHub github;
+        	String token = System.getenv("GITHUB_PACKAGES");
+
+        	if (token != null && !token.isEmpty()) {
+        	    github = new GitHubBuilder().withOAuthToken(token).build();
+        	} else {
+        	    github = GitHub.connectAnonymously();
+        	} 
+            GHRepository repo = github.getRepository(entityId);
+
+            int total = 0;
+            int etiquetados = 0;
+
+            for (GHIssue issue : repo.getIssues(org.kohsuke.github.GHIssueState.OPEN)) {
+                if (!issue.isPullRequest()) {
+                    total++;
+                    if (!issue.getLabels().isEmpty()) {
+                        etiquetados++;
+                    }
+                }
+            }
+
+            if (metricName.equals("totalIssues")) {
+                return new ReportItemBuilder<Double>("totalIssues", (double) total)
+                        .source("GitHub")
+                        .build();
+            } else if (metricName.equals("labeledIssues")) {
+                return new ReportItemBuilder<Double>("labeledIssues", (double) etiquetados)
+                        .source("GitHub")
+                        .build();
+            } else {
+                throw new MetricException("Métrica desconocida: " + metricName);
+            }
+
+        } catch (IOException e) {
+        	System.err.println("IOException: " + e.getMessage());
+            throw new MetricException("Error al conectar con GitHub: " + e.getMessage());
+        } catch (Exception e) {
+        	System.err.println("Exception: " + e.getMessage());
+            throw new MetricException("Error al construir ReportItem: " + e.getMessage());
+        }
+    }
+
+	@Override
+	public List<String> getAvailableMetrics() {
+		return SUPPORTED_METRICS;
+	}
+
+	@Override
+	public RemoteType getRemoteType() {
+		return RemoteType.GITHUB;
+	}
+
+}

src/main/resources/a4iDefault.json

@@ -127,8 +127,8 @@
 			"unit": "issues"
 		},
 		{
-			"name": "issues",
-			"type": "java.lang.Integer",
+			"name": "totalIssues",
+			"type": "java.lang.Double",
 			"description": "Tareas totales",
 			"unit": "issues"
 		},
@@ -298,6 +298,12 @@
 			"description": "Indicador de conformidad con las convenciones en el repo",
 			"unit": "ratio"
 		},
+		{
+  			"name": "labeledIssues",
+  			"type": "java.lang.Double",
+ 			"description": "Número de issues con al menos una etiqueta",
+  			"unit": "issues"
+		},
 		{
 			"name": "teamsBalanceI",
 			"type": "java.lang.Double",

src/test/java/us/muit/fs/a4i/test/model/remote/RemoteEnquirerTest.java

@@ -0,0 +1,86 @@
+package us.muit.fs.a4i.test.model.remote;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import java.util.logging.Logger;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import us.muit.fs.a4i.exceptions.MetricException;
+import us.muit.fs.a4i.model.entities.ReportItem;
+import us.muit.fs.a4i.model.entities.ReportItemI;
+import us.muit.fs.a4i.model.remote.ExtraccionMetricas;
+import us.muit.fs.a4i.model.remote.GitHubRepositoryEnquirer;
+import us.muit.fs.a4i.model.remote.RemoteEnquirer;
+
+class RemoteEnquirerTest {
+
+    private static Logger log = Logger.getLogger(RemoteEnquirerTest.class.getName());
+
+    private RemoteEnquirer enquirer = new ExtraccionMetricas();  // Asegúrate que esta clase existe y está implementada
+
+
+    // Test que certifica que se puede obtener la métrica "totalIssues" (el resultado no es nulo,
+    // el nombre de la métrica coincide al completo y el valor es de tipo numérico).
+
+    @Test
+    void testGetTotalIssuesMetric() throws MetricException {
+        String repoId = "MIT-FS"; // Reemplazar con un repositorio válido de prueba
+
+        ReportItemI metric = enquirer.getMetric("totalIssues", repoId);
+        assertNotNull(metric, "La métrica 'totalIssues' no debe ser null");
+        assertEquals("totalIssues", metric.getName());
+        assertTrue(metric.getValue() instanceof Number, "El valor debe ser numérico");
+
+        log.info("Total Issues: " + metric.getValue());
+    }
+
+    // Test que certifica que se puede obtener la métrica "labeledIssues" (el resultado no es nulo,
+    // el nombre de la métrica coincide al completo y el valor es de tipo numérico).
+
+    @Test
+    void testGetLabeledIssuesMetric() throws MetricException {
+        String repoId = "MIT-FS";
+
+        ReportItemI metric = enquirer.getMetric("labeledIssues", repoId);
+        assertNotNull(metric, "La métrica 'labeledIssues' no debe ser null");
+        assertEquals("labeledIssues", metric.getName());
+        assertTrue(metric.getValue() instanceof Number, "El valor debe ser numérico");
+
+        log.info("Issues con etiquetas: " + metric.getValue());
+    }
+
+
+    // Test que verifica que el objeto informa correctamente de las métricas que soporta (que
+    // la lista no es nula y que dentro de las posibilidades están "totalIssues" y "labeledIssues")
+
+    @Test
+    void testGetAvailableMetrics() {
+        List<String> metrics = enquirer.getAvailableMetrics();
+        assertNotNull(metrics);
+        assertTrue(metrics.contains("totalIssues"), "Debe contener la métrica 'totalIssues'");
+        assertTrue(metrics.contains("labeledIssues"), "Debe contener la métrica 'labeledIssues'");
+    }
+
+    // Test que intenta pedir una métrica que no existe, para comprobar que la excepción salta como se espera
+
+
+    @Test
+    void testInvalidMetricThrowsException() {
+        String repoId = "Isabel-Roman";
+
+        assertThrows(MetricException.class, () -> {
+            enquirer.getMetric("nonExistentMetric", repoId);
+        });
+    }
+
+
+    // Test que verifica que el tipo de la clase está correctamente identificado como GITHUB
+
+    @Test
+    void testGetRemoteType() {
+        assertEquals(RemoteEnquirer.RemoteType.GITHUB, enquirer.getRemoteType());
+    }
+}