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

Añade componentes de event-sourcing + test

parent 1188be7a

atlas-commands/src/main/java/es/redmic/atlascommands/aggregate/LayerAggregate.java

0 → 100644
+179 −0
Original line number Diff line number Diff line 
package es.redmic.atlascommands.aggregate;



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

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

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

import es.redmic.atlascommands.statestore.LayerStateStore;



/*-

 * #%L

 * Atlas-management

 * %%

 * Copyright (C) 2019 REDMIC Project / Server

 * %%

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 * 

 *      http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 * #L%

 */



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

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

import es.redmic.atlaslib.events.layer.common.LayerEvent;

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

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

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

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

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

import es.redmic.brokerlib.avro.common.Event;

import es.redmic.commandslib.aggregate.Aggregate;



public class LayerAggregate extends Aggregate {



	private LayerDTO layer;



	private LayerStateStore layerStateStore;



	public LayerAggregate(LayerStateStore layerStateStore) {



		this.layerStateStore = layerStateStore;

	}



	public CreateLayerEvent process(CreateLayerCommand cmd) {



		assert layerStateStore != null;



		String id = cmd.getLayer().getId();



		if (exist(id)) {

			logger.info("Descartando Layer " + id + ". Ya está registrado.");

			return null; // Se lanza excepción en el origen no aquí

		}



		this.setAggregateId(id);



		CreateLayerEvent evt = new CreateLayerEvent(cmd.getLayer());

		evt.setAggregateId(id);

		evt.setVersion(1);

		return evt;

	}



	public UpdateLayerEvent process(UpdateLayerCommand cmd) {



		assert layerStateStore != null;



		String id = cmd.getLayer().getId();



		Event state = getStateFromHistory(id);



		loadFromHistory(state);



		checkState(id, state.getType());



		UpdateLayerEvent evt = new UpdateLayerEvent(cmd.getLayer());

		evt.setAggregateId(id);

		evt.setVersion(getVersion() + 1);

		return evt;

	}



	public CheckDeleteLayerEvent process(DeleteLayerCommand cmd) {



		assert layerStateStore != null;



		String id = cmd.getLayerId();



		Event state = getStateFromHistory(id);



		loadFromHistory(state);



		checkState(id, state.getType());



		CheckDeleteLayerEvent evt = new CheckDeleteLayerEvent();

		evt.setAggregateId(id);

		evt.setVersion(getVersion() + 1);



		return evt;

	}



	public LayerDTO getLayer() {

		return layer;

	}



	@Override

	protected boolean isLocked(String eventType) {



		return LayerEventTypes.isLocked(eventType);

	}



	@Override

	protected Event getItemFromStateStore(String id) {



		return layerStateStore.getLayer(id);

	}



	@Override

	public void loadFromHistory(Event event) {



		logger.debug("Cargando último estado de Layer ", event.getAggregateId());



		check(event);



		String eventType = event.getType();



		switch (eventType) {

		case "CREATED":

			logger.debug("Item creado");

			apply((LayerEvent) event);

			break;

		case "UPDATED":

			logger.debug("Item modificado");

			apply((LayerEvent) event);

			break;

		case "DELETED":

			logger.debug("Item borrado");

			apply((LayerDeletedEvent) event);

			break;

		// CANCELLED

		case "CREATE_CANCELLED":

			logger.debug("Compensación por creación fallida");

			apply((CreateLayerCancelledEvent) event);

			break;

		case "UPDATE_CANCELLED":

		case "DELETE_CANCELLED":

			logger.debug("Compensación por edición/borrado fallido");

			apply((LayerEvent) event);

			break;

		default:

			logger.debug("Evento no manejado ", event.getType());

		}

	}



	public void apply(CreateLayerCancelledEvent event) {

		this.deleted = true;

		apply(event);

	}



	public void apply(LayerDeletedEvent event) {

		this.deleted = true;

		super.apply(event);

	}



	public void apply(LayerEvent event) {

		this.layer = event.getLayer();

		super.apply(event);

	}



	@Override

	protected void reset() {

		this.layer = null;

		super.reset();

	}

}

atlas-commands/src/main/java/es/redmic/atlascommands/handler/LayerCommandHandler.java

0 → 100644
+291 −0
Original line number Diff line number Diff line 
package es.redmic.atlascommands.handler;



/*-

 * #%L

 * Atlas-management

 * %%

 * Copyright (C) 2019 REDMIC Project / Server

 * %%

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 * 

 *      http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 * #L%

 */



import java.util.concurrent.CompletableFuture;



import javax.annotation.PostConstruct;



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

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

import org.springframework.kafka.annotation.KafkaHandler;

import org.springframework.kafka.annotation.KafkaListener;

import org.springframework.stereotype.Component;



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

import es.redmic.atlascommands.config.UserService;

import es.redmic.atlascommands.statestore.LayerStateStore;

import es.redmic.atlascommands.streams.LayerEventStreams;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import es.redmic.brokerlib.alert.AlertService;

import es.redmic.commandslib.commands.CommandHandler;

import es.redmic.commandslib.streaming.common.StreamConfig;

import es.redmic.commandslib.streaming.common.StreamConfig.Builder;

import es.redmic.exception.factory.ExceptionFactory;



@Component

@KafkaListener(topics = "${broker.topic.layer}")

public class LayerCommandHandler extends CommandHandler {



	@Value("${spring.kafka.properties.schema.registry.url}")

	protected String schemaRegistry;



	@Value("${spring.kafka.bootstrap-servers}")

	protected String bootstrapServers;



	@Value("${broker.topic.layer}")

	private String layerTopic;



	@Value("${broker.state.store.layer.dir}")

	private String stateStoreLayerDir;



	@Value("${broker.state.store.layer.id}")

	private String layerIdConfig;



	@Value("${broker.stream.events.layer.id}")

	private String layerEventsStreamId;



	@Value("${stream.windows.time.ms}")

	private Long streamWindowsTime;



	private LayerStateStore layerStateStore;



	@Autowired

	UserService userService;



	@Autowired

	AlertService alertService;



	public LayerCommandHandler() {



	}



	@PostConstruct

	private void setUp() {



		// @formatter:off

		

		Builder config = StreamConfig.Builder

				.bootstrapServers(bootstrapServers)

				.schemaRegistry(schemaRegistry)

				.stateStoreDir(stateStoreLayerDir)

				.topic(layerTopic);

		

		layerStateStore = new LayerStateStore(

				config

					.serviceId(layerIdConfig)

					.build(), alertService);



		new LayerEventStreams(

				config

					.serviceId(layerEventsStreamId)

					.windowsTime(streamWindowsTime)

					.build(), alertService);

		

		// @formatter:on

	}



	public LayerDTO save(CreateLayerCommand cmd) {



		LayerAggregate agg = new LayerAggregate(layerStateStore);



		// Se procesa el comando, obteniendo el evento generado

		logger.debug("Procesando CreateLayerCommand");



		CreateLayerEvent event = agg.process(cmd);



		// Si no se genera evento significa que no se debe aplicar

		if (event == null)

			return null;



		event.setUserId(userService.getUserId());



		// Se aplica el evento

		agg.apply(event);



		logger.debug("Aplicado evento: " + event.getType());



		// Crea la espera hasta que se responda con evento completado

		CompletableFuture<LayerDTO> completableFuture = getCompletableFeature(event.getSessionId(), agg.getLayer());



		// Emite evento para enviar a kafka

		publishToKafka(event, layerTopic);



		// Obtiene el resultado cuando se resuelva la espera

		return getResult(event.getSessionId(), completableFuture);

	}



	public LayerDTO update(String id, UpdateLayerCommand cmd) {



		LayerAggregate agg = new LayerAggregate(layerStateStore);



		// Se procesa el comando, obteniendo el evento generado

		UpdateLayerEvent event = agg.process(cmd);



		// Si no se genera evento significa que no se va a aplicar

		if (event == null)

			return null;



		event.setUserId(userService.getUserId());



		// Si no existen excepciones, se aplica el comando

		agg.apply(event);



		// Crea la espera hasta que se responda con evento completado

		CompletableFuture<LayerDTO> completableFuture = getCompletableFeature(event.getSessionId(), agg.getLayer());



		// Emite evento para enviar a kafka

		publishToKafka(event, layerTopic);



		// Obtiene el resultado cuando se resuelva la espera

		return getResult(event.getSessionId(), completableFuture);

	}



	public LayerDTO update(String id, DeleteLayerCommand cmd) {



		LayerAggregate agg = new LayerAggregate(layerStateStore);

		agg.setAggregateId(id);



		// Se procesa el comando, obteniendo el evento generado

		CheckDeleteLayerEvent event = agg.process(cmd);



		// Si no se genera evento significa que no se va a aplicar

		if (event == null)

			return null;



		event.setUserId(userService.getUserId());



		// Si no existen excepciones, se aplica el comando

		agg.apply(event);



		// Crea la espera hasta que se responda con evento completado

		CompletableFuture<LayerDTO> completableFuture = getCompletableFeature(event.getSessionId(), agg.getLayer());



		// Emite evento para enviar a kafka

		publishToKafka(event, layerTopic);



		// Obtiene el resultado cuando se resuelva la espera

		return getResult(event.getSessionId(), completableFuture);

	}



	@KafkaHandler

	private void listen(LayerCreatedEvent event) {



		logger.debug("Layer creado " + event.getAggregateId());



		// El evento Creado se envía desde el stream



		resolveCommand(event.getSessionId());

	}



	@KafkaHandler

	private void listen(LayerUpdatedEvent event) {



		logger.debug("Layer modificado " + event.getAggregateId());



		// El evento Modificado se envía desde el stream



		resolveCommand(event.getSessionId());

	}



	@KafkaHandler

	private void listen(DeleteLayerCheckedEvent event) {



		publishToKafka(LayerEventFactory.getEvent(event, LayerEventTypes.DELETE), layerTopic);

	}



	@KafkaHandler

	private void listen(DeleteLayerConfirmedEvent event) {



		publishToKafka(LayerEventFactory.getEvent(event, LayerEventTypes.DELETED), layerTopic);

	}



	@KafkaHandler

	private void listen(LayerDeletedEvent event) {



		logger.debug("Layer eliminado " + event.getAggregateId());



		resolveCommand(event.getSessionId());

	}



	@KafkaHandler

	private void listen(CreateLayerFailedEvent event) {



		publishToKafka(LayerEventFactory.getEvent(event, LayerEventTypes.CREATE_CANCELLED, event.getExceptionType(),

				event.getArguments()), layerTopic);

	}



	@KafkaHandler

	private void listen(CreateLayerCancelledEvent event) {



		logger.debug("Error creando Layer " + event.getAggregateId());



		resolveCommand(event.getSessionId(),

				ExceptionFactory.getException(event.getExceptionType(), event.getArguments()));

	}



	@KafkaHandler

	private void listen(UpdateLayerCancelledEvent event) {



		logger.debug("Error modificando Layer " + event.getAggregateId());



		// El evento Cancelled se envía desde el stream



		resolveCommand(event.getSessionId(),

				ExceptionFactory.getException(event.getExceptionType(), event.getArguments()));

	}



	@KafkaHandler

	private void listen(DeleteLayerCheckFailedEvent event) {



		publishToKafka(LayerEventFactory.getEvent(event, LayerEventTypes.DELETE_CANCELLED, event.getExceptionType(),

				event.getArguments()), layerTopic);

	}



	@KafkaHandler

	private void listen(DeleteLayerCancelledEvent event) {



		logger.debug("Error eliminando Layer " + event.getAggregateId());



		// El evento Cancelled se envía desde el stream



		resolveCommand(event.getSessionId(),

				ExceptionFactory.getException(event.getExceptionType(), event.getArguments()));

	}

}

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

0 → 100644
+170 −0
Original line number Diff line number Diff line 
package es.redmic.test.atlascommands.unit.aggregate.layer;



/*-

 * #%L

 * Atlas-management

 * %%

 * Copyright (C) 2019 REDMIC Project / Server

 * %%

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 * 

 *      http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 * #L%

 */



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;



import java.util.ArrayList;

import java.util.List;

import java.util.UUID;



import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mockito;

import org.mockito.junit.MockitoJUnitRunner;



import es.redmic.atlascommands.aggregate.LayerAggregate;

import es.redmic.atlascommands.statestore.LayerStateStore;

import es.redmic.atlaslib.events.layer.common.LayerEvent;

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.update.LayerUpdatedEvent;

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

import es.redmic.brokerlib.avro.common.Event;

import es.redmic.commandslib.exceptions.ItemLockedException;

import es.redmic.test.atlascommands.integration.layer.LayerDataUtil;



@RunWith(MockitoJUnitRunner.class)

public class ApplyEventTest {



	private final String code = UUID.randomUUID().toString();



	LayerStateStore layerStateStore;



	LayerAggregate agg;



	@Before

	public void setUp() {



		layerStateStore = Mockito.mock(LayerStateStore.class);



		agg = new LayerAggregate(layerStateStore);

	}



	@Test

	public void applyLayerCreatedEvent_ChangeAggrefateState_IfProcessIsOk() {



		LayerCreatedEvent evt = LayerDataUtil.getLayerCreatedEvent(code);



		agg.apply(evt);



		checkCreatedOrUpdatedState(evt);

	}



	@Test

	public void applyLayerUpdatedEvent_ChangeAggregateState_IfProcessIsOk() {



		LayerUpdatedEvent evt = LayerDataUtil.getLayerUpdatedEvent(code);



		agg.apply(evt);



		checkCreatedOrUpdatedState(evt);

	}



	@Test

	public void applyLayerDeletedEvent_ChangeAggregateState_IfProcessIsOk() {



		LayerDeletedEvent evt = LayerDataUtil.getLayerDeletedEvent(code);



		agg.apply(evt);



		checkDeletedState(evt);

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToCreated_IfEventIsCreated() {



		LayerCreatedEvent evt = LayerDataUtil.getLayerCreatedEvent(code);



		agg.loadFromHistory(evt);



		checkCreatedOrUpdatedState(evt);

	}



	@Test(expected = ItemLockedException.class)

	public void loadFromHistory_ThrowItemLockedException_IfEventIsCreate() {



		CreateLayerEvent evt = LayerDataUtil.getCreateEvent(code);



		agg.loadFromHistory(evt);

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToUpdated_IfEventIsUpdated() {



		LayerUpdatedEvent evt = LayerDataUtil.getLayerUpdatedEvent(code);



		agg.loadFromHistory(evt);



		checkCreatedOrUpdatedState(evt);

	}



	@Test(expected = ItemLockedException.class)

	public void loadFromHistory_ThrowItemLockedException_IfEventIsUpdate() {



		UpdateLayerEvent evt = LayerDataUtil.getUpdateEvent(code);



		agg.loadFromHistory(evt);

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToDeleted_IfLastEventIsDeleted() {



		List<Event> history = new ArrayList<>();



		history.add(LayerDataUtil.getLayerCreatedEvent(code));

		history.add(LayerDataUtil.getLayerUpdatedEvent(code));



		history.add(LayerDataUtil.getLayerDeletedEvent(code));



		agg.loadFromHistory(history);



		checkDeletedState((LayerDeletedEvent) history.get(2));

	}



	@Test(expected = ItemLockedException.class)

	public void loadFromHistory_ThrowItemLockedException_IfEventIsDelete() {



		DeleteLayerEvent evt = LayerDataUtil.getDeleteEvent(code);



		agg.loadFromHistory(evt);

	}



	private void checkCreatedOrUpdatedState(LayerEvent evt) {



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

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

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

		assertFalse(agg.isDeleted());

	}



	private void checkDeletedState(LayerDeletedEvent evt) {



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

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

		assertTrue(agg.isDeleted());

	}

}

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

0 → 100644
+172 −0
Original line number Diff line number Diff line 
package es.redmic.test.atlascommands.unit.aggregate.layer;



/*-

 * #%L

 * Atlas-management

 * %%

 * Copyright (C) 2019 REDMIC Project / Server

 * %%

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 * 

 *      http://www.apache.org/licenses/LICENSE-2.0

 * 

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 * #L%

 */



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.Mockito.when;



import java.util.UUID;



import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mockito;

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

import es.redmic.atlascommands.statestore.LayerStateStore;

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

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.update.UpdateLayerEvent;

import es.redmic.commandslib.exceptions.ItemLockedException;

import es.redmic.exception.data.ItemNotFoundException;

import es.redmic.test.atlascommands.integration.layer.LayerDataUtil;



@RunWith(MockitoJUnitRunner.class)

public class ProcessEventTest {



	private final String code = UUID.randomUUID().toString();



	LayerStateStore layerStateStore;



	LayerAggregate agg;



	@Before

	public void setUp() {



		layerStateStore = Mockito.mock(LayerStateStore.class);



		agg = new LayerAggregate(layerStateStore);

	}



	@Test

	public void processCreateLayerCommand_ReturnLayerCreatedEvent_IfProcessIsOk() {



		when(layerStateStore.getLayer(any())).thenReturn(null);



		LayerDTO layer = LayerDataUtil.getLayer(code);



		CreateLayerCommand command = new CreateLayerCommand(layer);



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

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

	}



	@Test

	public void processUpdateLayerCommand_ReturnLayerUpdatedEvent_IfProcessIsOk() {



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



		LayerDTO layer = LayerDataUtil.getLayer(code);



		UpdateLayerCommand command = new UpdateLayerCommand(layer);



		UpdateLayerEvent 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.UPDATE);

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

	}



	// Editar un elemento ya borrado

	@Test(expected = ItemNotFoundException.class)

	public void processUpdateLayerCommand_ThrowItemNotFoundException_IfItemIsDeleted() {



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



		LayerDTO layer = LayerDataUtil.getLayer(code);



		agg.process(new UpdateLayerCommand(layer));

	}



	// Editar un elemento bloqueado

	@Test(expected = ItemLockedException.class)

	public void processUpdateLayerCommand_ThrowItemLockedException_IfItemIsLocked() {



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



		LayerDTO layer = LayerDataUtil.getLayer(code);



		agg.process(new UpdateLayerCommand(layer));

	}



	@Test

	public void processDeleteLayerCommand_ReturnCheckDeleteLayerEvent_IfProcessIsOk() {



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



		LayerDTO layer = LayerDataUtil.getLayer(code);



		DeleteLayerCommand command = new DeleteLayerCommand(layer.getId());



		CheckDeleteLayerEvent evt = agg.process(command);



		assertNotNull(evt);

		assertNotNull(evt.getDate());

		assertNotNull(evt.getId());

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

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

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

	}



	// Borrar un elemento ya borrado

	@Test(expected = ItemNotFoundException.class)

	public void processDeleteLayerCommand_ThrowItemNotFoundException_IfItemIsDeleted() {



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



		LayerDTO layer = LayerDataUtil.getLayer(code);



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

	}



	// Borrar un elemento bloqueado

	@Test(expected = ItemLockedException.class)

	public void processDeleteLayerCommand_ThrowItemLockedException_IfItemIsLocked() {



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



		LayerDTO layer = LayerDataUtil.getLayer(code);



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

	}

}