diff --git a/src/main/java/shopManager/MyBagManager.java b/src/main/java/shopManager/MyBagManager.java
new file mode 100644
index 0000000..9f2e327
--- /dev/null
+++ b/src/main/java/shopManager/MyBagManager.java
@@ -0,0 +1,157 @@
+/**
+ * 
+ */
+package shopmanager;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.Collection;
+import java.util.HashMap;
+
+import java.util.logging.Logger;
+
+import exceptions.NoEnoughStock;
+import exceptions.NotInStock;
+import exceptions.NotInBag;
+import exceptions.UnknownRepo;
+import model.MyOrder;
+import model.Order;
+import model.Product;
+import persistency.OrderRepository;
+import shopmanager.StockManager;
+/**
+ * @author Isabel Rom�n, Antonio Delgado Bejarano
+ *
+ */
+public class MyBagManager implements BagManager {
+	private static Logger trazador=Logger.getLogger(MyStockManager.class.getName());
+	private Map<String,Product> cesta;
+	private OrderRepository repositorio;
+	private StockManager stock;
+	private Order order;
+	
+	/**
+	 * 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<String,Product>();
+	}
+
+	public MyBagManager(OrderRepository repo,StockManager stockManager){
+		cesta=new HashMap<String,Product>();
+		repositorio=repo;
+		stock=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();
+		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);
+		if(cesta.containsKey(newProduct.getId())){
+				int antes=cesta.get(newProduct.getId()).getNumber();
+				newProduct.setNumber(newProduct.getNumber()+antes);
+				cesta.put(newProduct.getId(), newProduct);
+			}
+		else
+			cesta.put(newProduct.getId(), newProduct);
+		return newProduct;
+	}
+	
+	@Override
+	public Product lessProduct(Product oldProduct)throws NotInStock {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public boolean removeProduct(Product oldProduct)throws NotInStock {
+		
+		// TODO Auto-generated method stub
+		return false;
+
+	}
+
+	@Override
+	public void removeProduct(String productId) throws NotInStock, NotInBag {
+		String msg="El id del producto a eliminar es "+productId;
+		trazador.info(msg);
+
+		if(cesta.containsKey(productId)){
+			
+			// Con el id obtiene el producto de la cesta
+			Product producto = cesta.get(productId);
+			
+			// Verifica que el producto existe en el stock para añadirlo al mismo, en caso contrario lanza una excepción NotInStock
+			if (stock.searchProduct(productId) != null) {
+			
+				// Añade al stock las unidades del producto que vamos a eliminar de la cesta
+				stock.addProduct(producto);
+			
+				// Elimina de la cesta el producto con esa id concreta
+				cesta.remove(productId);	
+			
+			}else {
+				throw new NotInStock(productId);
+			}
+		}
+		
+		// Si no encuentra en la cesta ningún producto con esa id lanza una excepción NotInBag
+		else {
+			
+			throw new NotInBag(productId);		
+		}
+	}
+
+	@Override
+	public Collection<Product> getBag() {
+			
+		return (List<Product>) cesta.values();
+	}
+
+	@Override
+	public Optional<Product> findProduct(String productId) {
+		Product producto=null;
+		if(cesta.containsKey(productId))
+			producto=cesta.get(productId);
+			
+		return Optional.ofNullable(producto);
+	}
+
+	@Override
+	public Optional<Product> findProduct(Product product) {
+		return findProduct(product.getId());
+	}
+	
+	@Override
+	public Order order() {
+		// 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();	
+		       trazador.info("Actualizo el pedido");
+		       order.setProducts(cesta.values());	
+		       trazador.info("Persisto el pedido");
+		       repositorio.save(order);
+		     
+	    
+		} catch (UnknownRepo ex) {
+			trazador.info("No ha sido posible guardar el pedido, no se estableci� el repositorio en el stock");
+		}
+	    	
+		return order;
+	}
+
+	@Override
+	public void reset() {
+		// Deber�a restaurar el stock, pero por ahora no se hace, s�lo borra
+		cesta.clear();
+		
+	}
+
+}
diff --git a/src/test/java/shopManager/TestRemoveProductString.java b/src/test/java/shopManager/TestRemoveProductString.java
new file mode 100644
index 0000000..e01b1dc
--- /dev/null
+++ b/src/test/java/shopManager/TestRemoveProductString.java
@@ -0,0 +1,144 @@
+package shopManager;
+
+import shopmanager.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+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.NotInBag;
+import exceptions.NotInStock;
+import model.Product;
+import model.Order;
+import persistency.OrderRepository;
+
+
+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 Isabel Román, Jorge Jimenez, Antonio Delgado
+ * Clase para realizar los test al método TestRemoveProductString de la clase MyBagManager
+ *
+ */
+@ExtendWith(MockitoExtension.class)
+class TestRemoveProductString {
+
+	//Creo los objetos sustitutos (representantes o mocks)
+	//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
+	private static StockManager stockMock= Mockito.mock(StockManager.class);
+	@Mock 
+	private static OrderRepository repositoryMock= Mockito.mock(OrderRepository.class);
+	@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)
+	@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
+	@Captor
+	private ArgumentCaptor<Integer> intCaptor;
+	@Captor
+	private ArgumentCaptor<Product> productCaptor;
+
+
+	/**
+	 * @see BeforeEach {@link org.junit.jupiter.api.BeforeEach}
+	 */
+	@BeforeEach
+	void setUpBeforeClass(){
+		//Todos los tests empiezan con la bolsa vacía
+		
+		   micestaTesteada.reset();
+	}
+	
+	/**
+	 * Test method for {@link shopmanager.MyBagManager#removeProduct(java.lang.String)}.
+	 * @throws NotInBag 
+	 */
+	@Test
+	@Tag("unidad")
+	@DisplayName("Prueba del método que elimina un producto")
+	void testRemoveProductString() throws NoEnoughStock, NotInStock, NotInBag {
+		
+		// Añado 1 producto del producto id1
+		Mockito.when(producto1Mock.getId()).thenReturn("id1");
+		Mockito.when(producto1Mock.getNumber()).thenReturn(1);
+		// Añado 2 productos del producto id2
+		Mockito.when(producto2Mock.getId()).thenReturn("id2");
+		Mockito.when(producto2Mock.getNumber()).thenReturn(2);
+		
+		// Intento configurar que el mock del stock devuelva un producto id1 cuando se busque en el stock
+		// pero no consigo hacerlo. De todos modos funciona correctamente
+		//Mockito.when(stockMock.searchProduct("id1")).thenReturn(producto1Mock);
+		
+		// Meto en la cesta 1 producto 1 y 2 productos 2
+		micestaTesteada.addProduct(producto1Mock);
+		micestaTesteada.addProduct(producto2Mock);
+		
+		// Elimino todo el producto id1 a partir de su id
+		micestaTesteada.removeProduct(producto1Mock.getId());
+		
+		// Compruebo que ya no esta en la cesta el producto id1
+		assertTrue(micestaTesteada.findProduct("id1").isEmpty());
+		
+		// Elimino todo el producto id2 a partir de su id
+		micestaTesteada.removeProduct(producto2Mock.getId());
+				
+		// Compruebo que ya no esta en la cesta el producto id2
+		assertTrue(micestaTesteada.findProduct("id2").isEmpty());
+
+		// Caso de borrar un producto con una id que no está en la cesta
+		try {
+			
+			// Intento borrar el producto con id3
+			micestaTesteada.removeProduct("id3");
+	    	
+			//Salta xcepción así que no debe llegar aquí		    	
+	    	fail("No salta la excepcion NotInBag");
+		    }catch(NotInBag e){
+		    	assertEquals("El producto con id id3 no existe en la cesta",e.getMessage(),"El mensaje de la excepción no es correcto");
+		    }
+		
+		// Programo el mock del Stock para que devuelva null al buscar un producto con id1
+		Mockito.when(stockMock.searchProduct("id1")).thenReturn(null);
+		Mockito.when(producto1Mock.getId()).thenReturn("id1");
+		
+		// Añado a la cesta un producto id1
+		Mockito.when(producto1Mock.getNumber()).thenReturn(1);
+		micestaTesteada.addProduct(producto1Mock);
+		
+		// Intenta eliminar el producto pero debe gestionar la excepcion NotInStock
+		try {
+			
+			micestaTesteada.removeProduct(producto1Mock.getId());
+
+			//Salta xcepción así que no debe llegar aquí		    	
+	    	fail("No salta la excepción NotInSotck");
+		
+		}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");
+		}
+		
+		
+	}
+	
+}