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

Añade test para procesamiento de comandos 

Tambíen testea la generación de eventos a partir del procesamiento de los comandos
parent 3bca11a0

vessels-commands/src/test/java/es/redmic/test/vesselscommands/unit/aggregate/vesseltracking/AggregateBaseTest.java

0 → 100644
+68 −0
Original line number Diff line number Diff line 
package es.redmic.test.vesselscommands.unit.aggregate.vesseltracking;



import org.joda.time.DateTime;

import org.junit.Before;

import org.mockito.Mockito;



import es.redmic.test.vesselscommands.integration.vesseltracking.VesselTrackingDataUtil;

import es.redmic.vesselscommands.aggregate.VesselTrackingAggregate;

import es.redmic.vesselscommands.statestore.VesselTrackingStateStore;

import es.redmic.vesselslib.dto.tracking.VesselTrackingDTO;

import es.redmic.vesselslib.events.vesseltracking.create.CreateVesselTrackingEvent;

import es.redmic.vesselslib.events.vesseltracking.create.VesselTrackingCreatedEvent;

import es.redmic.vesselslib.events.vesseltracking.delete.DeleteVesselTrackingEvent;

import es.redmic.vesselslib.events.vesseltracking.delete.VesselTrackingDeletedEvent;

import es.redmic.vesselslib.events.vesseltracking.update.UpdateVesselTrackingEvent;

import es.redmic.vesselslib.events.vesseltracking.update.VesselTrackingUpdatedEvent;



public abstract class AggregateBaseTest {



	VesselTrackingStateStore vesselTrackingsStateStore;



	VesselTrackingAggregate agg;



	Integer mmsi = 1234;



	@Before

	public void setUp() {



		vesselTrackingsStateStore = Mockito.mock(VesselTrackingStateStore.class);



		agg = new VesselTrackingAggregate(vesselTrackingsStateStore);

	}



	protected CreateVesselTrackingEvent getCreateVesselTrackingEvent() {



		return VesselTrackingDataUtil.getCreateEvent(mmsi);

	}



	protected VesselTrackingCreatedEvent getVesselTrackingCreatedEvent() {



		return VesselTrackingDataUtil.getVesselTrackingCreatedEvent(mmsi);

	}



	protected UpdateVesselTrackingEvent getUpdateVesselTrackingEvent() {



		return VesselTrackingDataUtil.getUpdateEvent(mmsi);

	}



	protected VesselTrackingUpdatedEvent getVesselTrackingUpdatedEvent() {



		return VesselTrackingDataUtil.getVesselTrackingUpdatedEvent(mmsi);

	}



	protected DeleteVesselTrackingEvent getDeleteVesselTrackingEvent() {



		return VesselTrackingDataUtil.getDeleteEvent(mmsi);

	}



	protected VesselTrackingDeletedEvent getVesselTrackingDeletedEvent() {



		return VesselTrackingDataUtil.getVesselTrackingDeletedEvent(mmsi);

	}



	protected VesselTrackingDTO getVesselTracking() {



		return VesselTrackingDataUtil.getVesselTracking(mmsi, String.valueOf(new DateTime().getMillis()));

	}

}

vessels-commands/src/test/java/es/redmic/test/vesselscommands/unit/aggregate/vesseltracking/ApplyEventTest.java

0 → 100644
+169 −0
Original line number Diff line number Diff line 
package es.redmic.test.vesselscommands.unit.aggregate.vesseltracking;



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 org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.junit.MockitoJUnitRunner;



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

import es.redmic.vesselslib.events.vesseltracking.common.VesselTrackingEvent;

import es.redmic.vesselslib.events.vesseltracking.create.CreateVesselTrackingEvent;

import es.redmic.vesselslib.events.vesseltracking.create.VesselTrackingCreatedEvent;

import es.redmic.vesselslib.events.vesseltracking.delete.DeleteVesselTrackingEvent;

import es.redmic.vesselslib.events.vesseltracking.delete.VesselTrackingDeletedEvent;

import es.redmic.vesselslib.events.vesseltracking.update.UpdateVesselTrackingEvent;

import es.redmic.vesselslib.events.vesseltracking.update.VesselTrackingUpdatedEvent;



@RunWith(MockitoJUnitRunner.class)

public class ApplyEventTest extends AggregateBaseTest {



	@Test

	public void applyCreateVesselTrackingEvent_ChangeAggrefateState_IfProcessIsOk() {



		CreateVesselTrackingEvent evt = getCreateVesselTrackingEvent();



		agg.apply(evt);



		checkCreateOrUpdateState(evt);

	}



	@Test

	public void applyVesselTrackingCreatedEvent_ChangeAggrefateState_IfProcessIsOk() {



		VesselTrackingCreatedEvent evt = getVesselTrackingCreatedEvent();



		agg.apply(evt);



		checkCreateOrUpdateState(evt);

	}



	@Test

	public void applyUpdateVesselTrackingEvent_ChangeAggregateState_IfProcessIsOk() {



		UpdateVesselTrackingEvent evt = getUpdateVesselTrackingEvent();



		agg.apply(evt);



		checkCreateOrUpdateState(evt);

	}



	@Test

	public void applyVesselTrackingUpdatedEvent_ChangeAggregateState_IfProcessIsOk() {



		VesselTrackingUpdatedEvent evt = getVesselTrackingUpdatedEvent();



		agg.apply(evt);



		checkCreateOrUpdateState(evt);

	}



	@Test

	public void applyDeleteVesselTrackingEvent_ChangeAggregateState_IfProcessIsOk() {



		DeleteVesselTrackingEvent evt = getDeleteVesselTrackingEvent();



		agg.apply(evt);



		checkDeleteState(evt);

	}



	@Test

	public void applyVesselTrackingDeletedEvent_ChangeAggregateState_IfProcessIsOk() {



		VesselTrackingDeletedEvent evt = getVesselTrackingDeletedEvent();



		agg.apply(evt);



		checkDeletedState(evt);

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToCreate_IfEventIsCreate() {



		CreateVesselTrackingEvent evt = getCreateVesselTrackingEvent();



		agg.loadFromHistory(evt);



		checkCreateOrUpdateState(evt);

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToUpdate_IfEventIsUpdate() {



		UpdateVesselTrackingEvent evt = getUpdateVesselTrackingEvent();



		agg.loadFromHistory(evt);



		checkCreateOrUpdateState(evt);

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToDelete_IfEventIsDelete() {



		DeleteVesselTrackingEvent evt = getDeleteVesselTrackingEvent();



		agg.loadFromHistory(evt);



		checkDeleteState(evt);

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToDelete_IfLastEventIsDelete() {



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



		history.add(getCreateVesselTrackingEvent());

		history.add(getUpdateVesselTrackingEvent());

		history.add(getDeleteVesselTrackingEvent());



		history.add(getDeleteVesselTrackingEvent());



		agg.loadFromHistory(history);



		checkDeleteState((DeleteVesselTrackingEvent) history.get(3));

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToDeleted_IfEventIsDelete() {



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



		history.add(getCreateVesselTrackingEvent());

		history.add(getUpdateVesselTrackingEvent());

		history.add(getDeleteVesselTrackingEvent());



		history.add(getVesselTrackingDeletedEvent());



		agg.loadFromHistory(history);



		checkDeletedState((VesselTrackingDeletedEvent) history.get(3));

	}



	private void checkCreateOrUpdateState(VesselTrackingEvent evt) {



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

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

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

		assertFalse(agg.isDeleted());

	}



	private void checkDeleteState(DeleteVesselTrackingEvent evt) {



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

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

		assertFalse(agg.isDeleted());

	}



	private void checkDeletedState(VesselTrackingDeletedEvent evt) {



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

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

		assertTrue(agg.isDeleted());

	}

}

vessels-commands/src/test/java/es/redmic/test/vesselscommands/unit/aggregate/vesseltracking/ProcessEventTest.java

0 → 100644
+149 −0
Original line number Diff line number Diff line 
package es.redmic.test.vesselscommands.unit.aggregate.vesseltracking;



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 org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.junit.MockitoJUnitRunner;



import es.redmic.commandslib.exceptions.ItemLockedException;

import es.redmic.exception.data.ItemNotFoundException;

import es.redmic.vesselscommands.commands.vesseltracking.CreateVesselTrackingCommand;

import es.redmic.vesselscommands.commands.vesseltracking.DeleteVesselTrackingCommand;

import es.redmic.vesselscommands.commands.vesseltracking.UpdateVesselTrackingCommand;

import es.redmic.vesselslib.dto.tracking.VesselTrackingDTO;

import es.redmic.vesselslib.events.vesseltracking.VesselTrackingEventTypes;

import es.redmic.vesselslib.events.vesseltracking.common.VesselTrackingEvent;

import es.redmic.vesselslib.events.vesseltracking.create.VesselTrackingCreatedEvent;

import es.redmic.vesselslib.events.vesseltracking.delete.DeleteVesselTrackingEvent;

import es.redmic.vesselslib.events.vesseltracking.delete.VesselTrackingDeletedEvent;

import es.redmic.vesselslib.events.vesseltracking.update.UpdateVesselTrackingEvent;

import es.redmic.vesselslib.events.vesseltracking.update.VesselTrackingUpdatedEvent;



@RunWith(MockitoJUnitRunner.class)

public class ProcessEventTest extends AggregateBaseTest {



	@Test

	public void processCreateVesselTrackingCommand_ReturnVesselTrackingCreatedEvent_IfProcessIsOk() {



		when(vesselTrackingsStateStore.getVesselTracking(any())).thenReturn(null);



		VesselTrackingDTO vesselTracking = getVesselTracking();



		CreateVesselTrackingCommand command = new CreateVesselTrackingCommand(vesselTracking);



		VesselTrackingEvent evt = agg.process(command);



		assertNotNull(evt);

		assertNotNull(evt.getDate());

		assertNotNull(evt.getVesselTracking());

		assertEquals(evt.getVesselTracking(), vesselTracking);

		assertNotNull(evt.getId());

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

		assertEquals(evt.getType(), VesselTrackingEventTypes.ENRICH_CREATE);

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

	}



	@Test

	public void processUpdateVesselTrackingCommand_ReturnVesselTrackingUpdatedEvent_IfProcessIsOk() {



		VesselTrackingCreatedEvent vesselTrackingCreatedEvent = getVesselTrackingCreatedEvent();



		when(vesselTrackingsStateStore.getVesselTracking(any())).thenReturn(vesselTrackingCreatedEvent);



		VesselTrackingDTO vesselTracking = vesselTrackingCreatedEvent.getVesselTracking();



		UpdateVesselTrackingCommand command = new UpdateVesselTrackingCommand(vesselTracking);



		VesselTrackingEvent evt = agg.process(command);



		assertNotNull(evt);

		assertNotNull(evt.getDate());

		assertNotNull(evt.getVesselTracking());

		assertEquals(evt.getVesselTracking(), vesselTracking);

		assertNotNull(evt.getId());

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

		assertEquals(evt.getType(), VesselTrackingEventTypes.ENRICH_UPDATE);

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

	}



	// Editar un elemento ya borrado

	@Test(expected = ItemNotFoundException.class)

	public void processUpdateVesselTrackingCommand_ThrowItemNotFoundException_IfItemIsDeleted() {



		VesselTrackingDeletedEvent vesselTrackingDeletedEvent = getVesselTrackingDeletedEvent();



		when(vesselTrackingsStateStore.getVesselTracking(any())).thenReturn(vesselTrackingDeletedEvent);



		VesselTrackingDTO vesselTracking = getVesselTracking();

		vesselTracking.setId(vesselTrackingDeletedEvent.getAggregateId());



		agg.process(new UpdateVesselTrackingCommand(vesselTracking));

	}



	// Editar un elemento bloqueado

	@Test(expected = ItemLockedException.class)

	public void processUpdateVesselTrackingCommand_ThrowItemLockedException_IfItemIsLocked() {



		UpdateVesselTrackingEvent updateVesselTrackingEvent = getUpdateVesselTrackingEvent();



		when(vesselTrackingsStateStore.getVesselTracking(any())).thenReturn(updateVesselTrackingEvent);



		VesselTrackingDTO vesselTracking = getVesselTracking();

		vesselTracking.setId(updateVesselTrackingEvent.getAggregateId());



		agg.process(new UpdateVesselTrackingCommand(vesselTracking));

	}



	@Test

	public void processDeleteVesselTrackingCommand_ReturnVesselTrackingDeletedEvent_IfProcessIsOk() {



		VesselTrackingUpdatedEvent vesselTrackingUpdatedEvent = getVesselTrackingUpdatedEvent();

		when(vesselTrackingsStateStore.getVesselTracking(any())).thenReturn(vesselTrackingUpdatedEvent);



		VesselTrackingDTO vesselTracking = getVesselTracking();

		vesselTracking.setId(vesselTrackingUpdatedEvent.getAggregateId());



		DeleteVesselTrackingCommand command = new DeleteVesselTrackingCommand(vesselTracking.getId());



		DeleteVesselTrackingEvent evt = agg.process(command);



		assertNotNull(evt);

		assertNotNull(evt.getDate());

		assertNotNull(evt.getId());

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

		assertEquals(evt.getType(), VesselTrackingEventTypes.DELETE);

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

	}



	// Borrar un elemento ya borrado

	@Test(expected = ItemNotFoundException.class)

	public void processDeleteVesselTrackingCommand_ThrowItemNotFoundException_IfItemIsDeleted() {



		VesselTrackingDeletedEvent vesselTrackingDeletedEvent = getVesselTrackingDeletedEvent();



		when(vesselTrackingsStateStore.getVesselTracking(any())).thenReturn(vesselTrackingDeletedEvent);



		VesselTrackingDTO vesselTracking = getVesselTracking();

		vesselTracking.setId(vesselTrackingDeletedEvent.getAggregateId());



		agg.process(new DeleteVesselTrackingCommand(vesselTracking.getId()));

	}



	// Borrar un elemento bloqueado

	@Test(expected = ItemLockedException.class)

	public void processDeleteVesselTrackingCommand_ThrowItemLockedException_IfItemIsLocked() {



		UpdateVesselTrackingEvent updateVesselTrackingEvent = getUpdateVesselTrackingEvent();

		when(vesselTrackingsStateStore.getVesselTracking(any())).thenReturn(updateVesselTrackingEvent);



		VesselTrackingDTO vesselTracking = getVesselTracking();

		vesselTracking.setId(updateVesselTrackingEvent.getAggregateId());



		agg.process(new DeleteVesselTrackingCommand(vesselTracking.getId()));

	}

}