Mockito tests example

gistfile1.txt

package com.ifood.merchant.core.service;

import com.ifood.merchant.core.converter.domain.GroupClientToGroupConverter;
import com.ifood.merchant.core.domain.Group;
import com.ifood.merchant.core.domain.Store;
import com.ifood.merchant.core.repository.GroupJpaRepository;
import com.ifood.merchant.model.GroupClientDTO;
import com.ifood.merchant.model.enums.GroupType;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

import javax.persistence.EntityManager;

import java.util.ArrayList;
import java.util.HashMap;

import static org.junit.Assert.*;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class GroupServiceTest {

    private static final String EXTERNAL_ID_TEST = "EXTERNAL_ID_TEST";
    private static final String DESCRIPTION_TEST = "Description test";
    private static final String SECOND_NAME_TEST = "Second name test";
    private static final String NAME_TEST = "Name test";

    private static final String SYSTEM_ID = "SYSTEM_ID";
    private static final String USER_ID = "USER_ID";


    @Mock
    private GroupJpaRepository repository;
    @Mock
    private GroupClientToGroupConverter toUnmanagedGroup;
    @Mock
    private EntityManager entityManager;

    @InjectMocks
    private GroupService groupService;

    @Rule
    public ExpectedException thrown = ExpectedException.none();

    private ArgumentCaptor<Group> groupArgumentCaptor;

    private GroupClientDTO mockGroupDTO;

    @Before
    public void setUp() {
        mockGroupDTO = buildMockGroupDTO();

        when(toUnmanagedGroup.convert(any())).thenCallRealMethod();

        groupArgumentCaptor = ArgumentCaptor.forClass(Group.class);
    }

    @Test
    public void createGroup() {
        groupService.create(SYSTEM_ID, USER_ID, mockGroupDTO);

        verify(repository).save(groupArgumentCaptor.capture());
        Group groupCreated = groupArgumentCaptor.getValue();

        assertNotNull(groupCreated.getId());
        assertEquals(EXTERNAL_ID_TEST, groupCreated.getExternalId());
        assertEquals(DESCRIPTION_TEST, groupCreated.getDescription());
        assertEquals(SECOND_NAME_TEST, groupCreated.getSecondName());
        assertEquals(NAME_TEST, groupCreated.getName());
        assertEquals(GroupType.GROUP, groupCreated.getType());
        assertTrue(groupCreated.isEnabled());

        assertNotNull(groupCreated.getSubGroups());
        assertNotNull(groupCreated.getStores());
    }

    @Test
    public void createGroupShouldThrowExceptionIfTypeIsNotSet() {
        mockGroupDTO.setType(null);
        thrown.expect(IllegalArgumentException.class);
        thrown.expectMessage("Can't create a group without type");

        groupService.create(SYSTEM_ID, USER_ID, mockGroupDTO);
    }

    @Test
    public void createCompanyGroupWithoutExternalIdShouldThrowException()  {
        mockGroupDTO.setType(GroupType.COMPANY);
        mockGroupDTO.setExternalId(null);

        thrown.expect(IllegalArgumentException.class);
        thrown.expectMessage("Can't create a group with COMPANY type without External ID");

        groupService.create(SYSTEM_ID, USER_ID, mockGroupDTO);
    }

    @Test
    public void createGroupShouldPutIDasExternalIdIfDontHaveIt()  {
        mockGroupDTO.setType(GroupType.REGION);
        mockGroupDTO.setExternalId(null);

        groupService.create(SYSTEM_ID, USER_ID, mockGroupDTO);

        verify(repository).save(groupArgumentCaptor.capture());
        Group groupCreated = groupArgumentCaptor.getValue();

        assertNotNull(groupCreated.getExternalId());
        assertEquals(groupCreated.getId().toString(), groupCreated.getExternalId());
    }

    private GroupClientDTO buildMockGroupDTO() {
        return GroupClientDTO.builder()
                .externalId(EXTERNAL_ID_TEST)
                .subGroups(new ArrayList<>())
                .stores(new ArrayList<>())
                .metaData(new HashMap<>())
                .description(DESCRIPTION_TEST)
                .secondName(SECOND_NAME_TEST)
                .name(NAME_TEST)
                .type(GroupType.GROUP)
                .build();
    }
}