Banco de dados, apenas um detalhe

InMemoryOrderRepository.java

package infrastructure;

import domain.Order;
import domain.OrderNotFound;
import domain.OrderRepository;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.UUID;

public class InMemoryOrderRepository implements OrderRepository {
    private List<Order> orders;

    public InMemoryOrderRepository() {
        orders = new ArrayList<Order>();
    }

    public InMemoryOrderRepository(List<Order> orders)
    {
        this.orders = orders;
    }

    @Override
    public void save(Order order) {
        if (! orderAlreadyExists(order.id())) {
            orders.add(order);
        }

        update(order);
    }

    @Override
    public Optional<Order> getById(UUID orderId) {
        return orders.stream().filter(o -> o.id().equals(orderId)).findFirst();
    }

    @Override
    public void delete(UUID orderId) throws OrderNotFound {
        if (! orderAlreadyExists(orderId)) {
            throw new OrderNotFound();
        }

        Order orderFound = orders.stream().filter(o -> o.id().equals(orderId)).findFirst().get();
        int orderFoundIndex = orders.indexOf(orderFound);
        orders.remove(orderFoundIndex);
    }

    private void update(Order order) {
        Order orderFound = orders.stream().filter(o -> o.id().equals(order.id())).findFirst().get();
        int orderFoundIndex = orders.indexOf(orderFound);
        orders.set(orderFoundIndex, order);
    }

    private boolean orderAlreadyExists(UUID orderId) {
        return orders.stream().anyMatch(o -> o.id().equals(orderId));
    }
}

OrderBeerUseCase.java

package application;

import domain.*;

import java.util.ArrayList;
import java.util.UUID;

public class OrderBeerUseCase {
    private OrderRepository orderRepository;
    private GarbimMood garbimMood;
    private int limitOfBeersByCustomer;

    public OrderBeerUseCase(OrderRepository orderRepository, GarbimMood garbimMood, int limitOfBeersByCustomer) {
        this.orderRepository = orderRepository;
        this.garbimMood = garbimMood;
        this.limitOfBeersByCustomer = limitOfBeersByCustomer;
    }

    public void placeAnOrder(OrderDTO orderDTO) throws Throwable {

        String garbimMoodOfTheDay = garbimMood.moodOfTheDay(orderDTO.orderDate);
        if (! garbimMoodOfTheDay.equals("HAPPY")) {
            throw new GarbimIsNotHappy();
        }

        int amountOfBeer = 0;
        ArrayList<Beer> beers = new ArrayList<Beer>();
        for (BeerDTO beerDTO: orderDTO.beers) {
            beers.add(Beer.make(UUID.randomUUID(), beerDTO.price, beerDTO.type));
            amountOfBeer += beerDTO.amount;
        }

        if (amountOfBeer > limitOfBeersByCustomer) {
            throw new AmountOfBeerPerCustomerHasBeenExceeded();
        }

        Address customerAddress = Address.create(
                orderDTO.customer.street,
                orderDTO.customer.city,
                orderDTO.customer.state,
                orderDTO.customer.postalCode
        );
        Customer customer = Customer.create(orderDTO.customer.fullName, orderDTO.customer.phoneNumber, customerAddress);

        Order order = Order.create(orderDTO.id, beers, customer);

        orderRepository.save(order);
    }
}

OrderBeerUseCaseTest.java

package application;

import domain.*;
import infrastructure.InMemoryOrderRepository;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Date;

public class OrderBeerUseCaseTest {

    @Test
    public void testShouldOrderBeer() throws Throwable {
        InMemoryOrderRepository repository = new InMemoryOrderRepository();
        GarbimMood garbimMood = new GarbimMood();
        OrderBeerUseCase orderBeer = new OrderBeerUseCase(repository, garbimMood, 5);
        OrderDTO orderDTO = createOrder(new Date(2021, 06, 15, 18, 30), 1);

        orderBeer.placeAnOrder(orderDTO);

        Order orderFound = repository.getById(orderDTO.id).get();
        Assertions.assertEquals(orderDTO.customer.fullName, orderFound.customer().fullName());
        Assertions.assertEquals(orderDTO.customer.city, orderFound.customer().address().city());
        Assertions.assertEquals(orderDTO.customer.street, orderFound.customer().address().street());
        Assertions.assertEquals(orderDTO.customer.state, orderFound.customer().address().state());
        Assertions.assertEquals(orderDTO.customer.phoneNumber, orderFound.customer().phoneNumber());
        Assertions.assertEquals(orderDTO.beers.get(0).type, orderFound.beers().get(0).type());
        Assertions.assertEquals(orderDTO.beers.get(0).price, orderFound.beers().get(0).price());
    }

    @Test
    public void testShouldThrowExceptionBecauseGarbimIsNotHappy() throws Throwable {
        InMemoryOrderRepository repository = new InMemoryOrderRepository();
        GarbimMood garbimMood = new GarbimMood();
        OrderBeerUseCase orderBeer = new OrderBeerUseCase(repository, garbimMood, 5);
        OrderDTO orderDTO = createOrder(new Date(2021, 06, 11, 17, 00), 2);

        Assertions.assertThrows(GarbimIsNotHappy.class, () -> {
            orderBeer.placeAnOrder(orderDTO);
        });
    }

    @Test
    public void testShouldThrowExceptionBecauseAmountOfBeerPerCustomerHasBeenExceeded() throws Throwable {
        InMemoryOrderRepository repository = new InMemoryOrderRepository();
        GarbimMood garbimMood = new GarbimMood();
        OrderBeerUseCase orderBeer = new OrderBeerUseCase(repository, garbimMood, 5);
        OrderDTO orderDTO = createOrder(new Date(2021, 06, 15, 18, 30), 6);

        Assertions.assertThrows(AmountOfBeerPerCustomerHasBeenExceeded.class, () -> {
            orderBeer.placeAnOrder(orderDTO);
        });
    }

    private OrderDTO createOrder(Date orderDate, int amountOfBeer) {
        CustomerDTO customer = new CustomerDTO(
                "Antoni Santos",
                "14958374733",
                "Rua Salvador",
                "Campos",
                "SP",
                "84123458"
        );
        ArrayList<BeerDTO> beers = new ArrayList<BeerDTO>();
        beers.add(new BeerDTO("LAGER", 10.50, amountOfBeer));

        return new OrderDTO(customer, beers, orderDate);
    }
}

OrderRepository.java

package domain;

import java.util.Optional;
import java.util.UUID;

public interface OrderRepository {
    void save(Order order);
    Optional<Order> getById(UUID orderId);
    void delete(UUID orderId) throws OrderNotFound;
}