Review Daniel Seto

.codecov.yml

@@ -2,4 +2,5 @@ coverage:
   round: up
   range: 0..100
   precision: 3
-
+  status:
+    patch: false

README.md

@@ -1,6 +1,94 @@
-poolobject
-==========
+## Medir para caracterizar entidades de productos y procesos software
+[![Universidad de Burgos](https://www.ubu.es/sites/all/themes/ubu_theme/images/UBUEscudo-1910.png "Universidad de Burgos")](http://www.ubu.es "Universidad de Burgos")
 
-Java code example of  design creational pattern pool object
+**Práctica 01 - Desarrollo avanzado de sistemas software**
+Grado en Ingeniería informática - Universidad de burgos
 
-Example to apply good practise in software developmemnt: test and mesurement.
+Daniel Setó Rey
+
+------------
+
+### Enunciado de la práctica
+En la práctica se va simular un pequeño desarrollo de un producto software para realizar mediciones sobre él.
+El objetivo es establecer un caso de estudio que sirva para caracterizar y evaluar tanto el producto desarrollado como el proceso seguido.
+#### Descripción del producto
+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 `ubu.gii.dass.test.c01.ReusablePoolTest.java`
+#### Descripción del proceso
+El proceso de desarrollo de la batería de pruebas se va a gestionar utilizando el control de versiones del sistema Git proporcionado por el repositorio de proyectos GitHub (https://github.com).
+Los pasos para gestionar el procesos son los siguientes:
+1. Cada miembro del equipo tiene que estar registrado en GitHub, Travis CI y Codecov.io.
+2. Uno de los miembros tiene que realizar un fork del repositorio donde se encuentra el código que se quiere probar https://github.com/clopezno/poolobject. El nuevo repositorio tiene que ser público.
+3. Invitar al resto de miembros del equipo para que puedan participar en el desarrollo de las pruebas.
+4. Vincular el proyecto con Travis CI y Codecov.io.
+5. Cada nuevo test realizado ejecutar un commit/push al repositorio del grupo. El texto del commit tiene que describir el caso de prueba añadido.
+6. Verificar el resultado de las pruebas en el pipeline de integración continua y cómo la calidad del producto va mejorando con las sucesivas integraciones.
+
+------------
+
+### Ejecución y resultados
+
+#### Setup y configuración
+Se ha hecho un fork del repositorio https://github.com/clopezno/poolobject y se han enlazado las correspondientes cuentas de travis CI y codeconv.
+
+Inicialmente se detectó un problema que impedía la correcta finalización del build en Travis con la configuración del repositorio. Tras realizar diferentes comprobaciones y estudiar posibles soluciones, el asunto se resuelve mediante una modificación  en travis.yml. por parte del profesor de la asignatura (https://github.com/clopezno/poolobject/commit/704d82252d75e8799a5d724d1ca119199dc2cbaa)
+
+Realizamos finalmente un nuevo fork, correspondiente al presente proyecto (https://github.com/dsr0018/poolobject) y solicitamos un build desde Travis, comprobando que el setup inicial actúa como se espera.
+
+En nuestro entorno de desarrollo, basado en Eclipse, clonamos el repositorio git y creamos un proyecto de Java para el desarrollo y ejecución local de test.
+
+#### Casos de prueba y desarrollo de test
+Con el objetivo de lograr una cobertura del 100% de `ubu.gii.dass.main.c01.ReusablePool.java` se diseñan varios casos de prueba basados en el *stub* proporcionado con la práctica. Algunos test se dividen en varios casos de prueba independientes. Los test se ejecutan con jUnit 4.
+En la siguiente tabla resumimos los casos de prueba diseñados y su implementación:
+
+|Método|Caso|Descripción|Test|Result. esperado|
+|---------|-----|-------------|----|-----------------------|
+|getInstance()|testGetInstance|Comprueba el funcionamiento correcto del patrón Singleton|Petición consecutiva de dos instancias de ReusablePool|Se obtienen dos referencias no nulas al mismo objeto (instancia Singleton)|
+|acquireReusable()|testAcquireReusable01|Test de adquisición de dos objetos reusables diferentes|Se solicitan consecutivamente dos objetos Reusable al pool ReusablePool|Se obtienen dos instancias no nulas diferentes de Reusable|
+|acquireReusable()|testAcquireReusable02|Comprueba la excepción NotFreeInstanceException si se solicitan más de dos objetos reusable|Se solicitan consecutivamente tres objetos reusables mediante acquireReusable()|Se lanza la excepción NotFreeInstanceException|
+|releaseReusable()|testReleaseReusable01|Comprueba que se liberan correctamente los objetos del pool y quedan a disposición de los clientes.|Se solicitan al pool dos objetos Reusable, se liberan y a continuación vuelven a solicitarse otros dos objetos Reusable.|En la segunda fase se obtienen los objetos Reusable liberados en la primera.|
+|releaseReusable()|testReleaseReusable02|Comprueba que no se permite liberar un objeto ya liberado.|Se solicitan consecutivamente dos veces la liberación de un objeto Reusable.|Se lanza la excepción DuplicatedInstanceException|
+#### Cuestiones planteadas
+**¿Se ha realizado trabajo en equipo?**
+
+No, dado que la práctica se ha realizado de modo individual. No obstante, se debe indicar que el setup empleado y el proceso de trabajo sería muy similar, dado que en el contexto de esta práctica no son de esperar problemas de integración continua derivados de la colaboración de varios participantes.
+
+**¿Tiene calidad el conjunto de pruebas disponibles?**
+
+Se considera que el conjunto de pruebas diseñado tiene un nivel elevado de calidad, debido a los siguientes motivos:
+1. El código a probar consiste en una aplicación sencilla del patrón Singleton, cuyos requisitos funcionales son simples y ha permitido diseñar casos de prueba basados directamente en la utilización típica (trivial) de los métodos de la clase. En un proyecto más complejo de software puede ser mucho más complicado conseguir una buena cobertura funcional.
+2. Mediante las herramientas automáticas podemos comprobar que mediante el conjunto de  test empleado se consigue una cobertura del 100% de las clases que implementan Pool Object. Según codecov: https://codecov.io/gh/dsr0018/poolobject/tree/master/src/main/ubu/gii/dass/c01
+![Cobertura codecov](./img/codecov.PNG)
+
+También hemos comprobado localmente la cobertura mediante eclEmma para Eclipse:
+![Cobertura codecov](./img/emma.PNG)
+
+**¿Cuál es el esfuerzo invertido en realizar la actividad?**
+
+Se estima un esfuerzo individual de aproximadamente 8 horas para la realización de la práctica, de acuerdo al desglose presentado en la siguiente tabla:
+
+|Tarea|Horas-persona|
+|------|-----------------|
+|Setup y configuración inicial</br>Incluye solución de problemas con el repositorio original|4|
+|Diseño y desarrollo de test|2|
+|Análisis de los resultados y documentación|2|
+
+**¿Cuál es el número de fallos encontrados en el código?**
+
+No se han encontrado fallos en el código cubierto por el conjunto de casos diseñado, como puede comprobarse en el log de Travis correspondiente al último build del proyecto:
+```shell
+            61 [junit] Running ubu.gii.dass.test.c01.ReusablePoolTest
+            62 [junit] Testsuite: ubu.gii.dass.test.c01.ReusablePoolTest
+            63 [junit] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.045 sec
+            64 [junit] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.045 sec
+            65 [junit]
+```
+https://travis-ci.org/dsr0018/poolobject
+
+#### Conclusiones
+La práctica ha constituido una buena primera aproximación al empleo práctico de un pipeline de integración continua en Java, en relación a los conceptos teóricos de medición y calidad en el desarrollo de software. 
+
+Destacar que el trabajo aparentemente inutil realizado inicialmente, derivado de la incorrecta configuración de Travis, ha servido al autor para estudiar bastantes posibilidades que desconocía de configuración de Ant.
+
+Además, la práctica ha provocado una interesante reflexión acerca de la mejor manera de realizar un conjunto de test unitarios sobre instancias Singleton (un aspecto este que en opinión del autor no está resuelto de manera completamente satisfactoria)

build.xml

@@ -83,4 +83,4 @@
     <delete dir="report"/>
     <delete file="jacoco.exec"/>
   </target>
-</project>
+</project>

img/dummy

@@ -0,0 +1 @@
+

src/test/ubu/gii/dass/test/c01/ReusablePoolTest.java

@@ -9,17 +9,34 @@
 import org.junit.Before;
 import org.junit.Test;
 
+import java.lang.reflect.Field;
+
+import ubu.gii.dass.c01.ReusablePool;
+import ubu.gii.dass.c01.DuplicatedInstanceException;
+import ubu.gii.dass.c01.NotFreeInstanceException;
+import ubu.gii.dass.c01.Reusable;
+
 /**
  * @author alumno
  *
  */
 public class ReusablePoolTest {
 
 	/**
+	 * Inicialización de test
 	 * @throws java.lang.Exception
 	 */
 	@Before
-	public void setUp() throws Exception {
+	public void setUp() throws Exception {		
+		// Utilizando Reflection podemos asegurarnos de trabajar siempre
+		// con una "nueva" instancia de Singleton en cada Test.
+		// Esta solución no me gusta demasiado, pero no veo cómo
+		// pueden hacerse las pruebas realmente independientes si no es así.
+		// (Porque no es posible garantizar que una prueba conserve
+		// el estado interno de una instancia Singleton)
+		Field instance = ReusablePool.class.getDeclaredField("instance");
+		instance.setAccessible(true);
+		instance.set(null, null);
 	}
 
 	/**
@@ -31,26 +48,93 @@ public void tearDown() throws Exception {
 
 	/**
 	 * Test method for {@link ubu.gii.dass.c01.ReusablePool#getInstance()}.
+	 * Comprueba el funcionamiento correcto del patrón Singleton
 	 */
 	@Test
 	public void testGetInstance() {
-		fail("Not yet implemented");
+		ReusablePool pool = ReusablePool.getInstance();
+		assertNotNull("Se ha devuelto un objeto nulo", pool);
+
+		ReusablePool pool2 = ReusablePool.getInstance();
+		assertNotNull("Se ha devuelto un objeto nulo", pool2);
+
+		assertSame("Se espera la misma instancia para el Singleton", pool, pool2);
+
 	}
 
 	/**
 	 * Test method for {@link ubu.gii.dass.c01.ReusablePool#acquireReusable()}.
+	 * Test de adquisición de dos objetos reusables diferentes
+	 * @throws NotFreeInstanceException 
 	 */
 	@Test
-	public void testAcquireReusable() {
-		fail("Not yet implemented");
+	public void testAcquireReusable01() throws NotFreeInstanceException {		
+		ReusablePool pool = ReusablePool.getInstance();
+
+		Reusable r1 = pool.acquireReusable();
+		assertNotNull(r1);
+		assertTrue(r1 instanceof Reusable);
+
+		Reusable r2 = pool.acquireReusable();
+		assertNotNull(r2);
+		assertTrue(r2 instanceof Reusable);
+
+		assertFalse("Se esperaban instancias diferentes de Reusable", r1.util().equals(r2.util()));
+
+	}
+
+	/**
+	 * Test method for {@link ubu.gii.dass.c01.ReusablePool#acquireReusable()}.
+	 * Comprueba la excepción NotFreeInstanceException si se solicitan más de dos objetos reusable
+	 * @throws NotFreeInstanceException 
+	 */
+	@SuppressWarnings("unused")
+	@Test(expected = NotFreeInstanceException.class)
+	public void testAcquireReusable02() throws NotFreeInstanceException {	
+		ReusablePool pool = ReusablePool.getInstance();	
+
+		Reusable r1 = pool.acquireReusable();	
+		Reusable r2 = pool.acquireReusable();
+		Reusable r3 = pool.acquireReusable();
+
 	}
 
 	/**
 	 * Test method for {@link ubu.gii.dass.c01.ReusablePool#releaseReusable(ubu.gii.dass.c01.Reusable)}.
+	 * Comprueba que se liberan correctamente los objetos del pool y quedan a disposición de los clientes.
+	 * @throws NotFreeInstanceException 
+	 * @throws DuplicatedInstanceException 
 	 */
 	@Test
-	public void testReleaseReusable() {
-		fail("Not yet implemented");
+	public void testReleaseReusable01() throws NotFreeInstanceException, DuplicatedInstanceException {
+		ReusablePool pool = ReusablePool.getInstance();
+		Reusable r1 = pool.acquireReusable();
+		Reusable r2 = pool.acquireReusable();
+
+		pool.releaseReusable(r1);
+		pool.releaseReusable(r2);
+
+		Reusable r2b = pool.acquireReusable();
+		Reusable r1b = pool.acquireReusable();
+
+		assertSame("No se recupera el objeto liberado",r1,r1b);
+		assertSame("No se recupera el objeto liberado",r2,r2b);
+	}
+
+	/**
+	 * Test method for {@link ubu.gii.dass.c01.ReusablePool#releaseReusable(ubu.gii.dass.c01.Reusable)}.
+	 * Comprueba que no se permite liberar un objeto ya liberado.
+	 * @throws NotFreeInstanceException 
+	 * @throws DuplicatedInstanceException 
+	 */
+	@Test(expected = DuplicatedInstanceException.class)
+	public void testReleaseReusable02() throws NotFreeInstanceException, DuplicatedInstanceException {
+		ReusablePool pool = ReusablePool.getInstance();
+
+		Reusable r1 = pool.acquireReusable();
+
+		pool.releaseReusable(r1);
+		pool.releaseReusable(r1);
+
 	}
-
 }