wallet

package com.team16.virtualwallet.services;

import com.team16.virtualwallet.exceptions.DuplicateEntityException;
import com.team16.virtualwallet.models.Currency;
import com.team16.virtualwallet.models.DTOs.CardDTO;
import com.team16.virtualwallet.models.DTOs.WalletDto;
import com.team16.virtualwallet.models.User;
import com.team16.virtualwallet.models.Wallet;
import com.team16.virtualwallet.models.mappers.WalletMapper;
import com.team16.virtualwallet.repositories.CurrencyRepository;
import com.team16.virtualwallet.repositories.UserRepository;
import com.team16.virtualwallet.repositories.WalletRepository;
import com.team16.virtualwallet.services.contracts.UserService;
import com.team16.virtualwallet.services.contracts.WalletService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;

import javax.persistence.EntityNotFoundException;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;

import static com.team16.virtualwallet.Factory.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;

@RunWith(MockitoJUnitRunner.class)
public class WalletServiceImplTests {

    @Mock
    WalletMapper walletMapper;

    @Mock
    WalletRepository mockWalletRepository;

    @Mock
    CurrencyRepository mockCurrencyRepository;

    @Mock
    UserRepository mockUserRepo;



    @InjectMocks
    WalletServiceIml mockWalletsService;

    @Test
    public void create_Should_ReturnWallet_WhenSuccessful() {
        //Arrange
        Wallet wallet = createWallet();
        WalletDto receivedWalletDTO = createWalletDto();
        User user = createUser();


        when(mockUserRepo.findByUsernameAndEnabledIsTrue(anyString())).thenReturn(java.util.Optional.of(user));
        when(mockWalletRepository.existsByNameAndCreator(anyString(), any(User.class))).thenReturn(false);
        when(walletMapper.mapToWallet(receivedWalletDTO)).thenReturn(wallet);
        //userRepository.findByUsernameAndEnabledIsTrue(creator)

        //Act
        mockWalletsService.create(receivedWalletDTO);
        //Assert
        Mockito.verify(mockWalletRepository, Mockito.times(1)).save(wallet);
    }


    @Test(expected = DuplicateEntityException.class)
    public void create_Should_ThrowException_WhenEntityIsAlreadyCreated() {
        //Arrange
        Wallet wallet = createWallet();
        WalletDto receivedWalletDTO = createWalletDto();
        User user = createUser();


        when(mockUserRepo.findByUsernameAndEnabledIsTrue(anyString())).thenReturn(java.util.Optional.of(user));
        when(mockWalletRepository.existsByNameAndCreator(anyString(), any(User.class))).thenReturn(true);

        //userRepository.findByUsernameAndEnabledIsTrue(creator)

        //Act
        mockWalletsService.create(receivedWalletDTO);
        //Assert
        Mockito.verify(mockWalletRepository, Mockito.times(1)).save(wallet);
    }

    @Test
    public void update_Should_CallRepository() {
        //Arrange
        Wallet wallet = createWallet();
        wallet.setCreator(createUser());

        when(mockWalletRepository.findById(1)).thenReturn(wallet);
        //Act
        mockWalletsService.update(1, wallet, wallet.getCreator().getUsername());
        //Arrange
        Mockito.verify(mockWalletRepository, Mockito.times(1)).save(wallet);
    }

    @Test
    public void addMoneyToWalletFromCard_Should_CallRepository() {
        //Arrange
        Wallet wallet = createWallet();

        when(mockWalletRepository.findById(anyInt())).thenReturn(wallet);
        //Act
        mockWalletsService.addMoneyToWalletFromCard(new BigDecimal("40"), anyInt());
        //Arrange
        Mockito.verify(mockWalletRepository, Mockito.times(1)).save(wallet);
    }

    @Test
    public void getUserCard_Should_CallRepository() {
        //Arrange
        Wallet wallet = createWallet();

        when(mockWalletRepository.findById(anyInt())).thenReturn(wallet);
        //Act
        mockWalletsService.addMoneyToWalletFromCard(new BigDecimal("40"), anyInt());
        //Arrange
        Mockito.verify(mockWalletRepository, Mockito.times(1)).save(wallet);
    }

    @Test
    public void findById_Should_CallRepository() {
        //Arrange
        Wallet wallet = createWallet();

        when(mockWalletRepository.findById(anyInt())).thenReturn(wallet);
        //Act
        mockWalletsService.findById(anyInt());
        //Arrange
        Mockito.verify(mockWalletRepository, Mockito.times(1)).findById(anyInt());
    }

    @Test
    public void getAll_Should_CallRepository() {

        mockWalletsService.getUsersWallets("testUsername", "testWalletName",PageRequest.of(1, 8));

        verify(mockWalletRepository,times(1)).getAllUserWallets("testUsername", "testWalletName",PageRequest.of(1, 8));
    }

    @Test
    public void findByCurrencies_Should_CallRepository() {
        Currency currency = createCurrency();
        List<Currency> currencies = new ArrayList<>();
        currencies.add(currency);

        when(mockCurrencyRepository.getAllBy()).thenReturn(currencies);

        mockWalletsService.findPossibleWalletCurr();

        Mockito.verify(mockCurrencyRepository, Mockito.times(1)).getAllBy();
    }

    @Test
    public void create_Should_CallRepository() {
        WalletDto walletDto = createWalletDto();
        User user = createUser();
        walletDto.setCreator(user.getUsername());


        when(mockUserRepo.findByUsernameAndEnabledIsTrue(anyString()))
                .thenReturn(Optional.of(user));

        mockWalletsService.create(walletDto);

        Mockito.verify(mockUserRepo, Mockito.times(1)).save(user);
    }


}