Añade test de refrescado de capas

 */

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;

import org.junit.ClassRule;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mapstruct.factory.Mappers;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.util.concurrent.ListenableFuture;

import es.redmic.atlaslib.dto.layer.LayerDTO;

import es.redmic.atlaslib.dto.layerwms.LayerWMSDTO;

import es.redmic.atlaslib.events.layer.LayerEventTypes;

import es.redmic.atlaslib.events.layer.create.CreateLayerConfirmedEvent;

import es.redmic.atlaslib.events.layer.create.CreateLayerEvent;

import es.redmic.atlaslib.events.layer.delete.DeleteLayerConfirmedEvent;

import es.redmic.atlaslib.events.layer.delete.DeleteLayerEvent;

import es.redmic.atlaslib.events.layer.delete.DeleteLayerFailedEvent;

import es.redmic.atlaslib.events.layer.refresh.RefreshLayerConfirmedEvent;

import es.redmic.atlaslib.events.layer.refresh.RefreshLayerEvent;

import es.redmic.atlaslib.events.layer.update.UpdateLayerConfirmedEvent;

import es.redmic.atlaslib.events.layer.update.UpdateLayerEvent;

import es.redmic.atlaslib.events.layer.update.UpdateLayerFailedEvent;

import es.redmic.atlasview.AtlasViewApplication;

import es.redmic.atlasview.mapper.layer.LayerESMapper;

import es.redmic.atlasview.model.category.Category;

import es.redmic.atlasview.model.layer.Layer;

import es.redmic.atlasview.repository.category.CategoryESRepository;

import es.redmic.models.es.data.common.model.DataHitWrapper;

import es.redmic.testutils.documentation.DocumentationViewBaseTest;

import es.redmic.testutils.utils.JsonToBeanTestUtil;

import es.redmic.viewlib.config.MapperScanBeanItfc;

@SpringBootTest(classes = { AtlasViewApplication.class })

@RunWith(SpringJUnit4ClassRunner.class)

	private static final String USER_ID = "1";

	@Autowired

	MapperScanBeanItfc mapper;

	@Autowired

	LayerESRepository repository;

	}

	@Test

	public void sendLayerUpdatedEvent_callUpdate_IfEventIsOk() throws Exception {

	public void sendUpdateLayerEvent_callUpdate_IfEventIsOk() throws Exception {

		UpdateLayerEvent event = getUpdateLayerEvent();

		repository.save(mapper.getMapperFacade().map(event.getLayer(), Layer.class),

		repository.save(Mappers.getMapper(LayerESMapper.class).map(event.getLayer()),

				event.getLayer().getParent().getId());

		ListenableFuture<SendResult<String, Event>> future = kafkaTemplate.send(LAYER_TOPIC, event.getAggregateId(),

		assertEquals(layer.getName(), event.getLayer().getName());

	}

	@Test

	public void sendRefreshLayerEvent_callRefresh_IfEventIsOk() throws Exception {

		RefreshLayerEvent event = getRefreshLayerEvent();

		event.getLayer().setQueryable(false);

		LayerDTO layer = getLayer();

		repository.save(Mappers.getMapper(LayerESMapper.class).map(layer), layer.getParent().getId());

		ListenableFuture<SendResult<String, Event>> future = kafkaTemplate.send(LAYER_TOPIC, event.getAggregateId(),

				event);

		future.addCallback(new SendListener());

		RefreshLayerConfirmedEvent confirm = (RefreshLayerConfirmedEvent) blockingQueue.poll(50, TimeUnit.SECONDS);

		// Se restablece el estado de la vista

		repository.delete(event.getLayer().getId(), layer.getParent().getId());

		assertNotNull(confirm);

		assertEquals(LayerEventTypes.REFRESH_CONFIRMED.toString(), confirm.getType());

		LayerDTO result = confirm.getLayer();

		assertEquals(result.getId(), event.getAggregateId());

		assertEquals(result.getName(), event.getLayer().getName());

		// Se modifica bien el campo al refrescar

		assertFalse(layer.getQueryable().equals(result.getQueryable()));

	}

	@Test(expected = ItemNotFoundException.class)

	public void sendLayerDeleteEvent_callDelete_IfEventIsOk() throws Exception {

		String parentId = original.getParent().getId();

		repository.save(mapper.getMapperFacade().map(original, Layer.class), parentId);

		repository.save(Mappers.getMapper(LayerESMapper.class).map(original), parentId);

		ListenableFuture<SendResult<String, Event>> future = kafkaTemplate.send(LAYER_TOPIC, event.getAggregateId(),

				event);

		CreateLayerEvent event = getCreateLayerEvent();

		repository.save(mapper.getMapperFacade().map(event.getLayer(), Layer.class),

		repository.save(Mappers.getMapper(LayerESMapper.class).map(event.getLayer()),

				event.getLayer().getParent().getId());

		ListenableFuture<SendResult<String, Event>> future = kafkaTemplate.send(LAYER_TOPIC, event.getAggregateId(),

		conflict.setName(original.getName() + "cpy");

		// Guarda el que se va a modificar

		repository.save(mapper.getMapperFacade().map(original, Layer.class), original.getParent().getId());

		repository.save(Mappers.getMapper(LayerESMapper.class).map(original), original.getParent().getId());

		// Guarda el que va a entrar en conflicto

		repository.save(mapper.getMapperFacade().map(conflict, Layer.class), conflict.getParent().getId());

		repository.save(Mappers.getMapper(LayerESMapper.class).map(conflict), conflict.getParent().getId());

		// Edita el nombre del que se va a modificar para entrar en conflicto (mismo

		// nombre y urlsource con distinto id)

		blockingQueue.offer(deleteLayerFailedEvent);

	}

	@KafkaHandler

	public void refreshLayerConfirmed(RefreshLayerConfirmedEvent refreshLayerConfirmedEvent) {

		blockingQueue.offer(refreshLayerConfirmedEvent);

	}

	@KafkaHandler(isDefault = true)

	public void defaultEvent(Object def) {

		return updatedEvent;

	}

	protected RefreshLayerEvent getRefreshLayerEvent() throws IOException {

		RefreshLayerEvent refreshEvent = new RefreshLayerEvent();

		refreshEvent.setId(UUID.randomUUID().toString());

		refreshEvent.setDate(DateTime.now());

		refreshEvent.setType(LayerEventTypes.UPDATE);

		LayerWMSDTO layer = (LayerWMSDTO) JsonToBeanTestUtil.getBean("/data/dto/layer/layerWMS.json",

				LayerWMSDTO.class);

		layer.setName(layer.getName() + "2");

		refreshEvent.setLayer(layer);

		refreshEvent.setAggregateId(refreshEvent.getLayer().getId());

		refreshEvent.setVersion(2);

		refreshEvent.setSessionId(UUID.randomUUID().toString());

		refreshEvent.setUserId(USER_ID);

		return refreshEvent;

	}

	protected DeleteLayerEvent getDeleteLayerEvent() throws IOException {

		DeleteLayerEvent deletedEvent = new DeleteLayerEvent();