package org.molgenis.data.elasticsearch.index;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.molgenis.data.DataService;
import org.molgenis.data.Entity;
import org.molgenis.data.Repository;
import org.molgenis.data.elasticsearch.SearchService;
import org.molgenis.data.elasticsearch.bootstrap.IndexBootstrapper;
import org.molgenis.data.elasticsearch.index.job.IndexJobExecution;
import org.molgenis.data.elasticsearch.index.job.IndexJobExecutionMeta;
import org.molgenis.data.index.IndexActionRegisterService;
import org.molgenis.data.index.meta.IndexAction;
import org.molgenis.data.index.meta.IndexActionMetaData;
import org.molgenis.data.jobs.model.JobExecutionMetaData;
import org.molgenis.data.meta.MetaDataService;
import org.molgenis.data.meta.model.AttributeMetadata;
import org.molgenis.data.support.QueryImpl;
import org.molgenis.test.data.AbstractMolgenisSpringTest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
import static org.mockito.Mockito.*;
import static org.mockito.MockitoAnnotations.initMocks;
import static org.molgenis.data.jobs.model.JobExecutionMetaData.FAILED;
@ContextConfiguration(classes = { IndexBootstrapperTest.Config.class })
public class IndexBootstrapperTest extends AbstractMolgenisSpringTest
{
@Autowired
private Config config;
@Autowired
private MetaDataService metaDataService;
@Autowired
private SearchService searchService;
@Autowired
private IndexActionRegisterService indexActionRegisterService;
@Autowired
private DataService dataService;
IndexBootstrapper indexBootstrapper;
@BeforeMethod
public void beforeMethod()
{
initMocks(this);
config.resetMocks();
indexBootstrapper = new IndexBootstrapper(metaDataService, searchService, indexActionRegisterService,
dataService);
}
@Test
public void testStartupNoIndex()
{
@SuppressWarnings("unchecked")
Repository<Entity> repo1 = mock(Repository.class);
when(repo1.getName()).thenReturn("repo1");
@SuppressWarnings("unchecked")
Repository<Entity> repo2 = mock(Repository.class);
when(repo2.getName()).thenReturn("repo2");
@SuppressWarnings("unchecked")
Repository<Entity> repo3 = mock(Repository.class);
when(repo3.getName()).thenReturn("repo3");
List<Repository<Entity>> repos = Arrays.asList(repo1, repo2, repo3);
when(searchService.hasMapping(AttributeMetadata.ATTRIBUTE_META_DATA)).thenReturn(false);
when(metaDataService.getRepositories()).thenReturn(repos.stream());
indexBootstrapper.bootstrap();
//verify that new jobs are registered for all repos
verify(indexActionRegisterService).register("repo1", null);
verify(indexActionRegisterService).register("repo2", null);
verify(indexActionRegisterService).register("repo3", null);
}
@Test
public void testStartupFailedIndexJobs()
{
when(searchService.hasMapping(AttributeMetadata.ATTRIBUTE_META_DATA)).thenReturn(true);
IndexJobExecution indexJobExecution = mock(IndexJobExecution.class);
when(indexJobExecution.getIndexActionJobID()).thenReturn("id");
IndexAction action = mock(IndexAction.class);
when(action.getEntityFullName()).thenReturn("myEntity");
when(action.getEntityId()).thenReturn("myEntityId");
when(dataService.findAll(IndexJobExecutionMeta.INDEX_JOB_EXECUTION,
new QueryImpl<IndexJobExecution>().eq(JobExecutionMetaData.STATUS, FAILED), IndexJobExecution.class))
.thenReturn(Stream.of(indexJobExecution));
when(dataService.findAll(IndexActionMetaData.INDEX_ACTION,
new QueryImpl<IndexAction>().eq(IndexActionMetaData.INDEX_ACTION_GROUP_ATTR, "id"), IndexAction.class))
.thenReturn(Stream.of(action));
indexBootstrapper.bootstrap();
//verify that we are not passing through the "missing index" code
verify(metaDataService, never()).getRepositories();
//verify that a new job is registered for the failed one
verify(indexActionRegisterService).register("myEntity", "myEntityId");
}
@Test
public void testStartupAllIsFine()
{
when(searchService.hasMapping(AttributeMetadata.ATTRIBUTE_META_DATA)).thenReturn(true);
when(dataService.findAll(IndexJobExecutionMeta.INDEX_JOB_EXECUTION,
new QueryImpl<IndexJobExecution>().eq(JobExecutionMetaData.STATUS, FAILED),
IndexJobExecution.class))
.thenReturn(Collections.<IndexJobExecution>emptyList().stream());
indexBootstrapper.bootstrap();
//verify that no new jobs are registered
verify(indexActionRegisterService, never()).register(Mockito.anyString(), Mockito.anyString());
}
@Configuration
public static class Config
{
@Mock
DataService dataService;
@Mock
SearchService searchService;
@Mock
IndexActionRegisterService indexActionRegisterService;
@Mock
MetaDataService metaDataService;
public Config()
{
initMocks(this);
}
@Bean
public DataService dataService()
{
return dataService;
}
@Bean
public SearchService searchService()
{
return searchService;
}
@Bean
public IndexActionRegisterService indexActionRegisterService()
{
return indexActionRegisterService;
}
@Bean
public MetaDataService metaDataService()
{
return metaDataService;
}
void resetMocks()
{
reset(dataService, searchService, indexActionRegisterService, metaDataService);
}
}
}