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

Completa todos los tipos en la factoría + tests

parent bda59225

vessels-lib/src/main/java/es/redmic/vesselslib/events/vessel/VesselEventFactory.java

+149 −46
Original line number Diff line number Diff line
@@ -6,82 +6,185 @@ import org.apache.logging.log4j.LogManager; 
import org.apache.logging.log4j.Logger;



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

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

import es.redmic.exception.common.ExceptionType;

import es.redmic.exception.common.InternalException;

import es.redmic.vesselslib.dto.vessel.VesselDTO;

import es.redmic.vesselslib.events.vessel.common.VesselCancelledEvent;

import es.redmic.vesselslib.events.vessel.common.VesselEvent;

import es.redmic.vesselslib.events.vessel.create.CreateVesselCancelledEvent;

import es.redmic.vesselslib.events.vessel.create.CreateVesselFailedEvent;

import es.redmic.vesselslib.events.vessel.create.VesselCreatedEvent;

import es.redmic.vesselslib.events.vessel.delete.DeleteVesselCancelledEvent;

import es.redmic.vesselslib.events.vessel.delete.DeleteVesselCheckFailedEvent;

import es.redmic.vesselslib.events.vessel.delete.DeleteVesselCheckedEvent;

import es.redmic.vesselslib.events.vessel.delete.DeleteVesselEvent;

import es.redmic.vesselslib.events.vessel.delete.DeleteVesselFailedEvent;

import es.redmic.vesselslib.events.vessel.delete.VesselDeletedEvent;

import es.redmic.vesselslib.events.vessel.partialupdate.vesseltype.UpdateVesselTypeInVesselEvent;

import es.redmic.vesselslib.events.vessel.update.UpdateVesselCancelledEvent;

import es.redmic.vesselslib.events.vessel.update.UpdateVesselFailedEvent;

import es.redmic.vesselslib.events.vessel.update.VesselUpdatedEvent;

import es.redmic.vesselslib.events.vesseltype.VesselTypeEventTypes;

import es.redmic.vesselslib.events.vesseltype.common.VesselTypeEvent;



public class VesselEventFactory {



	private static Logger logger = LogManager.getLogger();



	public static Event getEvent(Event source, String type) {



		if (type.equals(VesselEventTypes.DELETE)) {



			logger.info("Creando evento DeleteVesselEvent para: " + source.getAggregateId());



			return new DeleteVesselEvent().buildFrom(source);

		}



		if (type.equals(VesselEventTypes.DELETE_CHECKED)) {



			logger.info("Creando evento DeleteVesselCheckedEvent para: " + source.getAggregateId());



			return new DeleteVesselCheckedEvent().buildFrom(source);

		}



		if (type.equals(VesselEventTypes.DELETED)) {



			logger.info("Creando evento VesselDeletedEvent para: " + source.getAggregateId());



			return new VesselDeletedEvent().buildFrom(source);

		}



		logger.error("Tipo de evento no soportado");

		throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

	}



	//////////////



	public static Event getEvent(Event source, String type, VesselDTO vessel) {



		VesselEvent successfulEvent = null;



		if (type.equals(VesselEventTypes.CREATED)) {



			logger.info("Creando evento VesselCreatedEvent para: " + source.getAggregateId());

			successfulEvent = new VesselCreatedEvent().buildFrom(source);

		}



		if (type.equals(VesselEventTypes.UPDATED)) {



			logger.info("Creando evento VesselUpdatedEvent para: " + source.getAggregateId());

			successfulEvent = new VesselUpdatedEvent().buildFrom(source);

		}



		if (successfulEvent != null) {

			successfulEvent.setVessel(vessel);

			return successfulEvent;

		} else {

			logger.error("Tipo de evento no soportado");

			throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

		}

	}



	//////////////



	public static Event getEvent(Event source, Event trigger, String type) {



		if (type.equals(VesselEventTypes.UPDATE_VESSELTYPE)) {



			logger.info("Creando evento UpdateVesselTypeInVesselEvent para: " + source.getAggregateId());



			UpdateVesselTypeInVesselEvent requestEvent = new UpdateVesselTypeInVesselEvent();

			requestEvent.setAggregateId(source.getAggregateId());

			requestEvent.setUserId(trigger.getUserId());

			requestEvent.setVersion(source.getVersion() + 1);

			requestEvent.setVesselType(((VesselTypeEvent) trigger).getVesselType());

			return requestEvent;

		}



		logger.error("Tipo de evento no soportado");

		throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

	}



	/////////////////



	public static Event getEvent(Event source, String type, String exceptionType,

			Map<String, String> exceptionArguments) {



		EventError failedEvent = null;



		if (type.equals(VesselTypeEventTypes.CREATE_FAILED)) {



			logger.info("No se pudo crear Vessel en la vista");

			CreateVesselFailedEvent failedEvent = new CreateVesselFailedEvent().buildFrom(source);

			failedEvent.setExceptionType(exceptionType);

			failedEvent.setArguments(exceptionArguments);



			return failedEvent;

			failedEvent = new CreateVesselFailedEvent().buildFrom(source);

		}



		if (type.equals(VesselTypeEventTypes.UPDATE_FAILED)) {



			logger.info("No se pudo modificar Vessel en la vista");

			UpdateVesselFailedEvent failedEvent = new UpdateVesselFailedEvent().buildFrom(source);

			failedEvent.setExceptionType(exceptionType);

			failedEvent.setArguments(exceptionArguments);



			return failedEvent;

			failedEvent = new UpdateVesselFailedEvent().buildFrom(source);

		}



		if (type.equals(VesselTypeEventTypes.DELETE_FAILED)) {



			logger.info("No se pudo eliminar Vessel de la vista");

			DeleteVesselFailedEvent failedEvent = new DeleteVesselFailedEvent().buildFrom(source);

			failedEvent.setExceptionType(exceptionType);

			failedEvent.setArguments(exceptionArguments);



			return failedEvent;

			failedEvent = new DeleteVesselFailedEvent().buildFrom(source);

		}

		return null;



		if (type.equals(VesselEventTypes.DELETE_CHECK_FAILED)) {



			logger.info("Checkeo de eliminación fallido, el item está referenciado");

			failedEvent = new DeleteVesselCheckFailedEvent().buildFrom(source);

		}



	public static Event getEvent(Event source, String type) {

		return null;

		if (type.equals(VesselEventTypes.CREATE_CANCELLED)) {



			logger.info("Enviando evento CreateVesselCancelledEvent para: " + source.getAggregateId());

			failedEvent = new CreateVesselCancelledEvent().buildFrom(source);

		}



	/*-public static CreateVesselFailedEvent getCreateVesselFailedEvent(Event event, String exceptionType,

			Map<String, String> exceptionArguments) {

		if (failedEvent != null) {



		logger.info("No se pudo crear Vessel en la vista");

		CreateVesselFailedEvent failedEvent = new CreateVesselFailedEvent().buildFrom(event);

			failedEvent.setExceptionType(exceptionType);

			failedEvent.setArguments(exceptionArguments);

	

			return failedEvent;



		} else {

			logger.error("Tipo de evento no soportado");

			throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

		}

	}



	public static UpdateVesselFailedEvent getUpdateVesselFailedEvent(Event event, String exceptionType,

	////////////////////



	public static Event getEvent(Event source, String type, VesselDTO vessel, String exceptionType,

			Map<String, String> exceptionArguments) {



		logger.info("No se pudo modificar Vessel en la vista");

		UpdateVesselFailedEvent failedEvent = new UpdateVesselFailedEvent().buildFrom(event);

		failedEvent.setExceptionType(exceptionType);

		failedEvent.setArguments(exceptionArguments);

		VesselCancelledEvent cancelledEvent = null;



		return failedEvent;

		if (type.equals(VesselEventTypes.UPDATE_CANCELLED)) {



			logger.info("Creando evento UpdateVesselCancelledEvent para: " + source.getAggregateId());

			cancelledEvent = new UpdateVesselCancelledEvent().buildFrom(source);

		}



	public static DeleteVesselFailedEvent getDeleteVesselFailedEvent(Event event, String exceptionType,

			Map<String, String> exceptionArguments) {

		if (type.equals(VesselEventTypes.DELETE_CANCELLED)) {



		logger.info("No se pudo eliminar Vessel de la vista");

		DeleteVesselFailedEvent failedEvent = new DeleteVesselFailedEvent().buildFrom(event);

		failedEvent.setExceptionType(exceptionType);

		failedEvent.setArguments(exceptionArguments);

			logger.info("Creando evento DeleteVesselCancelledEvent para: " + source.getAggregateId());

			cancelledEvent = new DeleteVesselCancelledEvent().buildFrom(source);

		}



		return failedEvent;

	}-*/

		if (cancelledEvent != null) {



			cancelledEvent.setVessel(vessel);

			cancelledEvent.setExceptionType(exceptionType);

			cancelledEvent.setArguments(exceptionArguments);

			return cancelledEvent;



		} else {



			logger.error("Tipo de evento no soportado");

			throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

		}

	}

}

vessels-lib/src/main/java/es/redmic/vesselslib/events/vesseltype/VesselTypeEventFactory.java

+115 −47
Original line number Diff line number Diff line
@@ -6,81 +6,149 @@ import org.apache.logging.log4j.LogManager; 
import org.apache.logging.log4j.Logger;



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

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

import es.redmic.exception.common.ExceptionType;

import es.redmic.exception.common.InternalException;

import es.redmic.vesselslib.dto.vesseltype.VesselTypeDTO;

import es.redmic.vesselslib.events.vesseltype.common.VesselTypeCancelledEvent;

import es.redmic.vesselslib.events.vesseltype.common.VesselTypeEvent;

import es.redmic.vesselslib.events.vesseltype.create.CreateVesselTypeCancelledEvent;

import es.redmic.vesselslib.events.vesseltype.create.CreateVesselTypeFailedEvent;

import es.redmic.vesselslib.events.vesseltype.create.VesselTypeCreatedEvent;

import es.redmic.vesselslib.events.vesseltype.delete.DeleteVesselTypeCancelledEvent;

import es.redmic.vesselslib.events.vesseltype.delete.DeleteVesselTypeCheckFailedEvent;

import es.redmic.vesselslib.events.vesseltype.delete.DeleteVesselTypeCheckedEvent;

import es.redmic.vesselslib.events.vesseltype.delete.DeleteVesselTypeEvent;

import es.redmic.vesselslib.events.vesseltype.delete.DeleteVesselTypeFailedEvent;

import es.redmic.vesselslib.events.vesseltype.delete.VesselTypeDeletedEvent;

import es.redmic.vesselslib.events.vesseltype.update.UpdateVesselTypeCancelledEvent;

import es.redmic.vesselslib.events.vesseltype.update.UpdateVesselTypeFailedEvent;

import es.redmic.vesselslib.events.vesseltype.update.VesselTypeUpdatedEvent;



public class VesselTypeEventFactory {



	private static Logger logger = LogManager.getLogger();



	public static Event getEvent(Event source, String type) {



		if (type.equals(VesselTypeEventTypes.DELETE)) {



			logger.info("Creando evento DeleteVesselTypeEvent para: " + source.getAggregateId());

			return new DeleteVesselTypeEvent().buildFrom(source);

		}



		if (type.equals(VesselTypeEventTypes.DELETE_CHECKED)) {



			logger.info("Creando evento DeleteVesselTypeCheckedEvent para: " + source.getAggregateId());

			return new DeleteVesselTypeCheckedEvent().buildFrom(source);

		}



		if (type.equals(VesselTypeEventTypes.DELETED)) {



			logger.info("Creando evento VesselTypeDeletedEvent para: " + source.getAggregateId());

			return new VesselTypeDeletedEvent().buildFrom(source);

		}



		logger.error("Tipo de evento no soportado");

		throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

	}



	public static Event getEvent(Event source, String type, VesselTypeDTO vesselType) {



		VesselTypeEvent successfulEvent = null;



		if (type.equals(VesselTypeEventTypes.CREATED)) {

			logger.info("Creando evento VesselTypeCreatedEvent para: " + source.getAggregateId());

			successfulEvent = new VesselTypeCreatedEvent().buildFrom(source);

		}



		if (type.equals(VesselTypeEventTypes.UPDATED)) {

			logger.info("Creando evento VesselTypeUpdatedEvent para: " + source.getAggregateId());

			successfulEvent = new VesselTypeUpdatedEvent().buildFrom(source);

		}



		if (successfulEvent != null) {

			successfulEvent.setVesselType(vesselType);

			return successfulEvent;

		} else {

			logger.error("Tipo de evento no soportado");

			throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

		}

	}



	public static Event getEvent(Event source, String type, String exceptionType,

			Map<String, String> exceptionArguments) {



		EventError failedEvent = null;



		if (type.equals(VesselTypeEventTypes.CREATE_FAILED)) {



			logger.info("No se pudo crear Vessel type en la vista");

			CreateVesselTypeFailedEvent failedEvent = new CreateVesselTypeFailedEvent().buildFrom(source);

			failedEvent.setExceptionType(exceptionType);

			failedEvent.setArguments(exceptionArguments);



			return failedEvent;

			failedEvent = new CreateVesselTypeFailedEvent().buildFrom(source);

		}

		if (type.equals(VesselTypeEventTypes.UPDATE_FAILED)) {



			logger.info("No se pudo modificar Vessel type en la vista");

			UpdateVesselTypeFailedEvent failedEvent = new UpdateVesselTypeFailedEvent().buildFrom(source);

			failedEvent.setExceptionType(exceptionType);

			failedEvent.setArguments(exceptionArguments);



			return failedEvent;

			failedEvent = new UpdateVesselTypeFailedEvent().buildFrom(source);

		}

		if (type.equals(VesselTypeEventTypes.DELETE_FAILED)) {



			logger.info("No se pudo eliminar Vessel type de la vista");

			DeleteVesselTypeFailedEvent failedEvent = new DeleteVesselTypeFailedEvent().buildFrom(source);

			failedEvent.setExceptionType(exceptionType);

			failedEvent.setArguments(exceptionArguments);



			return failedEvent;

			failedEvent = new DeleteVesselTypeFailedEvent().buildFrom(source);

		}

		return null;



		if (type.equals(VesselTypeEventTypes.DELETE_CHECK_FAILED)) {



			logger.info("Checkeo de eliminación fallido, el item está referenciado");

			failedEvent = new DeleteVesselTypeCheckFailedEvent().buildFrom(source);

		}



	public static Event getEvent(Event source, String type) {

		return null;

		if (type.equals(VesselTypeEventTypes.CREATE_CANCELLED)) {



			logger.info("Enviando evento CreateVesselTypeCancelledEvent para: " + source.getAggregateId());

			failedEvent = new CreateVesselTypeCancelledEvent().buildFrom(source);

		}



	/*-public static CreateVesselTypeFailedEvent getCreateVesselTypeFailedEvent(Event event, String exceptionType,

			Map<String, String> exceptionArguments) {

		if (failedEvent != null) {



		logger.info("No se pudo crear Vessel type en la vista");

		CreateVesselTypeFailedEvent failedEvent = new CreateVesselTypeFailedEvent().buildFrom(event);

			failedEvent.setExceptionType(exceptionType);

			failedEvent.setArguments(exceptionArguments);

	

			return failedEvent;



		} else {

			logger.error("Tipo de evento no soportado");

			throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

		}

	}



	public static UpdateVesselTypeFailedEvent getUpdateVesselTypeFailedEvent(Event event, String exceptionType,

	public static Event getEvent(Event source, String type, VesselTypeDTO vesselType, String exceptionType,

			Map<String, String> exceptionArguments) {



		logger.info("No se pudo modificar Vessel type en la vista");

		UpdateVesselTypeFailedEvent failedEvent = new UpdateVesselTypeFailedEvent().buildFrom(event);

		failedEvent.setExceptionType(exceptionType);

		failedEvent.setArguments(exceptionArguments);

		VesselTypeCancelledEvent cancelledEvent = null;



		return failedEvent;

		if (type.equals(VesselTypeEventTypes.UPDATE_CANCELLED)) {



			logger.info("Creando evento UpdateVesselTypeCancelledEvent para: " + source.getAggregateId());

			cancelledEvent = new UpdateVesselTypeCancelledEvent().buildFrom(source);

		}



	public static DeleteVesselTypeFailedEvent getDeleteVesselTypeFailedEvent(Event event, String exceptionType,

			Map<String, String> exceptionArguments) {

		if (type.equals(VesselTypeEventTypes.DELETE_CANCELLED)) {



		logger.info("No se pudo eliminar Vessel type de la vista");

		DeleteVesselTypeFailedEvent failedEvent = new DeleteVesselTypeFailedEvent().buildFrom(event);

		failedEvent.setExceptionType(exceptionType);

		failedEvent.setArguments(exceptionArguments);

			logger.info("Creando evento DeleteVesselTypeCancelledEvent para: " + source.getAggregateId());

			cancelledEvent = new DeleteVesselTypeCancelledEvent().buildFrom(source);

		}



		return failedEvent;

	}-*/

		if (cancelledEvent != null) {



			cancelledEvent.setVesselType(vesselType);

			cancelledEvent.setExceptionType(exceptionType);

			cancelledEvent.setArguments(exceptionArguments);

			return cancelledEvent;



		} else {



			logger.error("Tipo de evento no soportado");

			throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

		}

	}

}

vessels-lib/src/test/java/es/redmic/vesselslib/unit/events/vessel/VesselEventFactoryTest.java

0 → 100644
+248 −0
Original line number Diff line number Diff line 
package es.redmic.vesselslib.unit.events.vessel;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;



import org.junit.Test;



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

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

import es.redmic.vesselslib.events.vessel.VesselEventFactory;

import es.redmic.vesselslib.events.vessel.VesselEventTypes;

import es.redmic.vesselslib.events.vessel.create.CreateVesselCancelledEvent;

import es.redmic.vesselslib.events.vessel.create.CreateVesselFailedEvent;

import es.redmic.vesselslib.events.vessel.create.VesselCreatedEvent;

import es.redmic.vesselslib.events.vessel.delete.DeleteVesselCancelledEvent;

import es.redmic.vesselslib.events.vessel.delete.DeleteVesselCheckFailedEvent;

import es.redmic.vesselslib.events.vessel.delete.DeleteVesselCheckedEvent;

import es.redmic.vesselslib.events.vessel.delete.DeleteVesselEvent;

import es.redmic.vesselslib.events.vessel.delete.DeleteVesselFailedEvent;

import es.redmic.vesselslib.events.vessel.delete.VesselDeletedEvent;

import es.redmic.vesselslib.events.vessel.partialupdate.vesseltype.UpdateVesselTypeInVesselEvent;

import es.redmic.vesselslib.events.vessel.update.UpdateVesselCancelledEvent;

import es.redmic.vesselslib.events.vessel.update.UpdateVesselFailedEvent;

import es.redmic.vesselslib.events.vessel.update.VesselUpdatedEvent;

import es.redmic.vesselslib.events.vesseltype.update.VesselTypeUpdatedEvent;

import es.redmic.vesselslib.unit.utils.VesselDataUtil;

import es.redmic.vesselslib.unit.utils.VesselTypeDataUtil;



public class VesselEventFactoryTest {



	@Test

	public void GetEvent_ReturnDeleteVesselEvent_IfTypeIsDelete() {



		Event source = VesselDataUtil.getDeleteVesselCheckedEvent();

		DeleteVesselEvent event = (DeleteVesselEvent) VesselEventFactory.getEvent(source, VesselEventTypes.DELETE);



		assertEquals(VesselEventTypes.DELETE, event.getType());



		checkMetadataFields(source, event);

	}



	@Test

	public void GetEvent_ReturnDeleteVesselCheckedEvent_IfTypeIsDelete_Checked() {



		Event source = VesselDataUtil.getCheckDeleteVesselEvent();

		DeleteVesselCheckedEvent event = (DeleteVesselCheckedEvent) VesselEventFactory.getEvent(source,

				VesselEventTypes.DELETE_CHECKED);



		assertEquals(VesselEventTypes.DELETE_CHECKED, event.getType());



		checkMetadataFields(source, event);

	}



	@Test

	public void GetEvent_ReturnDeleteVesselCheckedEvent_IfTypeIsDeleted() {



		Event source = VesselDataUtil.getDeleteVesselConfirmedEvent();

		VesselDeletedEvent event = (VesselDeletedEvent) VesselEventFactory.getEvent(source, VesselEventTypes.DELETED);



		assertEquals(VesselEventTypes.DELETED, event.getType());



		checkMetadataFields(source, event);

	}



	/////////////////////////



	@Test

	public void GetEvent_ReturnVesselCreatedEvent_IfTypeIsCreated() {



		Event source = VesselDataUtil.getCreateConfirmedEvent();

		VesselCreatedEvent event = (VesselCreatedEvent) VesselEventFactory.getEvent(source, VesselEventTypes.CREATED,

				VesselDataUtil.getVessel());



		assertEquals(VesselEventTypes.CREATED, event.getType());

		assertNotNull(event.getVessel());



		checkMetadataFields(source, event);

	}



	@Test

	public void GetEvent_ReturnVesselCreatedEvent_IfTypeIsUpdated() {



		Event source = VesselDataUtil.getUpdateVesselConfirmedEvent();

		VesselUpdatedEvent event = (VesselUpdatedEvent) VesselEventFactory.getEvent(source, VesselEventTypes.UPDATED,

				VesselDataUtil.getVessel());



		assertEquals(VesselEventTypes.UPDATED, event.getType());

		assertNotNull(event.getVessel());



		checkMetadataFields(source, event);

	}



	///////////////////



	@Test

	public void GetEvent_ReturnUpdateVesselTypeInVesselEvent_IfTypeIsUpdatedVesselType() {



		Event source = VesselDataUtil.getVesselUpdatedEvent();

		VesselTypeUpdatedEvent vesselTypeUpdated = VesselTypeDataUtil.getVesselTypeUpdatedEvent();



		UpdateVesselTypeInVesselEvent event = (UpdateVesselTypeInVesselEvent) VesselEventFactory.getEvent(source,

				vesselTypeUpdated, VesselEventTypes.UPDATE_VESSELTYPE);



		assertEquals(VesselEventTypes.UPDATE_VESSELTYPE, event.getType());

		assertNotNull(event.getVesselType());

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

		assertEquals(vesselTypeUpdated.getUserId(), event.getUserId());



		Integer versionExpected = source.getVersion() + 1;

		assertEquals(versionExpected.toString(), event.getVersion().toString());

	}



	///////////////////



	@Test

	public void GetEvent_ReturnCreateVesselFailedEvent_IfTypeIsCreateFailed() {



		CreateVesselFailedEvent exception = VesselDataUtil.getCreateVesselFailedEvent();



		Event source = VesselDataUtil.getCreateEvent();



		CreateVesselFailedEvent event = (CreateVesselFailedEvent) VesselEventFactory.getEvent(source,

				VesselEventTypes.CREATE_FAILED, exception.getExceptionType(), exception.getArguments());



		assertEquals(VesselEventTypes.CREATE_FAILED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

	}



	@Test

	public void GetEvent_ReturnUpdateVesselFailedEvent_IfTypeIsUpdateFailed() {



		UpdateVesselFailedEvent exception = VesselDataUtil.getUpdateVesselFailedEvent();



		Event source = VesselDataUtil.getUpdateEvent();



		UpdateVesselFailedEvent event = (UpdateVesselFailedEvent) VesselEventFactory.getEvent(source,

				VesselEventTypes.UPDATE_FAILED, exception.getExceptionType(), exception.getArguments());



		assertEquals(VesselEventTypes.UPDATE_FAILED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

	}



	@Test

	public void GetEvent_ReturnDeleteVesselFailedEventt_IfTypeIsDeleteFailed() {



		DeleteVesselFailedEvent exception = VesselDataUtil.getDeleteVesselFailedEvent();



		Event source = VesselDataUtil.getDeleteEvent();



		DeleteVesselFailedEvent event = (DeleteVesselFailedEvent) VesselEventFactory.getEvent(source,

				VesselEventTypes.DELETE_FAILED, exception.getExceptionType(), exception.getArguments());



		assertEquals(VesselEventTypes.DELETE_FAILED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

	}



	@Test

	public void GetEvent_ReturnDeleteVesselCheckFailedEvent_IfTypeIsDeleteCheckFailed() {



		DeleteVesselCheckFailedEvent exception = VesselDataUtil.getDeleteVesselCheckFailedEvent();



		Event source = VesselDataUtil.getCheckDeleteVesselEvent();



		DeleteVesselCheckFailedEvent event = (DeleteVesselCheckFailedEvent) VesselEventFactory.getEvent(source,

				VesselEventTypes.DELETE_CHECK_FAILED, exception.getExceptionType(), exception.getArguments());



		assertEquals(VesselEventTypes.DELETE_CHECK_FAILED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

	}



	@Test

	public void GetEvent_ReturnCreateVesselCancelledEvent_IfTypeIsCreateCancelled() {



		CreateVesselCancelledEvent exception = VesselDataUtil.getCreateVesselCancelledEvent();



		Event source = VesselDataUtil.getCreateEvent();



		CreateVesselCancelledEvent event = (CreateVesselCancelledEvent) VesselEventFactory.getEvent(source,

				VesselEventTypes.CREATE_CANCELLED, exception.getExceptionType(), exception.getArguments());



		assertEquals(VesselEventTypes.CREATE_CANCELLED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

	}



	////////////////////



	@Test

	public void GetEvent_ReturnUpdateVesselCancelledEvent_IfTypeIsUpdateCancelled() {



		UpdateVesselCancelledEvent exception = VesselDataUtil.getUpdateVesselCancelledEvent();



		Event source = VesselDataUtil.getUpdateEvent();



		UpdateVesselCancelledEvent event = (UpdateVesselCancelledEvent) VesselEventFactory.getEvent(source,

				VesselEventTypes.UPDATE_CANCELLED, VesselDataUtil.getVessel(), exception.getExceptionType(),

				exception.getArguments());



		assertEquals(VesselEventTypes.UPDATE_CANCELLED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

		assertNotNull(event.getVessel());

	}



	@Test

	public void GetEvent_ReturnDeleteVesselCancelledEvent_IfTypeIsDeleteCancelled() {



		DeleteVesselCancelledEvent exception = VesselDataUtil.getDeleteVesselCancelledEvent();



		Event source = VesselDataUtil.getDeleteEvent();



		DeleteVesselCancelledEvent event = (DeleteVesselCancelledEvent) VesselEventFactory.getEvent(source,

				VesselEventTypes.DELETE_CANCELLED, VesselDataUtil.getVessel(), exception.getExceptionType(),

				exception.getArguments());



		assertEquals(VesselEventTypes.DELETE_CANCELLED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

		assertNotNull(event.getVessel());

	}



	////////////////////



	private void checkMetadataFields(Event source, Event evt) {



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

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

		assertEquals(source.getSessionId(), evt.getSessionId());

		assertEquals(source.getUserId(), evt.getUserId());

	}



	private void checkErrorFields(EventError source, EventError evt) {



		assertEquals(source.getExceptionType(), evt.getExceptionType());

		assertEquals(source.getArguments(), evt.getArguments());

	}

}

vessels-lib/src/test/java/es/redmic/vesselslib/unit/events/vesseltype/VesselTypeEventFactoryTest.java

0 → 100644
+229 −0

File added.

Preview size limit exceeded, changes collapsed.