Commit b7675aeb authored by Noel Alonso's avatar Noel Alonso
Browse files

Añade tests para ciclo de resfresco de capas

parent 1350d838

atlas-commands/src/test/java/es/redmic/test/atlascommands/integration/layer/LayerCommandHandlerTest.java

+75 −0
Original line number Diff line number Diff line
@@ -70,6 +70,11 @@ import es.redmic.atlaslib.events.layer.delete.DeleteLayerCheckedEvent; 
import es.redmic.atlaslib.events.layer.delete.DeleteLayerConfirmedEvent;

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

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

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

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

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

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

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

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

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

import es.redmic.atlaslib.events.layer.update.UpdateLayerConfirmedEvent;
@@ -172,6 +177,30 @@ public class LayerCommandHandlerTest extends KafkaBaseIntegrationTest { 
				((LayerUpdatedEvent) confirm).getLayer().toString(), false);

	}



	// Envía un evento de confirmación de refrescado y debe provocar un evento

	// Refreshed con el item dentro

	@Test

	public void refreshLayerConfirmedEvent_SendLayerRefreshedEvent_IfReceivesSuccess()

			throws InterruptedException, JSONException {



		logger.debug("----> refreshLayerConfirmedEvent");



		// Envía refresh para meterlo en el stream

		RefreshLayerEvent refreshLayerEvent = LayerDataUtil.getRefreshEvent(code + "2a");

		kafkaTemplate.send(layer_topic, refreshLayerEvent.getAggregateId(), refreshLayerEvent);



		// Envía confirmed y espera un evento de refreshed con el layer refrescado

		// dentro

		RefreshLayerConfirmedEvent event = LayerDataUtil.getRefreshLayerConfirmedEvent(code + "2a");

		kafkaTemplate.send(layer_topic, event.getAggregateId(), event);

		Event confirm = (Event) blockingQueue.poll(60, TimeUnit.SECONDS);



		assertNotNull(confirm);

		assertEquals(LayerEventTypes.REFRESHED, confirm.getType());

		JSONAssert.assertEquals(refreshLayerEvent.getLayer().toString(),

				((LayerRefreshedEvent) confirm).getLayer().toString(), false);

	}



	// Envía un evento de comprobación de que el elemento puede ser borrado y debe

	// provocar un evento DeleteLayerCheckedEvent ya que no está referenciado

	@Test
@@ -281,6 +310,46 @@ public class LayerCommandHandlerTest extends KafkaBaseIntegrationTest { 
		assertEquals(layerUpdateEvent.getLayer(), ((UpdateLayerCancelledEvent) confirm).getLayer());

	}



	// Envía un evento de error de refrescado y debe provocar un evento Cancelled

	// con el item dentro

	@Test(expected = ItemNotFoundException.class)

	public void refreshLayerFailedEvent_SendLayerCancelledEvent_IfReceivesSuccess() throws Exception {



		logger.debug("----> refreshLayerFailedEvent");



		// Envía created para meterlo en el stream y lo saca de la cola

		LayerCreatedEvent layerCreatedEvent = LayerDataUtil.getLayerCreatedEvent(code + "5a");

		layerCreatedEvent.getLayer().setName("Nombre erroneo al crearlo");

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

		kafkaTemplate.send(layer_topic, layerCreatedEvent.getAggregateId(), layerCreatedEvent);

		blockingQueue.poll(10, TimeUnit.SECONDS);



		// Envía refresh para meterlo en el stream y lo saca de la cola

		RefreshLayerEvent refreshLayerEvent = LayerDataUtil.getRefreshEvent(code + "5a");

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

		kafkaTemplate.send(layer_topic, refreshLayerEvent.getAggregateId(), refreshLayerEvent);

		blockingQueue.poll(20, TimeUnit.SECONDS);



		Thread.sleep(3000);



		// Envía failed y espera un evento de cancelled con el layer original dentro

		RefreshLayerFailedEvent event = LayerDataUtil.getRefreshLayerFailedEvent(code + "5a");



		// Añade completableFeature para que se resuelva al recibir el mensaje.

		CompletableFuture<LayerDTO> completableFuture = Whitebox.invokeMethod(layerCommandHandler,

				"getCompletableFeature", event.getSessionId(), LayerDataUtil.getLayer(code + "5a"));



		kafkaTemplate.send(layer_topic, event.getAggregateId(), event);

		Event confirm = (Event) blockingQueue.poll(30, TimeUnit.SECONDS);



		// Obtiene el resultado

		Whitebox.invokeMethod(layerCommandHandler, "getResult", event.getSessionId(), completableFuture);



		assertNotNull(confirm);

		assertEquals(LayerEventTypes.REFRESH_CANCELLED, confirm.getType());

		assertEquals(layerCreatedEvent.getLayer(), ((RefreshLayerCancelledEvent) confirm).getLayer());

	}



	// Envía un evento de error de borrado y debe provocar un evento Cancelled con

	// el item dentro

	@Test(expected = DeleteItemException.class)
@@ -340,6 +409,12 @@ public class LayerCommandHandlerTest extends KafkaBaseIntegrationTest { 
		blockingQueue.offer(layerUpdatedEvent);

	}



	@KafkaHandler

	public void layerRefreshedEvent(LayerRefreshedEvent layerRefreshedEvent) {



		blockingQueue.offer(layerRefreshedEvent);

	}



	@KafkaHandler

	public void updateLayerCancelledEvent(UpdateLayerCancelledEvent updateLayerCancelledEvent) {

atlas-commands/src/test/java/es/redmic/test/atlascommands/integration/layer/LayerDataUtil.java

+167 −26
Original line number Diff line number Diff line
@@ -30,14 +30,18 @@ import java.util.UUID; 
import org.geotools.geometry.jts.JTSFactoryFinder;

import org.joda.time.DateTime;

import org.locationtech.jts.geom.Coordinate;

import org.locationtech.jts.geom.Polygon;



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

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

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

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

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

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

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

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

import es.redmic.atlaslib.dto.layerinfo.LayerInfoDTO;

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;
@@ -48,6 +52,11 @@ 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.delete.LayerDeletedEvent;

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

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

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

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

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

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

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

import es.redmic.atlaslib.events.layer.update.UpdateLayerEvent;
@@ -195,6 +204,66 @@ public abstract class LayerDataUtil { 
		return event;

	}



	// Refresh



	public static RefreshLayerEvent getRefreshEvent(String code) {



		RefreshLayerEvent event = new RefreshLayerEvent();

		event.setAggregateId(PREFIX + code);

		event.setType(LayerEventTypes.REFRESH);

		event.setVersion(2);

		event.setUserId(USER);

		event.setSessionId("sessionIdD");

		event.setLayer(getLayerWMS(code));



		return event;

	}



	public static RefreshLayerConfirmedEvent getRefreshLayerConfirmedEvent(String code) {



		RefreshLayerConfirmedEvent event = new RefreshLayerConfirmedEvent().buildFrom(getRefreshEvent(code));

		event.setType(LayerEventTypes.REFRESH_CONFIRMED);

		event.setLayer(getLayer(code));

		return event;

	}



	public static LayerRefreshedEvent getLayerRefreshedEvent(String code) {



		LayerRefreshedEvent event = new LayerRefreshedEvent().buildFrom(getRefreshEvent(code));

		event.setType(LayerEventTypes.REFRESHED);

		event.setLayer(getLayer(code));

		return event;

	}



	public static RefreshLayerFailedEvent getRefreshLayerFailedEvent(String code) {



		RefreshLayerFailedEvent event = new RefreshLayerFailedEvent().buildFrom(getRefreshEvent(code));

		event.setType(LayerEventTypes.REFRESH_FAILED);



		event.setExceptionType(ExceptionType.ITEM_NOT_FOUND.name());



		Map<String, String> arguments = new HashMap<String, String>();

		arguments.put("a", "b");

		event.setArguments(arguments);



		return event;

	}



	public static RefreshLayerCancelledEvent getRefreshLayerCancelledEvent(String code) {



		RefreshLayerCancelledEvent event = new RefreshLayerCancelledEvent().buildFrom(getRefreshEvent(code));

		event.setType(LayerEventTypes.REFRESH_CANCELLED);



		event.setExceptionType(ExceptionType.ITEM_NOT_FOUND.name());



		Map<String, String> arguments = new HashMap<String, String>();

		arguments.put("a", "b");

		event.setArguments(arguments);



		event.setLayer(getLayer(code));

		return event;

	}



	public static LayerInfoDTO getLayerInfo(String code) {



		LayerInfoDTO layerInfo = new LayerInfoDTO();
@@ -217,11 +286,15 @@ public abstract class LayerDataUtil { 
		return layerInfo;

	}



	@SuppressWarnings("serial")

	public static LayerDTO getLayer(String code) {



		LayerDTO layer = new LayerDTO();



		layer.setLegend("https://redmic.local/ww");

		layer.setAttribution(getAttribution());

		layer.setTimeDimension(getDimension());

		layer.setElevationDimension(getDimension());



		layer.setId(PREFIX + code);

		layer.setName("Prueba");

		layer.setTitle("title");
@@ -245,46 +318,101 @@ public abstract class LayerDataUtil { 
		formats.add("WMS");

		layer.setFormats(formats);



		layer.setGeometry(getGeometry());

		layer.setActivities(getActivities());

		layer.setContact(getContact());

		layer.setParent(CategoryDataUtil.getCategory("3442"));

		layer.setThemeInspire(ThemeInspireDataUtil.getThemeInspire("cc"));

		layer.setProtocols(getProtocols());

		layer.setLatLonBoundsImage(getLatLonBoundingBoxDTO());

		layer.setStylesLayer(getStylesLayer());



		return layer;

	}



	public static LayerWMSDTO getLayerWMS(String code) {



		LayerWMSDTO layer = new LayerWMSDTO();



		layer.setLegend("https://redmic.local/ww");

		layer.setAttribution(getAttribution());

		layer.setTimeDimension(getDimension());

		layer.setElevationDimension(getDimension());

		layer.setId(PREFIX + code);

		layer.setName("Prueba");

		layer.setTitle("title");

		layer.setAbstractLayer("Prueba");

		layer.setImage("Prueba");



		List<String> srs = new ArrayList<>();

		srs.add("srs");

		layer.setSrs(srs);



		List<String> keywords = new ArrayList<>();

		keywords.add("keywords");

		layer.setKeywords(keywords);



		List<String> formats = new ArrayList<>();

		formats.add("WMS");

		layer.setFormats(formats);



		layer.setGeometry(getGeometry());

		layer.setActivities(getActivities());

		layer.setContact(getContact());

		layer.setStylesLayer(getStylesLayer());



		return layer;

	}



	private static AttributionDTO getAttribution() {



		AttributionDTO attribution = new AttributionDTO();

		attribution.setTitle("title");

		return attribution;

	}



	private static ContactDTO getContact() {



		ContactDTO contact = new ContactDTO();

		contact.setName("Pepe");



		return contact;

	}



	public static DimensionDTO getDimension() {



		DimensionDTO dimension = new DimensionDTO();

		dimension.setName("time");

		dimension.setUnits("ISO8601");

		dimension.setDefaultValue("P30M/PRESENT");



		return dimension;

	}



	public static Polygon getGeometry() {



		Coordinate[] coordinates = new Coordinate[] { new Coordinate(-18.1745567321777, 27.6111183166504),

				new Coordinate(-18.1745567321777, 29.4221172332764),

				new Coordinate(-13.3011913299561, 29.4221172332764),

				new Coordinate(-13.3011913299561, 27.6111183166504),

				new Coordinate(-18.1745567321777, 27.6111183166504) };



		layer.setGeometry(JTSFactoryFinder.getGeometryFactory().createPolygon(coordinates));

		return JTSFactoryFinder.getGeometryFactory().createPolygon(coordinates);

	}



	@SuppressWarnings("serial")

	public static List<ActivityDTO> getActivities() {



		ActivityDTO activity = new ActivityDTO();

		activity.setId("3");

		activity.setName("AIS");

		activity.setPath("r.1.2.3");



		layer.setActivities(new ArrayList<ActivityDTO>() {

		return new ArrayList<ActivityDTO>() {

			{

				add(activity);

			}

		});



		ContactDTO contact = new ContactDTO();

		contact.setName("Pepe");

		layer.setContact(contact);



		layer.setParent(CategoryDataUtil.getCategory("3442"));



		layer.setThemeInspire(ThemeInspireDataUtil.getThemeInspire("cc"));



		layer.setProtocols(getProtocols());



		layer.setLatLonBoundsImage(getLatLonBoundingBoxDTO());



		StyleLayerDTO styleLayer = new StyleLayerDTO();

		styleLayer.setName("styleLayer");

		layer.setStylesLayer(new ArrayList<StyleLayerDTO>() {

			{

				add(styleLayer);

			}

		});



		return layer;

		};

	}



	@SuppressWarnings("serial")
@@ -312,4 +440,17 @@ public abstract class LayerDataUtil { 


		return latLonBoundingBoxDTO;

	}



	@SuppressWarnings("serial")

	public static List<StyleLayerDTO> getStylesLayer() {



		StyleLayerDTO styleLayer = new StyleLayerDTO();

		styleLayer.setName("styleLayer");



		return new ArrayList<StyleLayerDTO>() {

			{

				add(styleLayer);

			}

		};

	}

}

atlas-commands/src/test/java/es/redmic/test/atlascommands/integration/layer/LayerRestTest.java

+61 −0
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers. 
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;



import java.io.File;

import java.io.IOException;

import java.util.Map;

import java.util.UUID;

import java.util.concurrent.BlockingQueue;
@@ -69,11 +70,16 @@ import org.springframework.util.concurrent.ListenableFuture; 
import es.redmic.atlascommands.AtlasCommandsApplication;

import es.redmic.atlascommands.handler.LayerCommandHandler;

import es.redmic.atlascommands.statestore.LayerStateStore;

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

import es.redmic.atlaslib.dto.layerinfo.LayerInfoDTO;

import es.redmic.atlaslib.dto.refresh.RefreshRequestDTO;

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

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

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

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

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

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.brokerlib.avro.common.Event;
@@ -223,6 +229,46 @@ public class LayerRestTest extends DocumentationCommandBaseTest { 
		assertEquals(event.getAggregateId(), expectedEvent.getAggregateId());

	}



	@Test

	public void refreshLayer_SendRefreshLayerEvent_IfCommandWasSuccess() throws Exception {



		LayerCreatedEvent source = LayerDataUtil.getLayerCreatedEvent(CODE);



		when(layerStateStore.getLayer(anyString())).thenReturn(source);



		String originalName = "batimetriaGlobal";



		RefreshRequestDTO request = new RefreshRequestDTO();

		request.setUrlSource(new File("src/test/resources/data/capabilities/wms.xml").toURI().toString());

		request.setName(originalName);



		// @formatter:off

		

		String id = source.getAggregateId();

		

		this.mockMvc

				.perform(put(CATEGORY_PATH + "/refresh/" + id)

						.header("Authorization", "Bearer " + getTokenOAGUser())

						.content(mapper.writeValueAsString(request))

						.contentType(MediaType.APPLICATION_JSON)

						.accept(MediaType.APPLICATION_JSON))

				.andExpect(status().isOk())

				.andExpect(jsonPath("$.success", is(true)))

				.andExpect(jsonPath("$.body", notNullValue()))

				.andExpect(jsonPath("$.body.id", is(id)));

		

		// @formatter:on



		RefreshLayerEvent event = (RefreshLayerEvent) blockingQueue.poll(50, TimeUnit.SECONDS);



		RefreshLayerEvent expectedEvent = LayerDataUtil.getRefreshEvent(CODE);

		assertNotNull(event);

		assertEquals(event.getType(), expectedEvent.getType());

		assertEquals(event.getVersion(), expectedEvent.getVersion());

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

		assertEquals(event.getAggregateId(), expectedEvent.getAggregateId());

	}



	@Test

	public void deleteLayer_SendDeleteLayerEvent_IfCommandWasSuccess() throws Exception {
@@ -291,6 +337,21 @@ public class LayerRestTest extends DocumentationCommandBaseTest { 
		blockingQueue.offer(updateLayerEvent);

	}



	@KafkaHandler

	public void refreshLayer(RefreshLayerEvent refreshLayerEvent) throws IOException {



		LayerDTO layerExpected = (LayerDTO) JsonToBeanTestUtil.getBean("/data/layers/layerDTO.json", LayerDTO.class);



		RefreshLayerConfirmedEvent refreshConfirmEvent = new RefreshLayerConfirmedEvent().buildFrom(refreshLayerEvent);

		refreshConfirmEvent.setLayer(layerExpected);



		ListenableFuture<SendResult<String, Event>> future = kafkaTemplate.send(layer_topic,

				refreshConfirmEvent.getAggregateId(), refreshConfirmEvent);

		future.addCallback(new SendListener());



		blockingQueue.offer(refreshLayerEvent);

	}



	@KafkaHandler

	public void deleteLayer(DeleteLayerEvent deleteLayerEvent) {

atlas-commands/src/test/java/es/redmic/test/atlascommands/unit/aggregate/layer/ApplyEventTest.java

+35 −5
Original line number Diff line number Diff line
@@ -41,6 +41,8 @@ import es.redmic.atlaslib.events.layer.create.CreateLayerEvent; 
import es.redmic.atlaslib.events.layer.create.LayerCreatedEvent;

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

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

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

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

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

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

import es.redmic.brokerlib.avro.common.Event;
@@ -71,7 +73,7 @@ public class ApplyEventTest { 


		agg.apply(evt);



		checkCreatedOrUpdatedState(evt);

		checkCreatedUpdatedOrRefreshedState(evt);

	}



	@Test
@@ -81,7 +83,17 @@ public class ApplyEventTest { 


		agg.apply(evt);



		checkCreatedOrUpdatedState(evt);

		checkCreatedUpdatedOrRefreshedState(evt);

	}



	@Test

	public void applyLayerRefreshedEvent_ChangeAggregateState_IfProcessIsOk() {



		LayerRefreshedEvent evt = LayerDataUtil.getLayerRefreshedEvent(code);



		agg.apply(evt);



		checkCreatedUpdatedOrRefreshedState(evt);

	}



	@Test
@@ -101,7 +113,7 @@ public class ApplyEventTest { 


		agg.loadFromHistory(evt);



		checkCreatedOrUpdatedState(evt);

		checkCreatedUpdatedOrRefreshedState(evt);

	}



	@Test(expected = ItemLockedException.class)
@@ -119,7 +131,7 @@ public class ApplyEventTest { 


		agg.loadFromHistory(evt);



		checkCreatedOrUpdatedState(evt);

		checkCreatedUpdatedOrRefreshedState(evt);

	}



	@Test(expected = ItemLockedException.class)
@@ -130,6 +142,24 @@ public class ApplyEventTest { 
		agg.loadFromHistory(evt);

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToRefreshed_IfEventIsUpdated() {



		LayerRefreshedEvent evt = LayerDataUtil.getLayerRefreshedEvent(code);



		agg.loadFromHistory(evt);



		checkCreatedUpdatedOrRefreshedState(evt);

	}



	@Test(expected = ItemLockedException.class)

	public void loadFromHistory_ThrowItemLockedException_IfEventIsRefresh() {



		RefreshLayerEvent evt = LayerDataUtil.getRefreshEvent(code);



		agg.loadFromHistory(evt);

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToDeleted_IfLastEventIsDeleted() {
@@ -153,7 +183,7 @@ public class ApplyEventTest { 
		agg.loadFromHistory(evt);

	}



	private void checkCreatedOrUpdatedState(LayerEvent evt) {

	private void checkCreatedUpdatedOrRefreshedState(LayerEvent evt) {



		assertEquals(agg.getVersion(), evt.getVersion());

		assertEquals(agg.getAggregateId(), evt.getAggregateId());

atlas-commands/src/test/java/es/redmic/test/atlascommands/unit/aggregate/layer/ProcessEventTest.java

+46 −0
Original line number Diff line number Diff line
@@ -37,12 +37,15 @@ import org.mockito.junit.MockitoJUnitRunner; 
import es.redmic.atlascommands.aggregate.LayerAggregate;

import es.redmic.atlascommands.commands.layer.CreateLayerCommand;

import es.redmic.atlascommands.commands.layer.DeleteLayerCommand;

import es.redmic.atlascommands.commands.layer.RefreshLayerCommand;

import es.redmic.atlascommands.commands.layer.UpdateLayerCommand;

import es.redmic.atlascommands.statestore.LayerStateStore;

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.CreateLayerEvent;

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

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

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

import es.redmic.commandslib.exceptions.ItemLockedException;

import es.redmic.exception.data.ItemNotFoundException;
@@ -169,4 +172,47 @@ public class ProcessEventTest { 


		agg.process(new DeleteLayerCommand(layer.getId()));

	}



	@Test

	public void processRefreshLayerCommand_ReturnLayerRefreshedEvent_IfProcessIsOk() {



		when(layerStateStore.getLayer(any())).thenReturn(LayerDataUtil.getLayerCreatedEvent(code));



		LayerWMSDTO layer = LayerDataUtil.getLayerWMS(code);



		RefreshLayerCommand command = new RefreshLayerCommand(layer.getId(), layer);



		RefreshLayerEvent evt = agg.process(command);



		assertNotNull(evt);

		assertNotNull(evt.getDate());

		assertNotNull(evt.getLayer());

		assertEquals(evt.getLayer(), layer);

		assertNotNull(evt.getId());

		assertEquals(evt.getAggregateId(), layer.getId());

		assertEquals(evt.getType(), LayerEventTypes.REFRESH);

		assertTrue(evt.getVersion().equals(2));

	}



	// Refrescar un elemento ya borrado

	@Test(expected = ItemNotFoundException.class)

	public void processRefreshLayerCommand_ThrowItemNotFoundException_IfItemIsDeleted() {



		when(layerStateStore.getLayer(any())).thenReturn(LayerDataUtil.getLayerDeletedEvent(code));



		LayerWMSDTO layer = LayerDataUtil.getLayerWMS(code);



		agg.process(new RefreshLayerCommand(layer.getId(), layer));

	}



	// Refrescar un elemento bloqueado

	@Test(expected = ItemLockedException.class)

	public void processRefreshLayerCommand_ThrowItemLockedException_IfItemIsLocked() {



		when(layerStateStore.getLayer(any())).thenReturn(LayerDataUtil.getUpdateEvent(code));



		LayerWMSDTO layer = LayerDataUtil.getLayerWMS(code);



		agg.process(new RefreshLayerCommand(layer.getId(), layer));

	}

}