From 895e671b2454fb5be4e75ae91df817efb25e98ec Mon Sep 17 00:00:00 2001 From: Elena Mosquera Date: Sun, 27 Dec 2020 20:50:38 +0100 Subject: [PATCH 1/7] =?UTF-8?q?CODE:=20m=C3=A9todo=20Iterator=20M?= =?UTF-8?q?yBagManager.getUnitsIterator()?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Se implemeta un metodo que devuelve un iterador con la cesta ordenaa por productos --- src/main/java/shopmanager/BagManager.java | 41 ++++++++++++--------- src/main/java/shopmanager/MyBagManager.java | 26 +++++++++---- 2 files changed, 43 insertions(+), 24 deletions(-) diff --git a/src/main/java/shopmanager/BagManager.java b/src/main/java/shopmanager/BagManager.java index f15eb6e..32372fd 100644 --- a/src/main/java/shopmanager/BagManager.java +++ b/src/main/java/shopmanager/BagManager.java @@ -9,6 +9,7 @@ */ import java.util.Collection; +import java.util.Iterator; import java.util.Optional; import exceptions.NoEnoughStock; import exceptions.NotInStock; @@ -16,7 +17,7 @@ import model.Order; /** - * @author Isabel Román + * @author Isabel Rom�n * Gestor de la cesta de la compra * */ @@ -25,31 +26,31 @@ public interface BagManager { /** * - * Añade a la cesta tantas unidades del producto pasado como parámetro como indique getNumber() del mismo, actualiza Stock eliminado las unidades añadidas + * A�ade a la cesta tantas unidades del producto pasado como par�metro como indique getNumber() del mismo, actualiza Stock eliminado las unidades a�adidas * - * @param newProduct producto a añadir, en el número de unidades se indica cuántas unidades se añaden - * debe verificar si hay en stock, si no no se añaden y debería lanzar la excepción NoEnoughStock - * actualiza stock disminuyendo el número de unidades añadidas y aumenta el número de unidades en la cesta - * @return El producto tal y como está en la cesta - * @throws NoEnoughStock si el número de unidades en el stock no es suficiente + * @param newProduct producto a a�adir, en el n�mero de unidades se indica cu�ntas unidades se a�aden + * debe verificar si hay en stock, si no no se a�aden y deber�a lanzar la excepci�n NoEnoughStock + * actualiza stock disminuyendo el n�mero de unidades a�adidas y aumenta el n�mero de unidades en la cesta + * @return El producto tal y como est� en la cesta + * @throws NoEnoughStock si el n�mero de unidades en el stock no es suficiente * @throws NotInStock si el producto no existe en el stock */ Product addProduct(Product newProduct) throws NoEnoughStock,NotInStock; /** * - * Elimina de la cesta tantas unidades del producto pasado como parámetro como indique getNumber() del mismo, el número mínimo de unidades final es cero + * Elimina de la cesta tantas unidades del producto pasado como par�metro como indique getNumber() del mismo, el n�mero m�nimo de unidades final es cero * * @param oldProduct producto a eliminar, se eliminan las unidades que se marquen, actualiza stock aumentando estas unidades liberadas - * @return newProduct, el producto, indicando el número de unidades que quedan en la cesta + * @return newProduct, el producto, indicando el n�mero de unidades que quedan en la cesta * @throws NotInStock si el producto no estaba en el stock */ Product lessProduct(Product oldProduct) throws NotInStock; /** * Elimina completamente el producto, actualiza stock sumando las unidades liberadas * - * @param oldProduct el producto con el número de elementos que se quieren liberar - * @return devuelve true si se eliminó, false si el producto no estaba en la cesta - * @throws NotInStock si no existía en el stock este producto + * @param oldProduct el producto con el n�mero de elementos que se quieren liberar + * @return devuelve true si se elimin�, false si el producto no estaba en la cesta + * @throws NotInStock si no exist�a en el stock este producto * */ boolean removeProduct(Product oldProduct) throws NotInStock; @@ -64,16 +65,16 @@ public interface BagManager { /** * - * Obtiene la cesta como una colección (Sea cual sea la forma interna de almacenar los productos) + * Obtiene la cesta como una colecci�n (Sea cual sea la forma interna de almacenar los productos) * @return devuelve la cesta como una lista de productos */ Collection getBag(); /** * - * Devuelve el producto cuyo id se pasa como parámetro encapsulado en un objeto Optional + * Devuelve el producto cuyo id se pasa como par�metro encapsulado en un objeto Optional * @see java.util.Optional * @param productId el id del producto a buscar - * @return el producto, con el número de unidades del mismo, si es cero es que no estaba en la cesta + * @return el producto, con el n�mero de unidades del mismo, si es cero es que no estaba en la cesta */ Optional findProduct(String productId); /** @@ -81,7 +82,7 @@ public interface BagManager { * Devuelve el producto de la bolsa que se corresponde con el id del pasado, encapsulado en un objeto Optional * @see java.util.Optional * @param product producto a buscar - * @return el producto, con el número de unidades del mismo, si es cero es que no estaba en la cesta + * @return el producto, con el n�mero de unidades del mismo, si es cero es que no estaba en la cesta */ Optional findProduct(Product product); /** @@ -91,8 +92,14 @@ public interface BagManager { Order order(); /** - * Inicializa la cesta a cero, borra todo lo que había restaurando el stock + * Inicializa la cesta a cero, borra todo lo que hab�a restaurando el stock */ void reset(); + + /** + * + * @return un iterador que recorre la cesta por número de unidades, de más a menos + */ + Iterator getUnitsIterator(); } diff --git a/src/main/java/shopmanager/MyBagManager.java b/src/main/java/shopmanager/MyBagManager.java index 8deb338..94bbe05 100644 --- a/src/main/java/shopmanager/MyBagManager.java +++ b/src/main/java/shopmanager/MyBagManager.java @@ -7,8 +7,9 @@ import java.util.Map; import java.util.Optional; import java.util.Collection; +import java.util.Collections; import java.util.HashMap; - +import java.util.Iterator; import java.util.logging.Logger; import exceptions.NoEnoughStock; @@ -17,10 +18,11 @@ import model.MyOrder; import model.Order; import model.Product; +import model.UnitsComparator; import persistency.OrderRepository; import shopmanager.StockManager; /** - * @author Isabel Román + * @author Isabel Rom�n * */ public class MyBagManager implements BagManager { @@ -31,7 +33,7 @@ public class MyBagManager implements BagManager { private Order order; /** - * Al hacer privado el constructor obligo a que la construcción del objeto se haga siempre a través de newBag + * Al hacer privado el constructor obligo a que la construcci�n del objeto se haga siempre a trav�s de newBag */ public MyBagManager(){ cesta=new HashMap(); @@ -47,7 +49,7 @@ public MyBagManager(OrderRepository repo,StockManager stockManager){ @Override public Product addProduct(Product newProduct)throws NoEnoughStock, NotInStock{ - String msg="El id del producto es "+newProduct.getId()+" y las unidades a añadir"+newProduct.getNumber(); + String msg="El id del producto es "+newProduct.getId()+" y las unidades a a�adir"+newProduct.getNumber(); trazador.info(msg); //quito del stock las unidades solicitadas, si no hubiera suficientes lanza NoEnoughStock, si el producto no existe lanza NotInStock stock.lessProduct(newProduct); @@ -102,7 +104,7 @@ public Optional findProduct(Product product) { @Override public Order order() { - // No crea el objeto order, aún no está resuelto quién será el responsable de elegir el tipo concreto + // No crea el objeto order, a�n no est� resuelto qui�n ser� el responsable de elegir el tipo concreto try{ trazador.info("Intento persistir el stock"); stock.save(); @@ -112,7 +114,7 @@ public Order order() { repositorio.save(order); } catch (UnknownRepo ex) { - trazador.info("No ha sido posible guardar el pedido, no se estableció el repositorio en el stock"); + trazador.info("No ha sido posible guardar el pedido, no se estableci� el repositorio en el stock"); } return order; @@ -120,9 +122,19 @@ public Order order() { @Override public void reset() { - // Debería restaurar el stock, pero por ahora no se hace, sólo borra + // Deber�a restaurar el stock, pero por ahora no se hace, s�lo borra cesta.clear(); } + + @Override + public Iterator getUnitsIterator(){ + // Ordena la cesta segun las unidades de producto y devuelve un tipo iterador + List OrdenarCesta = (List) this.getBag(); + Collections.sort(OrdenarCesta, new UnitsComparator()); + + return OrdenarCesta.listIterator(); + } + } From 21e7eaeb1697b9776f52d0ecfd20c06141f368f9 Mon Sep 17 00:00:00 2001 From: Elena Mosquera Date: Sun, 27 Dec 2020 21:09:05 +0100 Subject: [PATCH 2/7] =?UTF-8?q?CODE:=20m=C3=A9todo=20Iterator=20M?= =?UTF-8?q?yBagManager.getUnitsIterator()?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/model/UnitsComparator.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 src/main/java/model/UnitsComparator.java diff --git a/src/main/java/model/UnitsComparator.java b/src/main/java/model/UnitsComparator.java new file mode 100644 index 0000000..8cc2b0f --- /dev/null +++ b/src/main/java/model/UnitsComparator.java @@ -0,0 +1,13 @@ +package model; + +import java.util.Comparator; + +public class UnitsComparator implements Comparator { + + @Override + public int compare(Product arg0, Product arg1) { + // TODO Auto-generated method stub + return 0; + } + +} From a408eec44b9753785a25b18484545f7f89359777 Mon Sep 17 00:00:00 2001 From: elemoncitos Date: Sun, 27 Dec 2020 21:29:48 +0100 Subject: [PATCH 3/7] TEST: para la clase UnitsComparator --- src/test/java/model/UnitsComparatorTest.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 src/test/java/model/UnitsComparatorTest.java diff --git a/src/test/java/model/UnitsComparatorTest.java b/src/test/java/model/UnitsComparatorTest.java new file mode 100644 index 0000000..e69de29 From 10631d659fb2b79df231655a87436151daf3bc49 Mon Sep 17 00:00:00 2001 From: elemoncitos Date: Sun, 3 Jan 2021 19:50:42 +0100 Subject: [PATCH 4/7] Cambios en BagManagerTest, UnitsComparator y UnitsComparatorTests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Añadimos los tests por pares de mi compañera y los tests que tengo que probar yo --- src/main/java/model/UnitsComparator.java | 17 +- src/test/java/model/UnitsComparatorTest.java | 101 ++++++++++++ src/test/java/shopManager/BagManagerTest.java | 147 ++++++++++++------ 3 files changed, 213 insertions(+), 52 deletions(-) diff --git a/src/main/java/model/UnitsComparator.java b/src/main/java/model/UnitsComparator.java index 8cc2b0f..4abdfd4 100644 --- a/src/main/java/model/UnitsComparator.java +++ b/src/main/java/model/UnitsComparator.java @@ -2,12 +2,15 @@ import java.util.Comparator; -public class UnitsComparator implements Comparator { - +public class UnitsComparator implements Comparator +{ + //https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html#compare-T-T- @Override - public int compare(Product arg0, Product arg1) { - // TODO Auto-generated method stub - return 0; + public int compare(Product o1, Product o2) + { + int num_o1= o1.getNumber(); + int num_o2= o2.getNumber(); + int resultado=num_o2-num_o1; //comparo + return resultado; } - -} +} \ No newline at end of file diff --git a/src/test/java/model/UnitsComparatorTest.java b/src/test/java/model/UnitsComparatorTest.java index e69de29..db5bf94 100644 --- a/src/test/java/model/UnitsComparatorTest.java +++ b/src/test/java/model/UnitsComparatorTest.java @@ -0,0 +1,101 @@ +/** + * + */ +package model; + +import shopmanager.*; + +import static org.junit.jupiter.api.Assertions.*; + +import static org.mockito.Mockito.mockitoSession; + +import java.util.logging.Logger; + +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.junit.jupiter.MockitoExtension; + +import exceptions.NoEnoughStock; +import exceptions.NotInStock; +import exceptions.UnknownRepo; +import model.Product; +import model.Order; +import model.UnitsComparator; +import persistency.OrderRepository; +import shopManager.ProductTest; + +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; + + + +/** + * @author Elena Mosquera + * Clase para realizar los test a la clase UnitsComparator + * + */ +@ExtendWith(MockitoExtension.class) +class UnitsComparatorTest { + + //Se crean los mocks a utilizar (los dos productos que vamos a comprobar se ordenan correctamente) + @Mock(serializable = true) + private static Product producto1Mock= Mockito.mock(Product.class); + @Mock(serializable = true) + private static Product producto2Mock= Mockito.mock(Product.class); + + + //Inyecci�n de dependencias + //Los objetos contenidos en micestaTesteada son reemplazados autom�ticamente por los sustitutos (mocks) + @InjectMocks + private static UnitsComparator comparador; + + + /** + * Test para probar el método Compare {@link model.UnitsCompaator#compare()} + * Tres comprobaciones: producto1 > producto2, producto1=producto2, producto1 Producto 2") + void TestGreaterThan() { + Mockito.when(producto1Mock.getNumber()).thenReturn(4); + Mockito.when(producto2Mock.getNumber()).thenReturn(2); + + int result = comparador.compare(producto1Mock, producto2Mock); + assertTrue(result >= 1, "Se espera un número positivo (cantidad de producto 1 es mayor que la del 2)"); + } + + @Test + @Tag("unidad") + @DisplayName("Producto 1 < Producto 2") + void TestLessThan() { + Mockito.when(producto1Mock.getNumber()).thenReturn(1); + Mockito.when(producto2Mock.getNumber()).thenReturn(2); + + int result = comparador.compare(producto1Mock, producto2Mock); + assertTrue(result <= -1, "Se espera un número negativo (cantidad de producto 2 es mayor que la del 1)"); + } + + @Test + @Tag("unidad") + @DisplayName("Producto 1 = Producto 2") + void TestEqualThan() { + Mockito.when(producto1Mock.getNumber()).thenReturn(2); + Mockito.when(producto2Mock.getNumber()).thenReturn(2); + + int result = comparador.compare(producto1Mock, producto2Mock); + assertTrue(result == 0, "Se espera un 0 (cantidad de producto 2 es igual que la del 1)"); + } + + + + +} diff --git a/src/test/java/shopManager/BagManagerTest.java b/src/test/java/shopManager/BagManagerTest.java index 72c0163..7c8a565 100644 --- a/src/test/java/shopManager/BagManagerTest.java +++ b/src/test/java/shopManager/BagManagerTest.java @@ -9,8 +9,11 @@ import static org.mockito.Mockito.mockitoSession; +import java.util.Iterator; import java.util.logging.Logger; + + import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; @@ -36,8 +39,8 @@ /** - * @author Isabel Román - * Clase para realizar los test a la clase MyBagManager, o a cualquier otra clase que implemente BagManager siempre que se sustituya la declaración private static MyBagManager micestaTesteada; + * @author Isabel Rom�n + * Clase para realizar los test a la clase MyBagManager, o a cualquier otra clase que implemente BagManager siempre que se sustituya la declaraci�n private static MyBagManager micestaTesteada; * */ @ExtendWith(MockitoExtension.class) @@ -45,11 +48,13 @@ class BagManagerTest { private static Logger trazador=Logger.getLogger(ProductTest.class.getName()); //Creo los objetos sustitutos (representantes o mocks) - //Son objetos contenidos en MyBagManager de los que aún no disponemos el código + //Son objetos contenidos en MyBagManager de los que a�n no disponemos el c�digo @Mock(serializable = true) private static Product producto1Mock= Mockito.mock(Product.class); @Mock(serializable = true) private static Product producto2Mock= Mockito.mock(Product.class); + @Mock(serializable = true) + private static Product producto3Mock= Mockito.mock(Product.class); @Mock private static StockManager stockMock= Mockito.mock(StockManager.class); @Mock @@ -57,14 +62,14 @@ class BagManagerTest { @Mock private static Order orderMock=Mockito.mock(Order.class); - //Inyección de dependencias - //Los objetos contenidos en micestaTesteada son reemplazados automáticamente por los sustitutos (mocks) + //Inyecci�n de dependencias + //Los objetos contenidos en micestaTesteada son reemplazados autom�ticamente por los sustitutos (mocks) @InjectMocks private static MyBagManager micestaTesteada; - //Servirán para conocer el argumento con el que se ha invocado algún método de alguno de los mocks (sustitutos o representantes) - //ArgumentCaptor es un genérico, indico al declararlo el tipo del argumento que quiero capturar + //Servir�n para conocer el argumento con el que se ha invocado alg�n m�todo de alguno de los mocks (sustitutos o representantes) + //ArgumentCaptor es un gen�rico, indico al declararlo el tipo del argumento que quiero capturar @Captor private ArgumentCaptor intCaptor; @Captor @@ -77,21 +82,21 @@ class BagManagerTest { @BeforeEach void setUpBeforeClass(){ - //Todos los tests empiezan con la bolsa vacía + //Todos los tests empiezan con la bolsa vac�a micestaTesteada.reset(); } /** - * Test para probar el método de efectuar un pedido {@link shopmanager.BagManager#order()} + * Test para probar el m�todo de efectuar un pedido {@link shopmanager.BagManager#order()} * - * @throws NoEnoughStock Se intenta añadir un número de unidades de un producto, pero no hay suficientes en stock - * @throws NotInStock Se intenta añadir un producto, pero no existe ese tipo en el stock - * @throws UnknownRepo Se intenta guardar algo en un repositorio, pero no se ha establecido bien esta referencia y no sabe dónde guardar + * @throws NoEnoughStock Se intenta a�adir un n�mero de unidades de un producto, pero no hay suficientes en stock + * @throws NotInStock Se intenta a�adir un producto, pero no existe ese tipo en el stock + * @throws UnknownRepo Se intenta guardar algo en un repositorio, pero no se ha establecido bien esta referencia y no sabe d�nde guardar */ @Test @Tag("unidad") - @DisplayName("Prueba del método que asienta el pedido") + @DisplayName("Prueba del m�todo que asienta el pedido") void testOrder() throws NoEnoughStock, NotInStock, UnknownRepo { trazador.info("Comienza el test de order"); //Hago un pedido que no debe tener problemas @@ -108,10 +113,10 @@ void testOrder() throws NoEnoughStock, NotInStock, UnknownRepo { //EJERCICIO: Elimine este comentario, ejecute los test // Mockito.verifyZeroInteractions(repositoryMock); - // ¿Por qué falla el test si se pone aquí esta comprobación? + // �Por qu� falla el test si se pone aqu� esta comprobaci�n? - //si no se pueda guardar el stock no se guarda el pedido, no se llega a tocar el repositorio ni se modifica order, y mi cesta gestiona la excepción, no debe propagarse y por tanto no debe lanzarla - trazador.info("Ahora hago que salte la excepción UnknownRepo en el stock, para ver si la gestiona bien BagManager"); + //si no se pueda guardar el stock no se guarda el pedido, no se llega a tocar el repositorio ni se modifica order, y mi cesta gestiona la excepci�n, no debe propagarse y por tanto no debe lanzarla + trazador.info("Ahora hago que salte la excepci�n UnknownRepo en el stock, para ver si la gestiona bien BagManager"); Mockito.doThrow(new UnknownRepo()).when(stockMock).save(); try { micestaTesteada.order(); @@ -120,8 +125,8 @@ void testOrder() throws NoEnoughStock, NotInStock, UnknownRepo { } catch(Exception e) { - //Me aseguro de que BagManager gestiona esta excepción y no la propaga - fail("BagManager debe gestionar la excepción UnknownRepo y no propagarla"); + //Me aseguro de que BagManager gestiona esta excepci�n y no la propaga + fail("BagManager debe gestionar la excepci�n UnknownRepo y no propagarla"); } @@ -129,12 +134,12 @@ void testOrder() throws NoEnoughStock, NotInStock, UnknownRepo { /** * Test method for {@link shopmanager.BagManager#addProduct(model.Product)}. - * @throws NotInStock lanza cualquier excepción de sus clientes, no las gestiona siempre internamente - * @throws NoEnoughStock lanza cualquier excepción de sus clientes, no las gestiona siempre internamente + * @throws NotInStock lanza cualquier excepci�n de sus clientes, no las gestiona siempre internamente + * @throws NoEnoughStock lanza cualquier excepci�n de sus clientes, no las gestiona siempre internamente */ @Test @Tag("unidad") - @DisplayName("Prueba del método que añade un producto") + @DisplayName("Prueba del m�todo que a�ade un producto") void testAddProduct() throws NoEnoughStock, NotInStock { Mockito.when(producto1Mock.getId()).thenReturn("id1"); Mockito.when(producto1Mock.getNumber()).thenReturn(1); @@ -143,12 +148,12 @@ void testAddProduct() throws NoEnoughStock, NotInStock { micestaTesteada.addProduct(producto1Mock); assertFalse(micestaTesteada.findProduct("id1").isEmpty()); - assertEquals(1,micestaTesteada.findProduct("id1").get().getNumber(),"El producto insertado debía tener una unidad"); + assertEquals(1,micestaTesteada.findProduct("id1").get().getNumber(),"El producto insertado deb�a tener una unidad"); micestaTesteada.addProduct(producto2Mock); - assertEquals(2,micestaTesteada.findProduct("id2").get().getNumber(),"El producto insertado debía tener dos unidades"); + assertEquals(2,micestaTesteada.findProduct("id2").get().getNumber(),"El producto insertado deb�a tener dos unidades"); assertTrue(micestaTesteada.findProduct("id1").isPresent()); - /**Cuidado con los mock, no son el objeto de verdad son sustitutos y no implementan la lógica de los objetos**/ - /**Analizar por qué estos dos test que vienen a continuación no son correctos, mientras que los de arriba sí*/ + /**Cuidado con los mock, no son el objeto de verdad son sustitutos y no implementan la l�gica de los objetos**/ + /**Analizar por qu� estos dos test que vienen a continuaci�n no son correctos, mientras que los de arriba s�*/ /* micestaTesteada.addProduct(producto1Mock); assertEquals(2,micestaTesteada.findProduct("id1").get().getNumber(),"El incremento de un producto en una unidad no se hace bien"); @@ -156,50 +161,50 @@ void testAddProduct() throws NoEnoughStock, NotInStock { assertEquals(4,micestaTesteada.findProduct("id2").get().getNumber(),"El incremento de un producto en dos unidades no se hace bien"); */ - //Para ver si realmente hace bien la actualización de valores lo que deberíamos es asegurar que el método + //Para ver si realmente hace bien la actualizaci�n de valores lo que deber�amos es asegurar que el m�todo //newProduct.setNumber(newProduct.getNumber()+antes); //se invoca con el valor correcto (no invoca la primera vez, ni la segunda porque el producto no estaba, la tercera se invoca con 2 y la cuarta con 4, porque hay que cambiarle el valor) - //estoy suponiendo que se guarda exactamente el mismo producto que se pasa, no se hace ningún tipo de copia (en realidad no tendría por qué suponer esto... + //estoy suponiendo que se guarda exactamente el mismo producto que se pasa, no se hace ning�n tipo de copia (en realidad no tendr�a por qu� suponer esto... //Es para probar las prestaciones de los ArgumentCaptors - //la segunda vez que añado el producto debe sumarse el número de unidades a las que ya había + //la segunda vez que a�ado el producto debe sumarse el n�mero de unidades a las que ya hab�a micestaTesteada.addProduct(producto1Mock); - //quiero verificar el argumento que se ha usado en el mock para poner el número de unidades + //quiero verificar el argumento que se ha usado en el mock para poner el n�mero de unidades Mockito.verify(producto1Mock).setNumber(intCaptor.capture()); - assertEquals(2,intCaptor.getValue(), "El argumento para actualizar el número de unidades en el producto no se calcula bien"); + assertEquals(2,intCaptor.getValue(), "El argumento para actualizar el n�mero de unidades en el producto no se calcula bien"); micestaTesteada.addProduct(producto2Mock); Mockito.verify(producto2Mock).setNumber(intCaptor.capture()); - assertEquals(4,intCaptor.getValue(), "El argumento para actualizar el número de unidades en el producto no se calcula bien"); + assertEquals(4,intCaptor.getValue(), "El argumento para actualizar el n�mero de unidades en el producto no se calcula bien"); - //Si hay no hay stock el producto no se debe añadir, parto de nuevo de la cesta vacía + //Si hay no hay stock el producto no se debe a�adir, parto de nuevo de la cesta vac�a micestaTesteada.reset(); Mockito.doThrow(new NoEnoughStock(0)).when(stockMock).lessProduct(producto1Mock); try { micestaTesteada.addProduct(producto1Mock); - //debe saltar la excepción así que no debe llegar aquí - fail("No salta la excepción del stock"); + //debe saltar la excepci�n as� que no debe llegar aqu� + fail("No salta la excepci�n del stock"); }catch(NoEnoughStock e){ - assertEquals("No hay suficientes unidades en el Stock, sólo quedan 0",e.getMessage(),"El mensaje de la excepción no es correcto"); + assertEquals("No hay suficientes unidades en el Stock, s�lo quedan 0",e.getMessage(),"El mensaje de la excepci�n no es correcto"); } - //Aseguro que si no había suficientes unidades no se ha agregado a la cesta - assertTrue(micestaTesteada.findProduct("id1").isEmpty(),"Se agrega un producto cuando no había suficientes unidades"); - assertFalse(micestaTesteada.findProduct("id1").isPresent(),"Se agrega un producto cuando no había suficientes unidades"); + //Aseguro que si no hab�a suficientes unidades no se ha agregado a la cesta + assertTrue(micestaTesteada.findProduct("id1").isEmpty(),"Se agrega un producto cuando no hab�a suficientes unidades"); + assertFalse(micestaTesteada.findProduct("id1").isPresent(),"Se agrega un producto cuando no hab�a suficientes unidades"); - //Ahora pruebo la gestión de la excepción NotInStock, no se debe agregar a la cesta y debe lanzar la excepción - //aseguro que parto de la cesta vacía + //Ahora pruebo la gesti�n de la excepci�n NotInStock, no se debe agregar a la cesta y debe lanzar la excepci�n + //aseguro que parto de la cesta vac�a micestaTesteada.reset(); Mockito.doThrow(new NotInStock("id1")).when(stockMock).lessProduct(producto1Mock); try { micestaTesteada.addProduct(producto1Mock); - //debe saltar la excepción así que no debe llegar aquí - fail("No salta la excepción NotInStock stock"); + //debe saltar la excepci�n as� que no debe llegar aqu� + fail("No salta la excepci�n NotInStock stock"); }catch(NotInStock e){ - assertEquals("El producto con id id1 no existe en el Stock",e.getMessage(),"El mensaje de la excepción no es correcto"); + assertEquals("El producto con id id1 no existe en el Stock",e.getMessage(),"El mensaje de la excepci�n no es correcto"); } - //Aseguro que si no existía en el stock no se ha agregado a la cesta + //Aseguro que si no exist�a en el stock no se ha agregado a la cesta assertTrue(micestaTesteada.findProduct("id1").isEmpty(),"Se agrega un producto que no existe en el stock"); assertFalse(micestaTesteada.findProduct("id1").isPresent(),"Se agrega un producto que no existe en el stock"); } @@ -260,7 +265,7 @@ void testFindProductProduct() { } /** * Rellena una cesta con los dos mocks declarados al inicio - * @throws NoEnoughStock Si no hay suficiente stock del producto a añadir + * @throws NoEnoughStock Si no hay suficiente stock del producto a a�adir * @throws NotInStock Si no existe el producto en el stock */ void rellenaCesta() throws NoEnoughStock, NotInStock { @@ -271,5 +276,57 @@ void rellenaCesta() throws NoEnoughStock, NotInStock { micestaTesteada.addProduct(producto1Mock); micestaTesteada.addProduct(producto2Mock); } + + @Test + @Tag("unidad") + @DisplayName("Prueba Iterador") + void test_iterador_mas_menos() throws NoEnoughStock, NotInStock + { + //Inicializo los mocks + Mockito.when(producto1Mock.getId()).thenReturn("id1"); + Mockito.when(producto1Mock.getNumber()).thenReturn(1); + Mockito.when(producto2Mock.getId()).thenReturn("id2"); + Mockito.when(producto2Mock.getNumber()).thenReturn(2); + Mockito.when(producto3Mock.getId()).thenReturn("id3"); + Mockito.when(producto3Mock.getNumber()).thenReturn(3); + //Agrego los productos a la cesta considerando que se añadieron correctamente + micestaTesteada.addProduct(producto1Mock); + micestaTesteada.addProduct(producto2Mock); + micestaTesteada.addProduct(producto3Mock); + Iterator iterador=micestaTesteada.getUnitsIterator(); + //Pruebo que no esta vacia + if (!iterador.hasNext()) // Si no tiene siguiente, es porque esta vacia + { + fail("El iterador fue recibido vacio"); + } + //Comprobamos que esten en orden de mayor a menor. + if (!(producto3Mock.getNumber()==iterador.next().getNumber())) + { + fail("El iterador no está ordenando correctamente (posicion1)"); + } + if (!iterador.hasNext()) // Si no tiene siguiente, es porque tiene un solo producto + { + fail("No se tienen todos los elementos que se metieron en la cesta"); + } + if (!(producto2Mock.getNumber()==iterador.next().getNumber())) + { + fail("El iterador no está ordenando correctamente (posicion2)"); + } + if (!iterador.hasNext()) // Si no tiene siguiente, es porque tiene dos productos + { + fail("No se tienen todos los elementos que se metieron en la cesta"); + } + if (!(producto1Mock.getNumber()==iterador.next().getNumber())) + { + fail("El iterador no está ordenando correctamente (posicion3)"); + } + if (iterador.hasNext()) // Si tiene siguiente, es porque tiene productos demas + { + fail("La cesta tiene mas productos de lo esperado"); + } + //fail("Not yet implemented"); + } + + } From f735642f41431d19e3bbd3aa7507fe6fe9bc8f94 Mon Sep 17 00:00:00 2001 From: elemoncitos Date: Sun, 3 Jan 2021 21:24:42 +0100 Subject: [PATCH 5/7] =?UTF-8?q?TEST=20+=20Correcci=C3=B3n=20de=20codigo:?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Corrección de MyBagManager.java - Error en el cast de devolución del metodo getBag(). cesta.values() devuelve una Collection y el cast a List no es posible, por lo que se redefine y se deja como tipo collection. Correccion de UnitsComparatorTest --- src/main/java/shopmanager/MyBagManager.java | 6 ++++-- src/test/java/model/UnitsComparatorTest.java | 4 ++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/main/java/shopmanager/MyBagManager.java b/src/main/java/shopmanager/MyBagManager.java index 94bbe05..d899985 100644 --- a/src/main/java/shopmanager/MyBagManager.java +++ b/src/main/java/shopmanager/MyBagManager.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashMap; @@ -85,7 +86,7 @@ public void removeProduct(String productId)throws NotInStock { @Override public Collection getBag() { - return (List) cesta.values(); + return (Collection) cesta.values(); } @Override @@ -130,7 +131,8 @@ public void reset() { @Override public Iterator getUnitsIterator(){ // Ordena la cesta segun las unidades de producto y devuelve un tipo iterador - List OrdenarCesta = (List) this.getBag(); + Collection Cesta = this.getBag(); + List OrdenarCesta = new ArrayList(Cesta); Collections.sort(OrdenarCesta, new UnitsComparator()); return OrdenarCesta.listIterator(); diff --git a/src/test/java/model/UnitsComparatorTest.java b/src/test/java/model/UnitsComparatorTest.java index db5bf94..1f97db1 100644 --- a/src/test/java/model/UnitsComparatorTest.java +++ b/src/test/java/model/UnitsComparatorTest.java @@ -70,7 +70,7 @@ void TestGreaterThan() { Mockito.when(producto2Mock.getNumber()).thenReturn(2); int result = comparador.compare(producto1Mock, producto2Mock); - assertTrue(result >= 1, "Se espera un número positivo (cantidad de producto 1 es mayor que la del 2)"); + assertTrue(result <= -1, "Se espera un número positivo (cantidad de producto 1 es mayor que la del 2)"); } @Test @@ -81,7 +81,7 @@ void TestLessThan() { Mockito.when(producto2Mock.getNumber()).thenReturn(2); int result = comparador.compare(producto1Mock, producto2Mock); - assertTrue(result <= -1, "Se espera un número negativo (cantidad de producto 2 es mayor que la del 1)"); + assertTrue(result >= 1, "Se espera un número negativo (cantidad de producto 2 es mayor que la del 1)"); } @Test From bbd74bf24a99ba9e888ac2f9558a834a12de578e Mon Sep 17 00:00:00 2001 From: elemoncitos Date: Sat, 23 Jan 2021 11:55:54 +0100 Subject: [PATCH 6/7] Eliminamos los comparadores --- src/main/java/model/UnitsComparator.java | 16 --- src/test/java/model/UnitsComparatorTest.java | 101 ------------------- 2 files changed, 117 deletions(-) delete mode 100644 src/main/java/model/UnitsComparator.java delete mode 100644 src/test/java/model/UnitsComparatorTest.java diff --git a/src/main/java/model/UnitsComparator.java b/src/main/java/model/UnitsComparator.java deleted file mode 100644 index 4abdfd4..0000000 --- a/src/main/java/model/UnitsComparator.java +++ /dev/null @@ -1,16 +0,0 @@ -package model; - -import java.util.Comparator; - -public class UnitsComparator implements Comparator -{ - //https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html#compare-T-T- - @Override - public int compare(Product o1, Product o2) - { - int num_o1= o1.getNumber(); - int num_o2= o2.getNumber(); - int resultado=num_o2-num_o1; //comparo - return resultado; - } -} \ No newline at end of file diff --git a/src/test/java/model/UnitsComparatorTest.java b/src/test/java/model/UnitsComparatorTest.java deleted file mode 100644 index 1f97db1..0000000 --- a/src/test/java/model/UnitsComparatorTest.java +++ /dev/null @@ -1,101 +0,0 @@ -/** - * - */ -package model; - -import shopmanager.*; - -import static org.junit.jupiter.api.Assertions.*; - -import static org.mockito.Mockito.mockitoSession; - -import java.util.logging.Logger; - -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Tag; -import org.junit.jupiter.api.Test; -import org.mockito.junit.jupiter.MockitoExtension; - -import exceptions.NoEnoughStock; -import exceptions.NotInStock; -import exceptions.UnknownRepo; -import model.Product; -import model.Order; -import model.UnitsComparator; -import persistency.OrderRepository; -import shopManager.ProductTest; - -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.ArgumentCaptor; -import org.mockito.Captor; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.Mockito; - - - -/** - * @author Elena Mosquera - * Clase para realizar los test a la clase UnitsComparator - * - */ -@ExtendWith(MockitoExtension.class) -class UnitsComparatorTest { - - //Se crean los mocks a utilizar (los dos productos que vamos a comprobar se ordenan correctamente) - @Mock(serializable = true) - private static Product producto1Mock= Mockito.mock(Product.class); - @Mock(serializable = true) - private static Product producto2Mock= Mockito.mock(Product.class); - - - //Inyecci�n de dependencias - //Los objetos contenidos en micestaTesteada son reemplazados autom�ticamente por los sustitutos (mocks) - @InjectMocks - private static UnitsComparator comparador; - - - /** - * Test para probar el método Compare {@link model.UnitsCompaator#compare()} - * Tres comprobaciones: producto1 > producto2, producto1=producto2, producto1 Producto 2") - void TestGreaterThan() { - Mockito.when(producto1Mock.getNumber()).thenReturn(4); - Mockito.when(producto2Mock.getNumber()).thenReturn(2); - - int result = comparador.compare(producto1Mock, producto2Mock); - assertTrue(result <= -1, "Se espera un número positivo (cantidad de producto 1 es mayor que la del 2)"); - } - - @Test - @Tag("unidad") - @DisplayName("Producto 1 < Producto 2") - void TestLessThan() { - Mockito.when(producto1Mock.getNumber()).thenReturn(1); - Mockito.when(producto2Mock.getNumber()).thenReturn(2); - - int result = comparador.compare(producto1Mock, producto2Mock); - assertTrue(result >= 1, "Se espera un número negativo (cantidad de producto 2 es mayor que la del 1)"); - } - - @Test - @Tag("unidad") - @DisplayName("Producto 1 = Producto 2") - void TestEqualThan() { - Mockito.when(producto1Mock.getNumber()).thenReturn(2); - Mockito.when(producto2Mock.getNumber()).thenReturn(2); - - int result = comparador.compare(producto1Mock, producto2Mock); - assertTrue(result == 0, "Se espera un 0 (cantidad de producto 2 es igual que la del 1)"); - } - - - - -} From 0dd2a9b2f84001cc61699270234dad9c687eb043 Mon Sep 17 00:00:00 2001 From: elemoncitos Date: Sat, 23 Jan 2021 12:33:03 +0100 Subject: [PATCH 7/7] Correcion del Test --- src/test/java/shopManager/BagManagerTest.java | 38 ++++--------------- 1 file changed, 8 insertions(+), 30 deletions(-) diff --git a/src/test/java/shopManager/BagManagerTest.java b/src/test/java/shopManager/BagManagerTest.java index 7c8a565..2be6753 100644 --- a/src/test/java/shopManager/BagManagerTest.java +++ b/src/test/java/shopManager/BagManagerTest.java @@ -280,7 +280,7 @@ void rellenaCesta() throws NoEnoughStock, NotInStock { @Test @Tag("unidad") @DisplayName("Prueba Iterador") - void test_iterador_mas_menos() throws NoEnoughStock, NotInStock + void testGetUnitsIterator() throws NoEnoughStock, NotInStock { //Inicializo los mocks Mockito.when(producto1Mock.getId()).thenReturn("id1"); @@ -295,36 +295,14 @@ void test_iterador_mas_menos() throws NoEnoughStock, NotInStock micestaTesteada.addProduct(producto3Mock); Iterator iterador=micestaTesteada.getUnitsIterator(); //Pruebo que no esta vacia - if (!iterador.hasNext()) // Si no tiene siguiente, es porque esta vacia - { - fail("El iterador fue recibido vacio"); - } + assertTrue(iterador.hasNext(), "El iterador esta vacio"); //Comprobamos que esten en orden de mayor a menor. - if (!(producto3Mock.getNumber()==iterador.next().getNumber())) - { - fail("El iterador no está ordenando correctamente (posicion1)"); - } - if (!iterador.hasNext()) // Si no tiene siguiente, es porque tiene un solo producto - { - fail("No se tienen todos los elementos que se metieron en la cesta"); - } - if (!(producto2Mock.getNumber()==iterador.next().getNumber())) - { - fail("El iterador no está ordenando correctamente (posicion2)"); - } - if (!iterador.hasNext()) // Si no tiene siguiente, es porque tiene dos productos - { - fail("No se tienen todos los elementos que se metieron en la cesta"); - } - if (!(producto1Mock.getNumber()==iterador.next().getNumber())) - { - fail("El iterador no está ordenando correctamente (posicion3)"); - } - if (iterador.hasNext()) // Si tiene siguiente, es porque tiene productos demas - { - fail("La cesta tiene mas productos de lo esperado"); - } - //fail("Not yet implemented"); + assertTrue(producto3Mock.getNumber()==iterador.next().getNumber(), "El primer producto debe de ser el 3"); + assertTrue(iterador.hasNext(), "No se tienen todos los elementos que se metieron en la cesta"); + assertTrue(producto2Mock.getNumber()==iterador.next().getNumber(), "El segundo producto debe de ser el 2"); + assertTrue(iterador.hasNext(), "No se tienen todos los elementos que se metieron en la cesta"); + assertTrue(producto1Mock.getNumber()==iterador.next().getNumber(), "El tercer producto debe de ser el 1"); + assertFalse(iterador.hasNext(), "La cesta tiene mas productos de lo esperado"); }