package com.deious.service.account;

import com.deious.domain.account.Account;
import com.deious.repository.account.AccountRepository;
import com.prociss.paragon.testing.specification.AfterInvocation;
import com.prociss.paragon.testing.specification.BeforeInvocation;
import com.prociss.paragon.testing.specification.InvalidInvocation;
import com.prociss.paragon.testing.specification.SpecificationCallback;
import com.prociss.paragon.testing.specification.ValidInvocation;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.runners.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;

import static com.prociss.paragon.testing.specification.Specifications.emailSpec;
import static com.prociss.paragon.testing.specification.ValidationVerifier.specification;
import static org.fest.assertions.Assertions.assertThat;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class AccountServiceTest {

    @Mock
    private AccountRepository accountRepository;

    private AccountService accountService;

    @Before
    public void setupService() {
        this.accountService = new AccountService(accountRepository);
    }

    @Test
    public void verifyCreateAccountParameterValidation() throws Throwable {

        specification(
                accountService,
                "createAccount",
                Account.class,
                new CreateAccountCallback(),
                emailSpec().notNull());

    }

    public class CreateAccountCallback implements SpecificationCallback {

        @BeforeInvocation
        public void setupMock() {

            when(accountRepository.save(any(Account.class))).thenAnswer(new Answer<Account>() {
                @Override
                public Account answer(InvocationOnMock invocation) throws Throwable {
                    Account account = (Account) invocation.getArguments()[0];
                    return new Account(account.getEmail());
                }
            });
        }

        @ValidInvocation
        public void validEmail(final String validEmail, final Account returnedAccount) {

            ArgumentCaptor<Account> accountCaptor = ArgumentCaptor.forClass(Account.class);
            verify(accountRepository).save(accountCaptor.capture());

            Account savedAccount = accountCaptor.getValue();

            assertThat(savedAccount.getEmail()).isEqualTo(validEmail);
            assertThat(returnedAccount.getEmail()).isEqualTo(validEmail);
        }

        @InvalidInvocation
        public void invalidEmail(final String invalidEmail) {

            verifyZeroInteractions(accountRepository);

        }

        @AfterInvocation
        public void resetMock() {

            reset(accountRepository);
        }


    }

}