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

Añade tests para la generación de eventos

parent 8c202802

src/test/java/es/redmic/commandslib/usersettings/SettingsDataUtil.java

0 → 100644
+254 −0
Original line number Diff line number Diff line 
package es.redmic.commandslib.usersettings;



/*-

 * #%L

 * commands-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.ArrayList;

import java.util.HashMap;

import java.util.Map;



import org.joda.time.DateTime;



import es.redmic.usersettingslib.dto.PersistenceDTO;

import es.redmic.usersettingslib.dto.SelectionDTO;

import es.redmic.usersettingslib.events.SettingsEventTypes;

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

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

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

import es.redmic.usersettingslib.events.delete.DeleteSettingsCancelledEvent;

import es.redmic.usersettingslib.events.delete.DeleteSettingsEvent;

import es.redmic.usersettingslib.events.delete.SettingsDeletedEvent;

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

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

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

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

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

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

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

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

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



public abstract class SettingsDataUtil {



	// @formatter:off

	public final static String PREFIX = "settings-",

			USER = "1";

	// @formatter:on



	// SELECT



	public static SelectEvent getSelectEvent(String code) {



		SelectEvent evt = new SelectEvent();

		evt.setAggregateId(PREFIX + code);

		evt.setType(SettingsEventTypes.SELECT);

		evt.setVersion(1);

		evt.setUserId(USER);

		evt.setSelection(getSelectionDTO(code));

		return evt;

	}



	public static SelectedEvent getSelectedEvent(String code) {



		SelectedEvent evt = new SelectedEvent().buildFrom(getSelectEvent(code));

		evt.setType(SettingsEventTypes.SELECTED);

		evt.setSelection(getSelectionDTO(code));

		return evt;

	}



	public static SelectCancelledEvent getSelectCancelledEvent(String code) {



		SelectCancelledEvent evt = new SelectCancelledEvent().buildFrom(getSelectEvent(code));

		evt.setType(SettingsEventTypes.SELECT_CANCELLED);

		evt.setSelection(getSelectionDTO(code));

		evt.setExceptionType("ItemNotFound");

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

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

		evt.setArguments(arguments);

		return evt;

	}



	// DESELECT



	public static DeselectEvent getDeselectEvent(String code) {



		DeselectEvent evt = new DeselectEvent();

		evt.setAggregateId(PREFIX + code);

		evt.setType(SettingsEventTypes.SELECT);

		evt.setVersion(1);

		evt.setUserId(USER);

		evt.setSelection(getSelectionDTO(code));

		return evt;

	}



	public static DeselectedEvent getDeselectedEvent(String code) {



		DeselectedEvent evt = new DeselectedEvent().buildFrom(getDeselectEvent(code));

		evt.setType(SettingsEventTypes.DESELECTED);

		evt.setSelection(getSelectionDTO(code));

		return evt;

	}



	public static DeselectCancelledEvent getDeselectCancelledEvent(String code) {



		DeselectCancelledEvent evt = new DeselectCancelledEvent().buildFrom(getDeselectEvent(code));

		evt.setType(SettingsEventTypes.DESELECT_CANCELLED);

		evt.setSelection(getSelectionDTO(code));

		evt.setExceptionType("ItemNotFound");

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

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

		evt.setArguments(arguments);

		return evt;

	}



	// CLEAR



	public static ClearEvent getClearEvent(String code) {



		ClearEvent evt = new ClearEvent();

		evt.setAggregateId(PREFIX + code);

		evt.setType(SettingsEventTypes.CLEAR);

		evt.setVersion(1);

		evt.setUserId(USER);

		evt.setSelection(getSelectionDTO(code));

		return evt;

	}



	public static ClearedEvent getClearedEvent(String code) {



		ClearedEvent evt = new ClearedEvent().buildFrom(getClearEvent(code));

		evt.setType(SettingsEventTypes.CLEARED);

		evt.setSelection(getSelectionDTO(code));

		return evt;

	}



	public static ClearCancelledEvent getClearCancelledEvent(String code) {



		ClearCancelledEvent evt = new ClearCancelledEvent().buildFrom(getClearEvent(code));

		evt.setType(SettingsEventTypes.CLEAR_CANCELLED);

		evt.setSelection(getSelectionDTO(code));

		evt.setExceptionType("ItemNotFound");

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

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

		evt.setArguments(arguments);

		return evt;

	}



	// SAVE



	public static SaveSettingsEvent getSaveSettingsEvent(String code) {



		SaveSettingsEvent evt = new SaveSettingsEvent();

		evt.setAggregateId(PREFIX + code);

		evt.setType(SettingsEventTypes.SAVE);

		evt.setVersion(1);

		evt.setUserId(USER);

		evt.setPersistence(getPersistenceDTO(code));

		return evt;

	}



	public static SettingsSavedEvent getSettingsSavedEvent(String code) {



		SettingsSavedEvent evt = new SettingsSavedEvent().buildFrom(getSaveSettingsEvent(code));

		evt.setType(SettingsEventTypes.SAVED);

		evt.setPersistence(getPersistenceDTO(code));

		return evt;

	}



	public static SaveSettingsCancelledEvent getSaveSettingsCancelledEvent(String code) {



		SaveSettingsCancelledEvent evt = new SaveSettingsCancelledEvent().buildFrom(getSaveSettingsEvent(code));

		evt.setType(SettingsEventTypes.SAVE_CANCELLED);

		evt.setPersistence(getPersistenceDTO(code));

		evt.setExceptionType("ItemNotFound");

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

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

		evt.setArguments(arguments);

		return evt;

	}



	// DELETE



	public static DeleteSettingsEvent getDeleteSettingsEvent(String code) {



		DeleteSettingsEvent evt = new DeleteSettingsEvent();

		evt.setAggregateId(PREFIX + code);

		evt.setType(SettingsEventTypes.DELETE);

		evt.setVersion(1);

		evt.setUserId(USER);

		return evt;

	}



	public static SettingsDeletedEvent getSettingsDeletedEvent(String code) {



		SettingsDeletedEvent evt = new SettingsDeletedEvent().buildFrom(getDeleteSettingsEvent(code));

		evt.setType(SettingsEventTypes.DELETED);

		return evt;

	}



	public static DeleteSettingsCancelledEvent getDeleteSettingsCancelledEvent(String code) {



		DeleteSettingsCancelledEvent evt = new DeleteSettingsCancelledEvent().buildFrom(getDeleteSettingsEvent(code));

		evt.setType(SettingsEventTypes.DELETE_CANCELLED);

		evt.setPersistence(getPersistenceDTO(code));

		evt.setExceptionType("ItemNotFound");

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

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

		evt.setArguments(arguments);

		return evt;

	}



	//



	@SuppressWarnings("serial")

	public static SelectionDTO getSelectionDTO(String code) {



		SelectionDTO selection = new SelectionDTO();



		selection.setId(PREFIX + code);

		selection.setService("prueba");

		selection.setSelection(new ArrayList<String>() {

			{

				add("1");

			}

		});



		selection.setInserted(DateTime.now());

		selection.setUpdated(DateTime.now());

		selection.setAccessed(DateTime.now());

		return selection;

	}



	public static PersistenceDTO getPersistenceDTO(String code) {



		PersistenceDTO persistence = new PersistenceDTO();



		persistence.setId(PREFIX + code);

		persistence.setName("prueba");

		persistence.setUserId(USER);



		persistence.setService("prueba");



		persistence.setInserted(DateTime.now());

		persistence.setUpdated(DateTime.now());

		persistence.setAccessed(DateTime.now());

		return persistence;

	}

}

src/test/java/es/redmic/commandslib/usersettings/persistence/ApplyEventTest.java

0 → 100644
+194 −0
Original line number Diff line number Diff line 
package es.redmic.commandslib.usersettings.persistence;



/*-

 * #%L

 * commands-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 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.brokerlib.avro.common.Event;

import es.redmic.commandslib.exceptions.ItemLockedException;

import es.redmic.commandslib.usersettings.SettingsDataUtil;

import es.redmic.commandslib.usersettings.aggregate.PersistenceAggregate;

import es.redmic.commandslib.usersettings.statestore.SettingsStateStore;

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

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

import es.redmic.usersettingslib.events.delete.DeleteSettingsCancelledEvent;

import es.redmic.usersettingslib.events.delete.DeleteSettingsEvent;

import es.redmic.usersettingslib.events.delete.SettingsDeletedEvent;

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

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

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



@RunWith(MockitoJUnitRunner.class)

public class ApplyEventTest {



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



	SettingsStateStore settingsStateStore;



	PersistenceAggregate agg;



	@Before

	public void setUp() {



		settingsStateStore = Mockito.mock(SettingsStateStore.class);



		agg = new PersistenceAggregate(settingsStateStore);

	}



	@Test

	public void applySettingsSavedEvent_ChangeAggregateState_IfProcessIsOk() {



		SettingsSavedEvent evt = SettingsDataUtil.getSettingsSavedEvent(code);



		agg.apply(evt);



		checkSavedState(evt);

	}



	@Test

	public void applySettingsDeletedEvent_ChangeAggregateState_IfProcessIsOk() {



		SettingsDeletedEvent evt = SettingsDataUtil.getSettingsDeletedEvent(code);



		agg.apply(evt);



		checkDeletedState(evt);

	}



	@Test

	public void applySaveSettingsCancelledEvent_ChangeAggregateState_IfProcessIsOk() {



		SaveSettingsCancelledEvent evt = SettingsDataUtil.getSaveSettingsCancelledEvent(code);



		agg.apply(evt);



		checkCancelledState(evt);

	}



	@Test

	public void applyDeleteSettingsCancelledEvent_ChangeAggregateState_IfProcessIsOk() {



		DeleteSettingsCancelledEvent evt = SettingsDataUtil.getDeleteSettingsCancelledEvent(code);



		agg.apply(evt);



		checkCancelledState(evt);

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToSaved_IfEventIsSaved() {



		SettingsSavedEvent evt = SettingsDataUtil.getSettingsSavedEvent(code);



		agg.loadFromHistory(evt);



		checkSavedState(evt);

	}



	@Test(expected = ItemLockedException.class)

	public void loadFromHistory_ThrowItemLockedException_IfEventIsCreate() {



		SaveSettingsEvent evt = SettingsDataUtil.getSaveSettingsEvent(code);



		agg.loadFromHistory(evt);

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToDeleted_IfEventIsDeleted() {



		SettingsDeletedEvent evt = SettingsDataUtil.getSettingsDeletedEvent(code);



		agg.loadFromHistory(evt);



		checkDeletedState(evt);

	}



	@Test(expected = ItemLockedException.class)

	public void loadFromHistory_ThrowItemLockedException_IfEventIsUpdate() {



		DeleteSettingsEvent evt = SettingsDataUtil.getDeleteSettingsEvent(code);



		agg.loadFromHistory(evt);

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToSaveSettingsCancelled_IfLastEventIsSaveSettingsCancelledEvent() {



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



		history.add(SettingsDataUtil.getSettingsSavedEvent(code));



		history.add(SettingsDataUtil.getSaveSettingsCancelledEvent(code));



		agg.loadFromHistory(history);



		checkCancelledState((PersistenceCancelledEvent) history.get(1));

	}



	@Test

	public void loadFromHistory_ChangeAggregateStateToDeleteCancelled_IfLastEventIsDeleteCancelled() {



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



		history.add(SettingsDataUtil.getSettingsSavedEvent(code));



		history.add(SettingsDataUtil.getDeleteSettingsCancelledEvent(code));



		agg.loadFromHistory(history);



		checkCancelledState((PersistenceCancelledEvent) history.get(1));

	}



	private void checkCancelledState(PersistenceCancelledEvent evt) {



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

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

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

		assertFalse(agg.isDeleted());

	}



	private void checkSavedState(PersistenceEvent evt) {



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

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

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

		assertFalse(agg.isDeleted());

	}



	private void checkDeletedState(SettingsDeletedEvent evt) {



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

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

		assertTrue(agg.isDeleted());

	}

}

src/test/java/es/redmic/commandslib/usersettings/persistence/ProcessEventTest.java

0 → 100644
+147 −0
Original line number Diff line number Diff line 
package es.redmic.commandslib.usersettings.persistence;



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.commandslib.exceptions.ItemLockedException;

import es.redmic.commandslib.usersettings.SettingsDataUtil;

import es.redmic.commandslib.usersettings.aggregate.PersistenceAggregate;

import es.redmic.commandslib.usersettings.commands.DeleteSettingsCommand;

import es.redmic.commandslib.usersettings.commands.SaveSettingsCommand;

import es.redmic.commandslib.usersettings.commands.UpdateSettingsCommand;

import es.redmic.commandslib.usersettings.statestore.SettingsStateStore;

import es.redmic.exception.data.ItemNotFoundException;

import es.redmic.usersettingslib.dto.PersistenceDTO;

import es.redmic.usersettingslib.events.SettingsEventTypes;

import es.redmic.usersettingslib.events.delete.CheckDeleteSettingsEvent;

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



@RunWith(MockitoJUnitRunner.class)

public class ProcessEventTest {



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



	SettingsStateStore settingsStateStore;



	PersistenceAggregate agg;



	@Before

	public void setUp() {



		settingsStateStore = Mockito.mock(SettingsStateStore.class);



		agg = new PersistenceAggregate(settingsStateStore);

	}



	@Test

	public void processSaveSettingsCommand_ReturnSaveEvent_IfProcessIsOk() {



		when(settingsStateStore.get(any())).thenReturn(null);



		PersistenceDTO persistence = SettingsDataUtil.getPersistenceDTO(code);



		SaveSettingsCommand command = new SaveSettingsCommand(persistence);



		SaveSettingsEvent evt = agg.process(command);



		assertNotNull(evt);

		assertNotNull(evt.getDate());

		assertNotNull(evt.getPersistence());

		assertEquals(evt.getPersistence(), persistence);

		assertNotNull(evt.getId());

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

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

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

	}



	@Test

	public void processUpdateSettingsCommand_ReturnSaveEvent_IfProcessIsOk() {



		when(settingsStateStore.get(any())).thenReturn(SettingsDataUtil.getSettingsSavedEvent(code));



		PersistenceDTO persistence = SettingsDataUtil.getPersistenceDTO(code);



		UpdateSettingsCommand command = new UpdateSettingsCommand(persistence);



		SaveSettingsEvent evt = agg.process(command);



		assertNotNull(evt);

		assertNotNull(evt.getDate());

		assertNotNull(evt.getPersistence());

		assertEquals(evt.getPersistence(), persistence);

		assertNotNull(evt.getId());

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

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

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

	}



	// Editar un elemento ya borrado

	@Test(expected = ItemNotFoundException.class)

	public void processUpdateSettingsCommand_ThrowItemNotFoundException_IfItemIsDeleted() {



		when(settingsStateStore.get(any())).thenReturn(SettingsDataUtil.getSettingsDeletedEvent(code));



		agg.process(new UpdateSettingsCommand(SettingsDataUtil.getPersistenceDTO(code)));

	}



	// Editar un elemento bloqueado

	@Test(expected = ItemLockedException.class)

	public void processUpdateCategoryCommand_ThrowItemLockedException_IfItemIsLocked() {



		when(settingsStateStore.get(any())).thenReturn(SettingsDataUtil.getSaveSettingsEvent(code));



		agg.process(new UpdateSettingsCommand(SettingsDataUtil.getPersistenceDTO(code)));

	}



	@Test

	public void processDeleteSettingsCommand_ReturnCheckDeleteSettingsEvent_IfProcessIsOk() {



		when(settingsStateStore.get(any())).thenReturn(SettingsDataUtil.getSettingsSavedEvent(code));



		PersistenceDTO persistence = SettingsDataUtil.getPersistenceDTO(code);



		DeleteSettingsCommand command = new DeleteSettingsCommand(persistence.getId());



		CheckDeleteSettingsEvent evt = agg.process(command);



		assertNotNull(evt);

		assertNotNull(evt.getDate());

		assertNotNull(evt.getId());

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

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

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

	}



	// Borrar un elemento ya borrado

	@Test(expected = ItemNotFoundException.class)

	public void processDeleteSettingsCommand_ThrowItemNotFoundException_IfItemIsDeleted() {



		when(settingsStateStore.get(any())).thenReturn(SettingsDataUtil.getSettingsDeletedEvent(code));



		PersistenceDTO persistence = SettingsDataUtil.getPersistenceDTO(code);



		agg.process(new DeleteSettingsCommand(persistence.getId()));

	}



	// Borrar un elemento bloqueado

	@Test(expected = ItemLockedException.class)

	public void processDeleteSettingsCommand_ThrowItemLockedException_IfItemIsLocked() {



		when(settingsStateStore.get(any())).thenReturn(SettingsDataUtil.getSaveSettingsEvent(code));



		PersistenceDTO persistence = SettingsDataUtil.getPersistenceDTO(code);



		agg.process(new DeleteSettingsCommand(persistence.getId()));

	}

}

src/test/java/es/redmic/commandslib/usersettings/selection/ApplyEventTest.java

0 → 100644
+241 −0

File added.

Preview size limit exceeded, changes collapsed.

src/test/java/es/redmic/commandslib/usersettings/selection/ProcessEventTest.java

0 → 100644
+176 −0
Original line number Diff line number Diff line 
package es.redmic.commandslib.usersettings.selection;



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;



/*-

 * #%L

 * commands-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 org.junit.runner.RunWith;

import org.mockito.Mockito;

import org.mockito.junit.MockitoJUnitRunner;



import es.redmic.commandslib.exceptions.HistoryNotFoundException;

import es.redmic.commandslib.exceptions.ItemLockedException;

import es.redmic.commandslib.usersettings.SettingsDataUtil;

import es.redmic.commandslib.usersettings.aggregate.SelectionAggregate;

import es.redmic.commandslib.usersettings.commands.ClearCommand;

import es.redmic.commandslib.usersettings.commands.DeselectCommand;

import es.redmic.commandslib.usersettings.commands.SelectCommand;

import es.redmic.commandslib.usersettings.statestore.SettingsStateStore;

import es.redmic.usersettingslib.dto.SelectionDTO;

import es.redmic.usersettingslib.events.SettingsEventTypes;

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

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

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



@RunWith(MockitoJUnitRunner.class)

public class ProcessEventTest {



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



	SettingsStateStore settingsStateStore;



	SelectionAggregate agg;



	@Before

	public void setUp() {



		settingsStateStore = Mockito.mock(SettingsStateStore.class);



		agg = new SelectionAggregate(settingsStateStore);

	}



	@Test

	public void processSelectCommand_ReturnSelectEvent_IfProcessIsOk() {



		when(settingsStateStore.get(any())).thenReturn(null);



		SelectionDTO selection = SettingsDataUtil.getSelectionDTO(code);



		SelectCommand command = new SelectCommand(selection);



		SelectEvent evt = agg.process(command);



		assertNotNull(evt);

		assertNotNull(evt.getDate());

		assertNotNull(evt.getSelection());

		assertEquals(evt.getSelection(), selection);

		assertNotNull(evt.getId());

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

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

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

	}



	@Test

	public void processDeselectCommand_ReturnDeselectEvent_IfProcessIsOk() {



		when(settingsStateStore.get(any())).thenReturn(SettingsDataUtil.getSelectedEvent(code));



		SelectionDTO selection = SettingsDataUtil.getSelectionDTO(code);



		DeselectCommand command = new DeselectCommand(selection);



		DeselectEvent evt = agg.process(command);



		assertNotNull(evt);

		assertNotNull(evt.getDate());

		assertNotNull(evt.getSelection());

		assertEquals(evt.getSelection(), selection);

		assertNotNull(evt.getId());

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

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

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

	}



	@Test

	public void processClearCommand_ReturnClearEvent_IfProcessIsOk() {



		when(settingsStateStore.get(any())).thenReturn(SettingsDataUtil.getSelectedEvent(code));



		SelectionDTO selection = SettingsDataUtil.getSelectionDTO(code);



		ClearCommand command = new ClearCommand(selection);



		ClearEvent evt = agg.process(command);



		assertNotNull(evt);

		assertNotNull(evt.getDate());

		assertNotNull(evt.getSelection());

		assertEquals(evt.getSelection(), selection);

		assertNotNull(evt.getId());

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

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

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

	}



	// Seleccionar un item con una selección bloqueada

	@Test(expected = ItemLockedException.class)

	public void processSelectCommand_ThrowItemLockedException_IfItemIsLocked() {



		when(settingsStateStore.get(any())).thenReturn(SettingsDataUtil.getSelectEvent(code));



		agg.process(new SelectCommand(SettingsDataUtil.getSelectionDTO(code)));

	}



	// Deseleccionar un item con una selección que no existe

	@Test(expected = HistoryNotFoundException.class)

	public void processDeselectCommand_ThrowItemNotFoundException_IfItemNotExist() {



		when(settingsStateStore.get(any())).thenReturn(null);



		agg.process(new DeselectCommand(SettingsDataUtil.getSelectionDTO(code)));

	}



	// Seleccionar un item con una selección bloqueada

	@Test(expected = ItemLockedException.class)

	public void processDeselectCommand_ThrowItemLockedException_IfItemIsLocked() {



		when(settingsStateStore.get(any())).thenReturn(SettingsDataUtil.getSelectEvent(code));



		agg.process(new DeselectCommand(SettingsDataUtil.getSelectionDTO(code)));

	}



	// Deseleccionar un item con una selección que no existe

	@Test(expected = HistoryNotFoundException.class)

	public void processClearCommand_ThrowItemNotFoundException_IfItemNotExist() {



		when(settingsStateStore.get(any())).thenReturn(null);



		agg.process(new ClearCommand(SettingsDataUtil.getSelectionDTO(code)));

	}



	// Seleccionar un item con una selección bloqueada

	@Test(expected = ItemLockedException.class)

	public void processClearCommand_ThrowItemLockedException_IfItemIsLocked() {



		when(settingsStateStore.get(any())).thenReturn(SettingsDataUtil.getSelectEvent(code));



		agg.process(new ClearCommand(SettingsDataUtil.getSelectionDTO(code)));

	}

}