diff --git a/.codecov.yml b/.codecov.yml index 31710dfe..6101accb 100644 --- a/.codecov.yml +++ b/.codecov.yml @@ -2,4 +2,6 @@ coverage: round: up range: 0..100 precision: 2 - +ignore: + - "src/main/java/ubu/gii/dass/c01/Client.java" + - "src/main/java/ubu/gii/dass/c01/Reusable.java" \ No newline at end of file diff --git a/.github/workflows/Javamaven.yml b/.github/workflows/Javamaven.yml new file mode 100644 index 00000000..77b67a44 --- /dev/null +++ b/.github/workflows/Javamaven.yml @@ -0,0 +1,35 @@ +# This workflow will build a Java project with Maven, and cache/restore any dependencies to improve the workflow execution time +# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-maven + +# This workflow uses actions that are not certified by GitHub. +# They are provided by a third-party and are governed by +# separate terms of service, privacy policy, and support +# documentation. + +name: Java CI with Maven + +on: + push: + branches: [ "master" ] + pull_request: + branches: [ "master" ] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + - name: Set up JDK 17 + uses: actions/setup-java@v4 + with: + java-version: '17' + distribution: 'temurin' + cache: maven + - name: Build with Maven + run: mvn -B package --file pom.xml + - name: Upload coverage reports to Codecov + uses: codecov/codecov-action@v5 + with: + token: ${{ secrets.CODECOV_TOKEN }} diff --git a/.settings/org.eclipse.core.resources.prefs b/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 00000000..f9fe3459 --- /dev/null +++ b/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,4 @@ +eclipse.preferences.version=1 +encoding//src/main/java=UTF-8 +encoding//src/test/java=UTF-8 +encoding/=UTF-8 diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 00000000..2f5cc74c --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,8 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore +org.eclipse.jdt.core.compiler.release=disabled +org.eclipse.jdt.core.compiler.source=1.8 diff --git a/.settings/org.eclipse.m2e.core.prefs b/.settings/org.eclipse.m2e.core.prefs new file mode 100644 index 00000000..f897a7f1 --- /dev/null +++ b/.settings/org.eclipse.m2e.core.prefs @@ -0,0 +1,4 @@ +activeProfiles= +eclipse.preferences.version=1 +resolveWorkspaceProjects=true +version=1 diff --git a/README.md b/README.md index 47c98e44..d5a138c3 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,75 @@ poolobject ========== +Partimos de un codigo dado que crea instancias unicas (Singleton). +Sobre ella se pretende realizar buenas practicas de desarrollo: testing, ci y metricas. -Java code example of creational design pattern pool object - -Workshop to use good practices in software development: testing, ci and measurement. - -Authors: +Autores de clases: - Carlos Lopez Nozal - Jesus Alonso Abad + +Autores de los test: +- Carlos Venero Ortega +- Iván Fernández Pardo +- Pablo Alonso Cameselle +- Mario Flores Cano + +### BADGES +Insignias de consecución de objetivos. +[![codecov](https://codecov.io/gh/cvo0004/poolobject/branch/master/graph/badge.svg?token=8GAMWS6JRQ)](https://codecov.io/gh/cvo0004/poolobject) + +# **OBJETIVOS** +El objetivo de esta actividad es que nos familiricemos con un proyecto de desarrollo avanzado de software, utilizando herramientas colaborativas como Git, pruebas automatizadas con JUnit, y la integración continua con Maven. Además, se documenta el proceso en la wiki del repositorio y el archivo README.md. +- Comprender, aplicar y analizar técnicas de medición sobre entidades de productos software relacionados con conjuntos de pruebas de software e integración continua +- Comprender, aplicar y analizar medidas relacionadas sobre entidades de proceso y recursos de prueba del software e integración continua + +# **ENUNCIADO** + +En la práctica simula un pequeño desarrollo de un producto software para realizar mediciones sobre él. El objetivo es establecer un caso de estudio dummy que sirva para caracterizar y evaluar tanto el producto desarrollado como el proceso colaborativo seguido. El producto software es un código de test y el proceso es el análisis de la cobertura de pruebas en el tiempo. +### (a)Descripción del caso de estudio +Dado un código de ejemplo del patrón diseño creacional Pool Object, se debe crear una batería de pruebas tal que las coberturas de sus clases sean del 100%. El código de las clases se puede obtener en el repositorio https://github.com/clopezno/poolobject. La batería de pruebas JUnit debe estar contenida en la clase test.java.ubu.gii.dass.c01.ReuseblePoolTest.java. + +# **PREGUNTAS** + +### ¿Se ha realizado trabajo en equipo? +Sí. Para ello se han realizado las siguientes acciones colaborativas: + - reuniones continuas utilizando TEAMS: Comparticion de conocimientos de familiarización con el entorno. + - Evaluación del texto en modo colaboratívo. + - Uso de la herramienta GITHUB para compartición de código. + - Realización de test de forma colaborativa, asignando el liderazgo de cada una a un componente. +Tiempo invertido en reuniones colaborativas 10 horas. + +Enlace a la actividad del repositorio: https://github.com/cvo0004/poolobject/pulse + - Autores: 1 del master, 4 de test. + - Número de commits realizados: 17 +(dentro de los datos abría que obviar los commits anteriores al Fork) +### ¿Tiene calidad el conjunto de pruebas disponibles? +El conjunto de pruebas cuenta con una buena cobertura de código, validando el comportamiento esperado de los métodos principales de la clase ReusablePool. +- Número total de tests: 3 +- Pruebas exitosas: 3 +- Pruebas fallidas: 0 +- Cobertura de código: 100% nota: _(Se hace que se ignoren en Codecov las clases Client.java y Reusable.java, ya que estas_ +_influyen en el porcentaje de coverage, cuando en realidad el enunciado_ +_sólo pide testear la clase ReusablePool.java) +Informe de cobertura: https://app.codecov.io/gh/cvo0004/poolobject + +### ¿Cuál es el esfuerzo invertido en realizar la actividad? +El esfuerzo invertido se ha medido a través de las horas dedicadas por cada miembro, reflejadas en los commits y las sesiones de trabajo. + +- Horas totales invertidas: 20 horas +Enlace a las actividades de cada miembro: https://github.com/cvo0004/poolobject/graphs/contributors + +### ¿Cuál es el número de fallos encontrados en el código original? +- Número total de fallos detectados: Pensamos que hay un fallo en el método releaseReusable* porque no nos pasaba un test que hicimos, pero no estábamos seguros de que fuese fallo del método en sí y no de la implementación de nuestro test. Por lo que decidimos eliminar esa parte. + + +### ¿El proceso de integración continua realizado ha sido de calidad? +El proceso de integración continua (CI) se ha configurado mediante GitHub Actions con Codecov, ejecutando las pruebas automáticamente tras cada push. Codecov ha ido incrementando su porcentaje de coverage tras cada test implementado. + +- Configuración de codecovs para la CI sincronizada con GitHub: https://github.com/cvo0004/poolobject/actions/workflows/Java17CImaven.yml + +# Conclusión +El equipo ha logrado implementar pruebas unitarias y establecer un proceso efectivo de integración continua. La colaboración ha sido clave para completar la actividad de forma organizada y eficiente. + +Repositorio del proyecto: https://github.com/cvo0004/poolobject diff --git a/pom.xml b/pom.xml index 49b9938c..2250477e 100644 --- a/pom.xml +++ b/pom.xml @@ -1,5 +1,4 @@ - 4.0.0 @@ -9,7 +8,6 @@ 1.0-SNAPSHOT PoolObject Example - https://github.com/clopezno/poolobject/ @@ -19,10 +17,15 @@ 5.9.1 0.8.12 3.0.0-M7 - + + + daas + cvo0004_poolobject + https://sonarcloud.io + ${project.build.directory}/site/jacoco/jacoco.xml - + org.junit.jupiter junit-jupiter-api @@ -37,7 +40,7 @@ - + @@ -73,10 +76,23 @@ report + + + XML + + + + org.sonarsource.scanner.maven + sonar-maven-plugin + 3.9.1.2184 + + + ${env.SONAR_TOKEN} + + - - \ No newline at end of file + diff --git a/pomOLD.xml b/pomOLD.xml new file mode 100644 index 00000000..c69cf864 --- /dev/null +++ b/pomOLD.xml @@ -0,0 +1,82 @@ + + + + 4.0.0 + + ubu.gii.dass.c01 + javaAppPoolObject + 1.0-SNAPSHOT + + PoolObject Example + + https://github.com/clopezno/poolobject/ + + + UTF-8 + 8 + 8 + 5.9.1 + 0.8.12 + 3.0.0-M7 + + + + + + org.junit.jupiter + junit-jupiter-api + ${junit-jupiter.version} + test + + + org.junit.jupiter + junit-jupiter-engine + ${junit-jupiter.version} + test + + + + + + + + org.jacoco + jacoco-maven-plugin + ${jacoco-maven-plugin.version} + + + org.apache.maven.plugins + maven-surefire-plugin + ${maven-surefire-plugin.version} + + + + + + org.apache.maven.plugins + maven-surefire-plugin + + + org.jacoco + jacoco-maven-plugin + + + prepare-agent + + prepare-agent + + + + report + test + + report + + + + + + + + diff --git a/src/test/java/ubu/gii/dass/c01/ReusablePoolTest.java b/src/test/java/ubu/gii/dass/c01/ReusablePoolTest.java index 4e8c38d0..1b5a6d6a 100644 --- a/src/test/java/ubu/gii/dass/c01/ReusablePoolTest.java +++ b/src/test/java/ubu/gii/dass/c01/ReusablePoolTest.java @@ -3,6 +3,10 @@ */ package ubu.gii.dass.c01; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertNotSame; import static org.junit.jupiter.api.Assertions.assertTrue; import org.junit.jupiter.api.AfterAll; @@ -14,7 +18,10 @@ /** - * @author alumno + * @author Carlos Venero Ortega + * @author Ivan Fernandez Pardo + * @author Mario Flores Cano + * @author Pablo Alonso Cameselle * */ public class ReusablePoolTest { @@ -34,30 +41,71 @@ public static void tearDown() throws Exception { */ @Test @DisplayName("testGetInstance") - @Disabled("Not implemented yet") public void testGetInstance() { - + //Declaro dos objetos ReusablePool y obtengo las instancias de esa clase para cada objeto. + ReusablePool miPool = ReusablePool.getInstance();; + ReusablePool miPool2 = ReusablePool.getInstance();; + + //Compruebo que ambas instancias no son null. + assertNotNull(miPool, "miPool no es una null."); + assertNotNull(miPool2, "miPool2 no es una null."); + + //Compruebo que ambas instancias son realmente instancias de ReusablePool. + assertTrue(miPool instanceof ReusablePool, "miPool es una instancia de ReusablePool."); + assertTrue(miPool2 instanceof ReusablePool, "miPool2 es una instancia de ReusablePool."); + + //Compruebo que ambas instancias son realmente la misma y apuntan al mismo objeto en memoria. + assertSame(miPool, miPool2, "Ambas instancias apuntan al mismo objeto en memoria."); } - /** - * Test method for {@link ubu.gii.dass.c01.ReusablePool#acquireReusable()}. - */ - @Test - @DisplayName("testAcquireReusable") - @Disabled("Not implemented yet") + /** + * Test method for {@link ubu.gii.dass.c01.ReusablePool#acquireReusable()}. + * @throws NotFreeInstanceException + */ + @Test + @DisplayName("testAcquireReusable") + + public void testAcquireReusable() throws NotFreeInstanceException { + //Se obtiene la instancia del pool. + ReusablePool miPool3 = ReusablePool.getInstance(); + + //Se intenta adquirir el primer objeto reusable del pool. + Reusable r1 = miPool3.acquireReusable(); + assertNotNull(r1, "El objeto adquirido no debe ser null."); + + //Se intenta adquirir el segundo objeto reusable del pool. + Reusable r2 = miPool3.acquireReusable(); + assertNotNull(r2, "El segundo objeto adquirido no debe ser null."); + + //Se verifica que los objetos adquiridos son diferentes + assertNotSame(r1, r2, "Los objetos adquiridos deben ser diferentes."); + + //Trata de adquirir un tercer objeto reusable y como ya han sido adquiridos los dos existentes lanza la excepción. + assertThrows(NotFreeInstanceException.class, () -> miPool3.acquireReusable(), "Ya se han adquirido los 2 objetos existentes, por lo que se lanza la excepción."); + } - public void testAcquireReusable() { - - } + /** + * Test method for {@link ubu.gii.dass.c01.ReusablePool#releaseReusable(ubu.gii.dass.c01.Reusable)}. + * @throws NotFreeInstanceException + * @throws DuplicatedInstanceException + */ + @Test + @DisplayName("testReleaseReusable") + + public void testReleaseReusable() throws NotFreeInstanceException, DuplicatedInstanceException { + //Se obtiene la instancia del pool. + ReusablePool miPool4 = ReusablePool.getInstance(); + + //Se intenta adquirir un objeto reusable del pool. + Reusable r1 = miPool4.acquireReusable(); - /** - * Test method for {@link ubu.gii.dass.c01.ReusablePool#releaseReusable(ubu.gii.dass.c01.Reusable)}. - */ - @Test - @DisplayName("testReleaseReusable") - @Disabled("Not implemented yet") - public void testReleaseReusable() { - - } + + //Se intenta liberar un objeto reusable del pool. + miPool4.releaseReusable(r1); + + //Se comprueba que tras intentar liberar el mismo objeto reusable lanza la excepción porque este ya ha sido liberada. + assertThrows(DuplicatedInstanceException.class, () -> miPool4.releaseReusable(r1), "Ya se ha devuelto ese objeto reusable anteriormente, por lo que se lanza la excepción."); + + } }