Commit 3a2fe796 authored by Noel Alonso's avatar Noel Alonso
Browse files

Añade factoría para eventos + tests

parent 191affdf

src/main/java/es/redmic/usersettingslib/events/SettingsEventFactory.java

0 → 100644
+266 −0
Original line number Diff line number Diff line 
package es.redmic.usersettingslib.events;



/*-

 * #%L

 * user-settings-lib

 * %%

 * 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.Map;



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.usersettingslib.dto.PersistenceDTO;

import es.redmic.usersettingslib.dto.SelectionDTO;

import es.redmic.usersettingslib.events.clear.ClearCancelledEvent;

import es.redmic.usersettingslib.events.clear.ClearConfirmedEvent;

import es.redmic.usersettingslib.events.clear.ClearEvent;

import es.redmic.usersettingslib.events.clear.ClearFailedEvent;

import es.redmic.usersettingslib.events.clear.ClearedEvent;

import es.redmic.usersettingslib.events.common.PersistenceCancelledEvent;

import es.redmic.usersettingslib.events.common.PersistenceEvent;

import es.redmic.usersettingslib.events.common.SelectionCancelledEvent;

import es.redmic.usersettingslib.events.common.SelectionEvent;

import es.redmic.usersettingslib.events.deselect.DeselectCancelledEvent;

import es.redmic.usersettingslib.events.deselect.DeselectConfirmedEvent;

import es.redmic.usersettingslib.events.deselect.DeselectEvent;

import es.redmic.usersettingslib.events.deselect.DeselectFailedEvent;

import es.redmic.usersettingslib.events.deselect.DeselectedEvent;

import es.redmic.usersettingslib.events.save.SaveCancelledEvent;

import es.redmic.usersettingslib.events.save.SaveConfirmedEvent;

import es.redmic.usersettingslib.events.save.SaveEvent;

import es.redmic.usersettingslib.events.save.SaveFailedEvent;

import es.redmic.usersettingslib.events.save.SavedEvent;

import es.redmic.usersettingslib.events.select.SelectCancelledEvent;

import es.redmic.usersettingslib.events.select.SelectConfirmedEvent;

import es.redmic.usersettingslib.events.select.SelectEvent;

import es.redmic.usersettingslib.events.select.SelectFailedEvent;

import es.redmic.usersettingslib.events.select.SelectedEvent;



public class SettingsEventFactory {



	private static Logger logger = LogManager.getLogger();



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



		if (type.equals(SettingsEventTypes.SELECT)) {



			logger.debug("Creando evento SelectEvent para: " + source.getAggregateId());

			return new SelectEvent().buildFrom(source);

		}



		if (type.equals(SettingsEventTypes.DESELECT)) {



			logger.debug("Creando evento DeselectEvent para: " + source.getAggregateId());

			return new DeselectEvent().buildFrom(source);

		}



		if (type.equals(SettingsEventTypes.CLEAR)) {



			logger.debug("Creando evento ClearEvent para: " + source.getAggregateId());

			return new ClearEvent().buildFrom(source);

		}



		if (type.equals(SettingsEventTypes.SAVE)) {



			logger.debug("Creando evento SaveEvent para: " + source.getAggregateId());

			return new SaveEvent().buildFrom(source);

		}



		if (type.equals(SettingsEventTypes.SELECT_CONFIRMED)) {



			logger.debug("Creando evento SelectConfirmedEvent para: " + source.getAggregateId());



			return new SelectConfirmedEvent().buildFrom(source);

		}



		if (type.equals(SettingsEventTypes.DESELECT_CONFIRMED)) {



			logger.debug("Creando evento DeselectConfirmedEvent para: " + source.getAggregateId());



			return new DeselectConfirmedEvent().buildFrom(source);

		}



		if (type.equals(SettingsEventTypes.CLEAR_CONFIRMED)) {



			logger.debug("Creando evento ClearConfirmedEvent para: " + source.getAggregateId());



			return new ClearConfirmedEvent().buildFrom(source);

		}



		if (type.equals(SettingsEventTypes.SAVE_CONFIRMED)) {



			logger.debug("Creando evento SaveConfirmedEvent para: " + source.getAggregateId());

			return new SaveConfirmedEvent().buildFrom(source);

		}



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

		throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

	}



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



		SelectionEvent successfulEvent = null;



		if (type.equals(SettingsEventTypes.SELECTED)) {

			logger.debug("Creando evento SettingsCreatedEvent para: " + source.getAggregateId());

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

		}



		if (type.equals(SettingsEventTypes.DESELECTED)) {

			logger.debug("Creando evento SettingsUpdatedEvent para: " + source.getAggregateId());

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

		}



		if (type.equals(SettingsEventTypes.CLEARED)) {

			logger.debug("Creando evento SettingsUpdatedEvent para: " + source.getAggregateId());

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

		}



		if (successfulEvent != null) {

			successfulEvent.setSelection(selection);

			return successfulEvent;

		} else {

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

			throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

		}

	}



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



		PersistenceEvent successfulEvent = null;



		if (type.equals(SettingsEventTypes.SAVED)) {

			logger.debug("Creando evento SavedEvent para: " + source.getAggregateId());

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

		}



		if (successfulEvent != null) {

			successfulEvent.setPersistence(persistence);

			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(SettingsEventTypes.SELECT_FAILED)) {



			logger.debug("No se pudo seleccionar el elemento");

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

		}

		if (type.equals(SettingsEventTypes.DESELECT_FAILED)) {



			logger.debug("No se pudo deseleccionar");

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

		}

		if (type.equals(SettingsEventTypes.CLEAR_FAILED)) {



			logger.debug("No se pudo limpiar la selección");

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

		}



		if (type.equals(SettingsEventTypes.SAVE_FAILED)) {



			logger.debug("No se pudo guardar la selección");

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

		}



		if (failedEvent != null) {



			failedEvent.setExceptionType(exceptionType);

			failedEvent.setArguments(exceptionArguments);

			return failedEvent;



		} else {

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

			throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

		}

	}



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

			Map<String, String> exceptionArguments) {



		SelectionCancelledEvent cancelledEvent = null;



		if (type.equals(SettingsEventTypes.SELECT_CANCELLED)) {



			logger.debug("Creando evento SelectCancelledEvent para: " + source.getAggregateId());

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

		}



		if (type.equals(SettingsEventTypes.DESELECT_CANCELLED)) {



			logger.debug("Creando evento DeselectCancelledEvent para: " + source.getAggregateId());

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

		}



		if (type.equals(SettingsEventTypes.CLEAR_CANCELLED)) {



			logger.debug("Creando evento ClearCancelledEvent para: " + source.getAggregateId());

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

		}



		if (cancelledEvent != null) {



			cancelledEvent.setSelection(selection);

			cancelledEvent.setExceptionType(exceptionType);

			cancelledEvent.setArguments(exceptionArguments);

			return cancelledEvent;



		} else {



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

			throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

		}

	}



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

			Map<String, String> exceptionArguments) {



		PersistenceCancelledEvent cancelledEvent = null;



		if (type.equals(SettingsEventTypes.SAVE_CANCELLED)) {



			logger.debug("Creando evento SaveCancelledEvent para: " + source.getAggregateId());

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

		}



		if (cancelledEvent != null) {



			cancelledEvent.setPersistence(persistence);

			cancelledEvent.setExceptionType(exceptionType);

			cancelledEvent.setArguments(exceptionArguments);

			return cancelledEvent;



		} else {



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

			throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);

		}

	}

}

src/test/java/es/redmic/usersettingslib/unit/events/SettingsEventFactoryTest.java

0 → 100644
+360 −0
Original line number Diff line number Diff line 
package es.redmic.usersettingslib.unit.events;



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.usersettingslib.events.SettingsEventFactory;

import es.redmic.usersettingslib.events.SettingsEventTypes;

import es.redmic.usersettingslib.events.clear.ClearCancelledEvent;

import es.redmic.usersettingslib.events.clear.ClearConfirmedEvent;

import es.redmic.usersettingslib.events.clear.ClearEvent;

import es.redmic.usersettingslib.events.clear.ClearFailedEvent;

import es.redmic.usersettingslib.events.clear.ClearedEvent;

import es.redmic.usersettingslib.events.deselect.DeselectCancelledEvent;

import es.redmic.usersettingslib.events.deselect.DeselectConfirmedEvent;

import es.redmic.usersettingslib.events.deselect.DeselectEvent;

import es.redmic.usersettingslib.events.deselect.DeselectFailedEvent;

import es.redmic.usersettingslib.events.deselect.DeselectedEvent;

import es.redmic.usersettingslib.events.save.SaveCancelledEvent;

import es.redmic.usersettingslib.events.save.SaveConfirmedEvent;

import es.redmic.usersettingslib.events.save.SaveEvent;

import es.redmic.usersettingslib.events.save.SaveFailedEvent;

import es.redmic.usersettingslib.events.save.SavedEvent;

import es.redmic.usersettingslib.events.select.SelectCancelledEvent;

import es.redmic.usersettingslib.events.select.SelectConfirmedEvent;

import es.redmic.usersettingslib.events.select.SelectEvent;

import es.redmic.usersettingslib.events.select.SelectFailedEvent;

import es.redmic.usersettingslib.events.select.SelectedEvent;

import es.redmic.usersettingslib.unit.utils.SettingsDataUtil;



/*-

 * #%L

 * user-settings-lib

 * %%

 * 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%

 */



public class SettingsEventFactoryTest {



	@Test

	public void GetEvent_ReturnSelectEvent_IfTypeIsSelect() {



		Event source = SettingsDataUtil.getSelectEvent();

		SelectEvent event = (SelectEvent) SettingsEventFactory.getEvent(source, SettingsEventTypes.SELECT);



		assertEquals(SettingsEventTypes.SELECT, event.getType());



		checkMetadataFields(source, event);

	}



	@Test

	public void GetEvent_ReturnDeselectEvent_IfTypeIsDeselect_Checked() {



		Event source = SettingsDataUtil.getDeselectEvent();

		DeselectEvent event = (DeselectEvent) SettingsEventFactory.getEvent(source, SettingsEventTypes.DESELECT);



		assertEquals(SettingsEventTypes.DESELECT, event.getType());



		checkMetadataFields(source, event);

	}



	@Test

	public void GetEvent_ReturnClearEvent_IfTypeIsClear() {



		Event source = SettingsDataUtil.getClearEvent();

		ClearEvent event = (ClearEvent) SettingsEventFactory.getEvent(source, SettingsEventTypes.CLEAR);



		assertEquals(SettingsEventTypes.CLEAR, event.getType());



		checkMetadataFields(source, event);

	}



	@Test

	public void GetEvent_ReturnSaveEvent_IfTypeIsSave() {



		Event source = SettingsDataUtil.getSaveEvent();

		SaveEvent event = (SaveEvent) SettingsEventFactory.getEvent(source, SettingsEventTypes.SAVE);



		assertEquals(SettingsEventTypes.SAVE, event.getType());



		checkMetadataFields(source, event);

	}



	//



	@Test

	public void GetEvent_ReturnSelectConfirmedEvent_IfTypeIsSelectConfirmed() {



		Event source = SettingsDataUtil.getSelectEvent();

		SelectConfirmedEvent event = (SelectConfirmedEvent) SettingsEventFactory.getEvent(source,

				SettingsEventTypes.SELECT_CONFIRMED);



		assertEquals(SettingsEventTypes.SELECT_CONFIRMED, event.getType());



		checkMetadataFields(source, event);

	}



	@Test

	public void GetEvent_ReturnDeselectConfirmedEvent_IfTypeIsDeselectConfirmed() {



		Event source = SettingsDataUtil.getDeselectEvent();

		DeselectConfirmedEvent event = (DeselectConfirmedEvent) SettingsEventFactory.getEvent(source,

				SettingsEventTypes.DESELECT_CONFIRMED);



		assertEquals(SettingsEventTypes.DESELECT_CONFIRMED, event.getType());



		checkMetadataFields(source, event);

	}



	@Test

	public void GetEvent_ReturnClearConfirmedEvent_IfTypeIsClearConfirmed() {



		Event source = SettingsDataUtil.getClearEvent();

		ClearConfirmedEvent event = (ClearConfirmedEvent) SettingsEventFactory.getEvent(source,

				SettingsEventTypes.CLEAR_CONFIRMED);



		assertEquals(SettingsEventTypes.CLEAR_CONFIRMED, event.getType());



		checkMetadataFields(source, event);

	}



	@Test

	public void GetEvent_ReturnSaveConfirmedEvent_IfTypeIsSaveConfirmed() {



		Event source = SettingsDataUtil.getSaveEvent();

		SaveConfirmedEvent event = (SaveConfirmedEvent) SettingsEventFactory.getEvent(source,

				SettingsEventTypes.SAVE_CONFIRMED);



		assertEquals(SettingsEventTypes.SAVE_CONFIRMED, event.getType());



		checkMetadataFields(source, event);

	}



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



	@Test

	public void GetEvent_ReturnSelectedEvent_IfTypeIsSelected() {



		Event source = SettingsDataUtil.getSelectEvent();

		SelectedEvent event = (SelectedEvent) SettingsEventFactory.getEvent(source, SettingsEventTypes.SELECTED,

				SettingsDataUtil.getSelectionDTO());



		assertEquals(SettingsEventTypes.SELECTED, event.getType());

		assertNotNull(event.getSelection());



		checkMetadataFields(source, event);

	}



	@Test

	public void GetEvent_ReturnDeselectedEvent_IfTypeIsDeselected() {



		Event source = SettingsDataUtil.getDeselectEvent();

		DeselectedEvent event = (DeselectedEvent) SettingsEventFactory.getEvent(source, SettingsEventTypes.DESELECTED,

				SettingsDataUtil.getSelectionDTO());



		assertEquals(SettingsEventTypes.DESELECTED, event.getType());

		assertNotNull(event.getSelection());



		checkMetadataFields(source, event);

	}



	@Test

	public void GetEvent_ReturnClearedEvent_IfTypeIsCleared() {



		Event source = SettingsDataUtil.getClearEvent();

		ClearedEvent event = (ClearedEvent) SettingsEventFactory.getEvent(source, SettingsEventTypes.CLEARED,

				SettingsDataUtil.getSelectionDTO());



		assertEquals(SettingsEventTypes.CLEARED, event.getType());

		assertNotNull(event.getSelection());



		checkMetadataFields(source, event);

	}



	@Test

	public void GetEvent_ReturnSavedEvent_IfTypeIsSaved() {



		Event source = SettingsDataUtil.getSaveEvent();

		SavedEvent event = (SavedEvent) SettingsEventFactory.getEvent(source, SettingsEventTypes.SAVED,

				SettingsDataUtil.getPersistenceDTO());



		assertEquals(SettingsEventTypes.SAVED, event.getType());

		assertNotNull(event.getPersistence());



		checkMetadataFields(source, event);

	}



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



	@Test

	public void GetEvent_ReturnSelectFailedEvent_IfTypeIsSelectFailed() {



		SelectFailedEvent exception = SettingsDataUtil.getSelectFailedEvent();



		Event source = SettingsDataUtil.getSelectEvent();



		SelectFailedEvent event = (SelectFailedEvent) SettingsEventFactory.getEvent(source,

				SettingsEventTypes.SELECT_FAILED, exception.getExceptionType(), exception.getArguments());



		assertEquals(SettingsEventTypes.SELECT_FAILED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

	}



	@Test

	public void GetEvent_ReturnDeselectFailedEvent_IfTypeIsDeselectFailed() {



		DeselectFailedEvent exception = SettingsDataUtil.getDeselectFailedEvent();



		Event source = SettingsDataUtil.getDeselectEvent();



		DeselectFailedEvent event = (DeselectFailedEvent) SettingsEventFactory.getEvent(source,

				SettingsEventTypes.DESELECT_FAILED, exception.getExceptionType(), exception.getArguments());



		assertEquals(SettingsEventTypes.DESELECT_FAILED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

	}



	@Test

	public void GetEvent_ReturnClearFailedEventt_IfTypeIsClearFailed() {



		ClearFailedEvent exception = SettingsDataUtil.getClearFailedEvent();



		Event source = SettingsDataUtil.getClearEvent();



		ClearFailedEvent event = (ClearFailedEvent) SettingsEventFactory.getEvent(source,

				SettingsEventTypes.CLEAR_FAILED, exception.getExceptionType(), exception.getArguments());



		assertEquals(SettingsEventTypes.CLEAR_FAILED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

	}



	@Test

	public void GetEvent_ReturnSaveFailedEvent_IfTypeIsSaveFailed() {



		SaveFailedEvent exception = SettingsDataUtil.getSaveFailedEvent();



		Event source = SettingsDataUtil.getSaveEvent();



		SaveFailedEvent event = (SaveFailedEvent) SettingsEventFactory.getEvent(source, SettingsEventTypes.SAVE_FAILED,

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



		assertEquals(SettingsEventTypes.SAVE_FAILED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

	}



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



	@Test

	public void GetEvent_ReturnSelectCancelledEvent_IfTypeIsSelectCancelled() {



		SelectCancelledEvent exception = SettingsDataUtil.getSelectCancelledEvent();



		Event source = SettingsDataUtil.getSelectEvent();



		SelectCancelledEvent event = (SelectCancelledEvent) SettingsEventFactory.getEvent(source,

				SettingsEventTypes.SELECT_CANCELLED, SettingsDataUtil.getSelectionDTO(), exception.getExceptionType(),

				exception.getArguments());



		assertEquals(SettingsEventTypes.SELECT_CANCELLED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

		assertNotNull(event.getSelection());

	}



	@Test

	public void GetEvent_ReturnDeselectCancelledEvent_IfTypeIsDeselectCancelled() {



		DeselectCancelledEvent exception = SettingsDataUtil.getDeselectCancelledEvent();



		Event source = SettingsDataUtil.getDeselectEvent();



		DeselectCancelledEvent event = (DeselectCancelledEvent) SettingsEventFactory.getEvent(source,

				SettingsEventTypes.DESELECT_CANCELLED, SettingsDataUtil.getSelectionDTO(), exception.getExceptionType(),

				exception.getArguments());



		assertEquals(SettingsEventTypes.DESELECT_CANCELLED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

		assertNotNull(event.getSelection());

	}



	@Test

	public void GetEvent_ReturnClearCancelledEvent_IfTypeIsClearCancelled() {



		ClearCancelledEvent exception = SettingsDataUtil.getClearCancelledEvent();



		Event source = SettingsDataUtil.getClearEvent();



		ClearCancelledEvent event = (ClearCancelledEvent) SettingsEventFactory.getEvent(source,

				SettingsEventTypes.CLEAR_CANCELLED, SettingsDataUtil.getSelectionDTO(), exception.getExceptionType(),

				exception.getArguments());



		assertEquals(SettingsEventTypes.CLEAR_CANCELLED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

		assertNotNull(event.getSelection());

	}



	@Test

	public void GetEvent_ReturnSaveCancelledEvent_IfTypeIsSaveCancelled() {



		SaveCancelledEvent exception = SettingsDataUtil.getSaveCancelledEvent();



		Event source = SettingsDataUtil.getSaveEvent();



		SaveCancelledEvent event = (SaveCancelledEvent) SettingsEventFactory.getEvent(source,

				SettingsEventTypes.SAVE_CANCELLED, SettingsDataUtil.getPersistenceDTO(), exception.getExceptionType(),

				exception.getArguments());



		assertEquals(SettingsEventTypes.SAVE_CANCELLED, event.getType());



		checkMetadataFields(source, event);

		checkErrorFields(exception, event);

		assertNotNull(event.getPersistence());

	}



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



	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());

	}



}