Revisión Pruebas Reusable-DAS Grupo1

README.md

@@ -1,6 +1,13 @@
 poolobject
 ==========
 
+[![codecov](https://codecov.io/gh/SofiaCalaviaGomez/Poolobject/graph/badge.svg?token=R35YMOPP2V)](https://codecov.io/gh/SofiaCalaviaGomez/Poolobject)
+
+[![codebeat badge](https://codebeat.co/badges/2abe3899-b4d8-4895-94d1-c2fc4711fe91)](https://codebeat.co/projects/github-com-andrespuentesg-poolobject-master)
+
+[![Maintainability](https://api.codeclimate.com/v1/badges/c978d5bde52a3f8c8c7b/maintainability)](https://codeclimate.com/github/haleks5/Poolobject/maintainability)
+
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=MarioCea_Poolobject&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=MarioCea_Poolobject)
 
 Java code example of creational design pattern pool object
 
@@ -10,3 +17,11 @@ Authors:
 
 - Carlos Lopez Nozal
 - Jesus Alonso Abad
+
+Editors:
+
+- @SofiaCalaviaGomez - Sofía Calavia
+- @Haleks5 -Alejandro García
+- @Andrespuentesg -Andrés Puentes
+- @Mariocea -Mario Cea
+

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

@@ -2,62 +2,232 @@
  * 
  */
 package ubu.gii.dass.c01;
-
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-
+import static org.junit.jupiter.api.Assertions.fail;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Disabled;
-
-
-
 /**
- * @author alumno
+ * @author Sofía Calavia
+ * @author Andrés Puentes
+ * @author Mario Cea
+ * @author Alejandro García
  *
  */
 public class ReusablePoolTest {
-
-
+	/**
+	 * @throws java.lang.Exception
+	 */
 	@BeforeAll
-	public static void setUp(){
+	public static void setUp() throws Exception{
 	}
-
 
 	@AfterAll
 	public static void tearDown() throws Exception {
 	}
-
 	/**
 	 * Test method for {@link ubu.gii.dass.c01.ReusablePool#getInstance()}.
 	 */
         @Test
         @DisplayName("testGetInstance")
-        @Disabled("Not implemented yet")
 	public void testGetInstance() {
+		// Crear una instancia del pool
+		ReusablePool instance1 = ReusablePool.getInstance();
+			//Verifica que la instancia no sea nula
+      		assertNotNull (instance1,"La instancia adquirida no debe ser nula");
+			//Comprueba si la instancia 1 es igual que la instancia 2
+      		ReusablePool instance2 = ReusablePool.getInstance();
+      		assertSame(instance1, instance2);		
+	}
+	/**
+	 * Test method for {@link ubu.gii.dass.c01.ReusablePool#acquireReusable()}.
+	*/
+		@Test
+    	@DisplayName("testAcquireReusable")
+	public void testAcquireReusable() {
+		// Crear una instancia del pool
+		ReusablePool pool = ReusablePool.getInstance();
+		try {
+			//Va a adquirir un objeto reusable del pool
+			Reusable reusable = pool.acquireReusable();
+			// Verifica que el objeto reusable adquirido no es nulo
+			assertNotNull(reusable,"El objeto reusable adquirido no debería ser nulo");
+			// Verifica que el objeto adquirido es una instancia de la clase Reusable
+        	assertTrue(reusable instanceof Reusable, "El objeto adquirido debe ser una instancia de Reusable");
+		} catch (NotFreeInstanceException e) {
+			// Si hay excepción, imprimirá un mensaje de error
+			fail("No se lanzaría una excepción si hemos adquirirido un objeto reusable del pool");
+        }
 
 	}
+	/**
+	 * Test method for {@link ubu.gii.dass.c01.ReusablePool#releaseReusable(ubu.gii.dass.c01.Reusable)}.
+		 * @throws NotFreeInstanceException 
+		*/ 
+		 @Test
+		 @DisplayName("testReleaseReusable")
+		 public void testReleaseReusable() throws DuplicatedInstanceException, NotFreeInstanceException {
+			// Crear una instancia del pool
+	 		ReusablePool pool = ReusablePool.getInstance();
+			//Crea un nuevo objeto reusable
+			Reusable reusable = new Reusable();
+		 try{
+			//Libera este objeto del pool
+			 pool.releaseReusable(reusable);
+			//Intenta adquirir un nuevo objeto de este
+			 Reusable acqReusable = pool.acquireReusable();
+			// Verifica si el objeto adquirido es el mismo que el objeto liberado
+			 assertEquals(reusable, acqReusable, "El objeto que ha sido adquirido debe ser el mismo que el liberado");
+			//Verifica que el pool tiene un objeto antes de liberarlo
+			 assertNotNull(pool.acquireReusable(), "El pool debería tener al menos un objeto reusable después de liberarlo");
+		 } catch (DuplicatedInstanceException e) {
+			//Si se lanza una excepción, imprime un mensaje de error
+			fail("No debería saltar una excepcion al liberar un objeto reusable");
+		 } catch (NotFreeInstanceException e) {
+			//Si se lanza una excepción, imprime un mensaje de error
+			fail("No se debe lanzar una excepción al adquirir un objeto reusable");
+		 }
+	 }
 
 	/**
-	 * Test method for {@link ubu.gii.dass.c01.ReusablePool#acquireReusable()}.
+	 * Test method for exception when no free instances are available.
 	 */
 	@Test
-        @DisplayName("testAcquireReusable")
-        @Disabled("Not implemented yet")
+	@DisplayName("testAcquireReusableWhenNoFreeInstances")
+	public void testAcquireReusableWhenNoFreeInstances() {
+		// Instancia un pool
+		ReusablePool pool = ReusablePool.getInstance();
+
+		try {
+			// Adquiere 2 pools disponibles
+			Reusable r1 = pool.acquireReusable();
+			Reusable r2 = pool.acquireReusable();
+
+			// Verifica que ambos objetos no son nulls y que estan instanciados
+			assertNotNull(r1, "First reusable should not be null");
+			assertNotNull(r2, "Second reusable should not be null");
+
+			// Trata de adquirir un tercer reusable (deberia hacer un throw NotFreeInstanceException)
+			try {
+				pool.acquireReusable();
+				fail("Should have thrown NotFreeInstanceException");
+			} catch (NotFreeInstanceException e) {
+				// Excepcion esperada
+				assertEquals("No hay más instancias reutilizables disponibles. Reintentalo más tarde", e.getMessage());
+			}
+			// Limpia y devuelve los objetos al pool
+			pool.releaseReusable(r1);
+			pool.releaseReusable(r2);
+
+		} catch (Exception e) {
+			fail("Unexpected exception: " + e.getMessage());
+		}
+	}
 
-	public void testAcquireReusable() {
+	/**
+	 * Test method for exception when releasing a duplicate instance.
+	 */
+	@Test
+	@DisplayName("testReleaseReusableDuplicated")
+	public void testReleaseReusableDuplicated() {
+		// Instancia un pool
+		ReusablePool pool = ReusablePool.getInstance();
 
+		try {
+			// Adquiere a reusable
+			Reusable reusable = pool.acquireReusable();
+			pool.releaseReusable(reusable);
+
+			// Intenta hacerlo de nuevo (sino throw DuplicatedInstanceException)
+			try {
+				pool.releaseReusable(reusable);
+				fail("Should have thrown DuplicatedInstanceException");
+			} catch (DuplicatedInstanceException e) {
+				// Excepcion esperada
+				assertEquals("Ya existe esa instancia en el pool.", e.getMessage());
+			}
+
+		} catch (Exception e) {
+			fail("Unexpected exception: " + e.getMessage());
+		}
 	}
 
 	/**
-	 * Test method for {@link ubu.gii.dass.c01.ReusablePool#releaseReusable(ubu.gii.dass.c01.Reusable)}.
+	 * Test for proper functioning of the pool with multiple operations.
+	 */
+	@Test
+	@DisplayName("testPoolCycleOperations")
+	public void testPoolCycleOperations() {
+		// Consigue la instancia pool
+		ReusablePool pool = ReusablePool.getInstance();
+
+		try {
+            // Paso 1: adquiere todas las variables reusables disponibles
+			Reusable r1 = pool.acquireReusable();
+			Reusable r2 = pool.acquireReusable();
+
+			// Paso 2: Verifica que sean objetos diferentes
+			assertNotNull(r1, "First reusable should not be null");
+			assertNotNull(r2, "Second reusable should not be null");
+			assertTrue(r1 != r2, "Should be different objects");
+
+            // Paso 3: Cambia el orden
+			pool.releaseReusable(r2);
+			pool.releaseReusable(r1);
+
+            // Paso 4: Readquiere y verifica el orden LIFO
+			Reusable r3 = pool.acquireReusable();
+			Reusable r4 = pool.acquireReusable();
+
+            // El pool deberia de retornar objetos siguiendo el orden LIFO
+			assertSame(r1, r3, "First released object should be first acquired");
+			assertSame(r2, r4, "Second released object should be second acquired");
+
+			pool.releaseReusable(r3);
+			pool.releaseReusable(r4);
+
+		} catch (Exception e) {
+			fail("Unexpected exception: " + e.getMessage());
+		}
+	}
+
+	/**
+	 * Test method for Reusable.util() functionality.
 	 */
 	@Test
-        @DisplayName("testReleaseReusable")
-        @Disabled("Not implemented yet")
-	public void testReleaseReusable() {
+	@DisplayName("testReusableUtil")
+	public void testReusableUtil() {
+		// Crea un objeto reusable y un string
+		Reusable reusable = new Reusable();
+		String utilString = reusable.util();
 
+		//  Verifica si contiene lo esperado
+		assertTrue(utilString.contains(String.valueOf(reusable.hashCode())), 
+				   "Util string should contain the object's hashcode");
+		assertTrue(utilString.contains(":Uso del objeto Reutilizable"), 
+				   "Util string should contain the expected message");
 	}
 
+	/**
+	 * Test method for exception classes.
+	 */
+	@Test
+	@DisplayName("testExceptionMessages")
+	public void testExceptionMessages() {
+		// Test NotFreeInstanceException
+		NotFreeInstanceException notFreeEx = new NotFreeInstanceException();
+		assertEquals("No hay más instancias reutilizables disponibles. Reintentalo más tarde", 
+					 notFreeEx.getMessage(), 
+					 "NotFreeInstanceException should have correct message");
+
+		// Test DuplicatedInstanceException
+		DuplicatedInstanceException dupEx = new DuplicatedInstanceException();
+		assertEquals("Ya existe esa instancia en el pool.", 
+					 dupEx.getMessage(), 
+					 "DuplicatedInstanceException should have correct message");
+	}
 }