package org.legrog.web.publisher; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.platform.runner.JUnitPlatform; import org.junit.runner.RunWith; import org.legrog.entities.*; import org.legrog.test.MockitoExtension; import org.legrog.web.xyz.SharedService; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.Mock; import org.mockito.Mockito; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.*; /** * Class testing PublisherServiceDefault */ @RunWith(JUnitPlatform.class) @ExtendWith(MockitoExtension.class) @DisplayName("Service layer for all publisher-related data") public class PublisherServiceDefaultTest { Logger logger = LoggerFactory.getLogger(getClass()); PublisherServiceDefault publisherServiceDefault; PublisherVersion publisherVersion; PublisherVersion publisherVersion1; Publisher publisher; PublisherRepository publisherRepository; PublisherVersionRepository publisherVersionRepository; @Mock PublisherVersion publisherVersionMock; @Captor ArgumentCaptor<IndexedPublisher> indexedPublisherArgumentCaptor; @BeforeEach public void setUp(@Mock PublisherRepository publisherRepository, @Mock PublisherVersionRepository publisherVersionRepository, @Mock PublisherActionRepository publisherActionRepository, @Mock PublisherSearchRepository publisherSearchRepository, @Mock SharedService sharedService) throws Exception { publisherServiceDefault = Mockito.spy(new PublisherServiceDefault(publisherRepository, publisherVersionRepository, publisherActionRepository, publisherSearchRepository, sharedService)); publisherVersion = new PublisherVersion(); publisherVersion1 = new PublisherVersion(); this.publisherRepository = publisherRepository; } @Nested @DisplayName("addNewPublisher method") class AddNewPublisherTests { @DisplayName("When a new publisher is added, both Publisher and PublisherVersion should be saved in the right state") @Test public void testAddNewPublisher(@Mock PublisherVersionRepository publisherVersionRepository) { publisherServiceDefault.addNewPublisher(publisherVersion); publisher = publisherVersion.getPublisher(); assertThat(publisher.getVersions()).containsExactly(publisherVersion); assertThat(publisherVersion.getPublisher()).isEqualTo(publisher); verify(publisherRepository).save(publisher); verify(publisherVersionRepository).save(publisherVersion); } } @Nested @DisplayName("addVersionToPublisher method") class AddVersionToPublisherTests { @DisplayName("When a new version of a publisher is added, setting it up, attaching it to publisher and saving both") @Test public void testAddVersionToPublisher(@Mock PublisherRepository publisherRepository, @Mock PublisherVersionRepository publisherVersionRepository) { publisherServiceDefault.addNewPublisher(publisherVersion); publisher = publisherVersion.getPublisher(); publisherServiceDefault.addVersionToPublisher(publisher, publisherVersion1); assertThat(publisherVersion1.getPublisher()).isEqualTo(publisher); assertThat(publisher.getVersions()).contains(publisherVersion, publisherVersion1); verify(publisherRepository, times(2)).save(publisher); verify(publisherVersionRepository).save(publisherVersion1); } } @Nested @DisplayName("addVersionToPublisher method") class ValidatePublisherVersionTests { @DisplayName("When a PublisherVersion is validated, it should be the right one") @Test public void testValidateVersionRight() { Set<PublisherVersion> publisherVersions; publisher = new Publisher(); publisherVersion = new PublisherVersion(); publisherVersions = new HashSet<>(); publisherVersions.add(publisherVersion); publisherVersions.add(publisherVersionMock); publisher.setVersions(publisherVersions); when(publisherVersionMock.getPublisher()).thenReturn(publisher); publisherServiceDefault.validatePublisherVersion(publisherVersionMock); assertThat(publisher.getValidatedVersion()).isEqualTo(publisherVersionMock); } @DisplayName("When a publisherVersion is validated, the indexed IndexedPublisher should have all attributes right") @Test public void testValidateIndexPublisher(@Mock PublisherSearchRepository publisherSearchRepository) { publisher = new Publisher(); publisher.setPublisherId(111); when(publisherVersionMock.getPublisher()).thenReturn(publisher); when(publisherVersionMock.getPublisherName()).thenReturn("nom"); when(publisherVersionMock.getPublisherHistory()).thenReturn("histoire"); publisherServiceDefault.validatePublisherVersion(publisherVersionMock); try { Mockito.verify(publisherSearchRepository).save(indexedPublisherArgumentCaptor.capture()); } catch (IndexingException e) { logger.error("IndexingException {}", e); } IndexedPublisher indexedPublisher = indexedPublisherArgumentCaptor.getValue(); assertThat(indexedPublisher.getPublisherId()).isEqualTo(111); assertThat(indexedPublisher.getPublisherName()).isEqualTo("nom"); assertThat(indexedPublisher.getPublisherHistory()).isEqualTo("histoire"); } @DisplayName("When a validate creates a PublisherAction it should be saved and have all attributes right") @Test public void testValidateCreateAction(@Mock PublisherActionRepository publisherActionRepository) { PublisherAction publisherAction; ActionType actionType = ActionType.VALIDATE; publisher = new Publisher(); when(publisherVersionMock.getPublisher()).thenReturn(publisher); publisherAction = publisherServiceDefault.validatePublisherVersion(publisherVersionMock); verify(publisherActionRepository).save(publisherAction); assertThat(publisherAction.getPublisherVersion()).isEqualTo(publisherVersionMock); assertThat(publisherAction.getPublisher()).isEqualTo(publisher); assertThat(publisherAction.getPublisher().getValidatedVersion()).isEqualTo(publisherVersionMock); assertThat(publisherAction.getActionType()).isEqualTo(actionType); } } @Nested @DisplayName("search method") class SearchTests { @DisplayName("When called, should delegate search to PublisherSearchRepository") @Test public void testDelegateSearchToPublisherSearchRepository(@Mock PublisherSearchRepository publisherSearchRepository) throws SearchingException { publisherServiceDefault.search("3"); Mockito.verify(publisherSearchRepository).search("3"); } @DisplayName("When getting IndexedPublishers from search, should convert them") @Test public void testConvertReturnedIndexedPublishers(@Mock PublisherSearchRepository publisherSearchRepository) throws SearchingException { List<IndexedPublisher> indexedPublishers = new ArrayList<>(); when(publisherSearchRepository.search("4")).thenReturn(indexedPublishers); publisherServiceDefault.search("4"); verify(publisherServiceDefault, times(1)).convert(indexedPublishers); } @DisplayName("When called, should return the PublisherVersions it gets from convert") @Test public void testReturnFromConvert(@Mock PublisherSearchRepository publisherSearchRepository) throws SearchingException { List<PublisherVersion> publisherVersions = new ArrayList<>(); List<IndexedPublisher> indexedPublishers = new ArrayList<>(); Mockito.doReturn(publisherVersions).when(publisherServiceDefault).convert(indexedPublishers); when(publisherSearchRepository.search("5")).thenReturn(indexedPublishers); assertThat(publisherServiceDefault.search("5")).isEqualTo(publisherVersions); } } @Nested @DisplayName("convert method") class ConvertTests { @DisplayName("When called, should return the PublisherVersions it gets from findByPublisherVersionIdIn") @Test public void testReturnFromFind(@Mock PublisherVersionRepository publisherVersionRepository) { List<PublisherVersion> publisherVersions = new ArrayList<>(); List<IndexedPublisher> indexedPublishers = new ArrayList<>(); when(publisherVersionRepository.findByPublisherVersionIdIn(Mockito.any())).thenReturn(publisherVersions); assertThat(publisherServiceDefault.convert(indexedPublishers)).isEqualTo(publisherVersions); } } }