InMemoryAccountRepository.java

package de.japrost.jabudget.repository.inmemory;

import java.util.*;
import java.util.stream.Collectors;

import de.japrost.jabudget.domain.DomainException;
import de.japrost.jabudget.domain.DomainFailure;
import de.japrost.jabudget.domain.account.Account;
import de.japrost.jabudget.domain.account.Entry;
import de.japrost.jabudget.domain.account.EntryBuilder;
import de.japrost.jabudget.repository.AccountRepository;

/**
 * {@link AccountRepository} storing in memory without persistence. Mostly for test and development.<br>
 * This implementation is not thread safe.
 */
public class InMemoryAccountRepository implements AccountRepository {

    private final Map<String, Account> storage = new HashMap<>();
    private final Map<String, Collection<Entry>> entryStorage = new HashMap<>();

    /**
     * {@inheritDoc}
     * <p>
     * <strong>This implementation</strong> stores and gives defensive copies of the given account.
     */
    @Override
    public Account create(final Account account) throws DomainException {
        if (storage.containsKey(account.getId())) {
            throw new DomainException(DomainFailure.DUPLICATE_ENTITY);
        }
        return putInStoreDefensively(account);
    }

    /**
     * {@inheritDoc}
     * <p>
     * <strong>This implementation</strong> stores and gives defensive copies of the given account.
     */
    @Override
    public Account update(final Account account) throws DomainException {
        if (!storage.containsKey(account.getId())) {
            throw new DomainException(DomainFailure.MISSING_ENTITY);
        }
        return putInStoreDefensively(account);

    }

    /**
     * {@inheritDoc}
     * <p>
     * <strong>This implementation</strong> clears existing and adds defensive copies to store.
     */
    @Override
    public void replaceAll(final Set<Account> accounts) {
        storage.clear();
        entryStorage.clear();
        accounts.forEach(this::putInStoreDefensively);
    }

    private Account putInStoreDefensively(final Account account) {
        final Account accountToStore = new Account.Builder(account).build();
        storage.put(account.getId(), accountToStore);
        if (!entryStorage.containsKey(account.getId())) {
            entryStorage.put(account.getId(), new ArrayList<Entry>());
        }
        return new Account.Builder(account).build();
    }

    /**
     * {@inheritDoc}
     * <p>
     * <strong>This implementation</strong> gives a defensive copy of the stored accounts.
     */
    @Override
    public Optional<Account> findById(final String id) {
        return Account.Builder.builder(storage.get(id)).buildOptional();
    }

    /**
     * {@inheritDoc}
     * <p>
     * <strong>This implementation</strong> gives defensive copies of all stored accounts.
     */
    @Override
    public Set<Account> findAll() {
        return storage.values().stream().map(account -> new Account.Builder(account).build()).collect(Collectors.toSet());
    }

    /**
     * {@inheritDoc}
     * <p>
     * <strong>This implementation</strong> returns {@link Boolean#TRUE} always.
     */
    @Override
    public Boolean delete(final String accountId) {
        storage.remove(accountId);
        entryStorage.remove(accountId);
        return Boolean.TRUE;
    }

    @Override
    public Entry create(final Entry entry) throws DomainException {
        Collection<Entry> entries = entryStorage.get(entry.getAccountId());
        if (Objects.isNull(entries)) {
            throw new DomainException(DomainFailure.MISSING_ENTITY_REFERENCE);
        }
        if (entries.contains(entry)) {
            throw new DomainException(DomainFailure.DUPLICATE_ENTITY);
        }
        return putInStoreDefensively(entries, entry);
    }

    private Entry putInStoreDefensively(final Collection<Entry> entries, final Entry value) {
        final Entry toStore = EntryBuilder.builder(value).build();
        entries.add(toStore);
        return EntryBuilder.builder(toStore).build();
    }

}