From f278778d53994e2b130ae8aacb295e1130ccc8c0 Mon Sep 17 00:00:00 2001 From: nprentza Date: Fri, 4 Aug 2023 09:43:33 +0300 Subject: [PATCH] more tests, other improvements --- .../core/SerializableStoredRefObject.java | 2 +- ...leSerializationReliableRefObjectStore.java | 25 +++- .../test/ReliabilityFireAndAlarmTest.java | 138 ++++++++++++++++-- 3 files changed, 152 insertions(+), 13 deletions(-) diff --git a/drools-reliability/drools-reliability-core/src/main/java/org/drools/reliability/core/SerializableStoredRefObject.java b/drools-reliability/drools-reliability-core/src/main/java/org/drools/reliability/core/SerializableStoredRefObject.java index 49e986a8226..7093434a763 100644 --- a/drools-reliability/drools-reliability-core/src/main/java/org/drools/reliability/core/SerializableStoredRefObject.java +++ b/drools-reliability/drools-reliability-core/src/main/java/org/drools/reliability/core/SerializableStoredRefObject.java @@ -45,7 +45,7 @@ public StoredObject updateReferencedObjects(Storage storage) try { refField.get().set(this.object, storage.get(this.referencedObjects.get(refField.get().getName())).getObject()); } catch (IllegalAccessException e) { - e.printStackTrace(); + throw new ReliabilityRuntimeException(e); } } }); diff --git a/drools-reliability/drools-reliability-core/src/main/java/org/drools/reliability/core/SimpleSerializationReliableRefObjectStore.java b/drools-reliability/drools-reliability-core/src/main/java/org/drools/reliability/core/SimpleSerializationReliableRefObjectStore.java index 6ccf4d6e38b..ad5c36e4d21 100644 --- a/drools-reliability/drools-reliability-core/src/main/java/org/drools/reliability/core/SimpleSerializationReliableRefObjectStore.java +++ b/drools-reliability/drools-reliability-core/src/main/java/org/drools/reliability/core/SimpleSerializationReliableRefObjectStore.java @@ -19,6 +19,7 @@ import org.drools.core.common.Storage; import java.lang.reflect.Field; +import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; @@ -33,7 +34,7 @@ public SimpleSerializationReliableRefObjectStore(Storage sto super(storage); uniqueObjectTypesInStore = new HashMap<>(); if (storage.size()>0){ - storage.values().forEach(sObject -> {this.putIntoObjectTypesList( sObject.getObject() );}); + updateObjectTypesList(); } this.storage = storage.size()>0 ? updateObjectReferences(storage) : storage; } @@ -53,14 +54,14 @@ public void putIntoPersistedStorage(InternalFactHandle handle, boolean propagate StoredObject storedObject = factHandleToStoredObject(handle, reInitPropagated || propagated, object); storage.put(getHandleForObject(object).getId(), setReferencedObjects(storedObject)); // also add the type of the object into the uniqueObjectTypesInStore list (if not already there) - this.putIntoObjectTypesList(object); + this.updateObjectTypesList(object); } @Override public void removeFromPersistedStorage(Object object) { super.removeFromPersistedStorage(object); // also remove instance from uniqueObjectTypesInStore - this.removeFromObjectTypesList(object); + this.updateObjectTypesList(object); } @Override @@ -108,6 +109,24 @@ private List getReferencedObjects(Object object){ return fieldsWithTypeInTheStore; } + private void updateObjectTypesList(Object object){ + uniqueObjectTypesInStore.put(object.getClass(), + storage.values().stream().filter(sObject -> sObject.getObject().getClass().equals(object.getClass())).count()); + } + + private void updateObjectTypesList(){ + // list of unique object types in storage + List uTypes = new ArrayList<>(); + storage.values().forEach(sObject -> { + if (!uTypes.contains(sObject.getObject().getClass())){uTypes.add(sObject.getObject().getClass());} + }); + // add unique object types + their occurrences in uniqueObjectTypesInStore + uTypes.forEach(uType -> { + uniqueObjectTypesInStore.put(uType, + storage.values().stream().filter(sObject -> sObject.getObject().getClass().equals(uType)).count()); + }); + } + private void putIntoObjectTypesList(Object object){ Long objectTypeCount = uniqueObjectTypesInStore.get(object.getClass()); if (objectTypeCount!=null){ diff --git a/drools-reliability/drools-reliability-tests/src/test/java/org/drools/reliability/test/ReliabilityFireAndAlarmTest.java b/drools-reliability/drools-reliability-tests/src/test/java/org/drools/reliability/test/ReliabilityFireAndAlarmTest.java index a037043c638..3cbbb3660b6 100644 --- a/drools-reliability/drools-reliability-tests/src/test/java/org/drools/reliability/test/ReliabilityFireAndAlarmTest.java +++ b/drools-reliability/drools-reliability-tests/src/test/java/org/drools/reliability/test/ReliabilityFireAndAlarmTest.java @@ -28,7 +28,7 @@ import static org.assertj.core.api.Assertions.assertThat; -public class ReliabilityFireAndAlarmTest extends ReliabilityTestBasics{ +public class ReliabilityFireAndAlarmTest extends ReliabilityTestBasics { private static final String FIRE_AND_ALARM = "import " + Alarm.class.getCanonicalName() + ";" + "import " + Fire.class.getCanonicalName() + ";" + @@ -49,7 +49,7 @@ public class ReliabilityFireAndAlarmTest extends ReliabilityTestBasics{ " insert( new Alarm() );\n" + " System.out.println(\"Raise the alarm\");\n" + " results.add( \"Raise alarm rule\" );\n" + - "end\n"+ + "end\n" + "rule 'Cancel the alarm when all the fires have gone' when \n" + " not Fire() \n" + " $alarm : Alarm() \n" + @@ -69,7 +69,7 @@ public class ReliabilityFireAndAlarmTest extends ReliabilityTestBasics{ @ParameterizedTest @MethodSource("strategyProviderStoresOnlyWithExplicitSafepoints") - void testNoFailover(PersistedSessionOption.PersistenceStrategy persistenceStrategy, PersistedSessionOption.SafepointStrategy safepointStrategy){ + void testNoFailover(PersistedSessionOption.PersistenceStrategy persistenceStrategy, PersistedSessionOption.SafepointStrategy safepointStrategy) { createSession(FIRE_AND_ALARM, persistenceStrategy, safepointStrategy); // phase 1 @@ -91,8 +91,8 @@ void testNoFailover(PersistedSessionOption.PersistenceStrategy persistenceStrate } @ParameterizedTest - @MethodSource("strategyProviderStoresOnlyWithExplicitSafepoints") - void testInsertFailover_ShouldFireRules(PersistedSessionOption.PersistenceStrategy persistenceStrategy, PersistedSessionOption.SafepointStrategy safepointStrategy){ + @MethodSource("strategyProviderStoresOnlyWithExplicitSafepoints") // does not support PersistedSessionOption.PersistenceObjectsStrategy.SIMPLE + void testInsertFailover_ShouldFireRules(PersistedSessionOption.PersistenceStrategy persistenceStrategy, PersistedSessionOption.SafepointStrategy safepointStrategy) { createSession(FIRE_AND_ALARM, persistenceStrategy, safepointStrategy, PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); Room room1 = new Room("Room 1"); @@ -102,7 +102,7 @@ void testInsertFailover_ShouldFireRules(PersistedSessionOption.PersistenceStrate insert(sprinkler1); failover(); - restoreSession(FIRE_AND_ALARM, persistenceStrategy,safepointStrategy,PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); + restoreSession(FIRE_AND_ALARM, persistenceStrategy, safepointStrategy, PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); assertThat(fireAllRules()).isEqualTo(2); Optional sprinklerR = getObjectByType(Sprinkler.class); @@ -112,8 +112,8 @@ void testInsertFailover_ShouldFireRules(PersistedSessionOption.PersistenceStrate @ParameterizedTest @MethodSource("strategyProviderStoresOnlyWithExplicitSafepoints") // does not support PersistedSessionOption.PersistenceObjectsStrategy.SIMPLE - void testPhase1FailoverPhase2Phase3_ShouldFireRules(PersistedSessionOption.PersistenceStrategy persistenceStrategy, PersistedSessionOption.SafepointStrategy safepointStrategy){ - createSession(FIRE_AND_ALARM, persistenceStrategy, safepointStrategy,PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); + void testPhase1FailoverPhase2Phase3_ShouldFireRules(PersistedSessionOption.PersistenceStrategy persistenceStrategy, PersistedSessionOption.SafepointStrategy safepointStrategy) { + createSession(FIRE_AND_ALARM, persistenceStrategy, safepointStrategy, PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); // phase 1 Room room1 = new Room("Room 1"); @@ -127,9 +127,94 @@ void testPhase1FailoverPhase2Phase3_ShouldFireRules(PersistedSessionOption.Persi assertThat(alarm.isEmpty()).isFalse(); failover(); - restoreSession(FIRE_AND_ALARM, persistenceStrategy,safepointStrategy,PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); + restoreSession(FIRE_AND_ALARM, persistenceStrategy, safepointStrategy, PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); + clearResults(); + + // phase 2 + Optional room = getObjectByType(Room.class); + assertThat(room.isEmpty()).isFalse(); + Sprinkler sprinkler1 = new Sprinkler((Room) room.get()); + insert(sprinkler1); + + assertThat(fireAllRules()).isEqualTo(1); + assertThat(getResults()).containsExactlyInAnyOrder("Turn on sprinkler rule"); + clearResults(); + + Optional sprinkler = getObjectByType(Sprinkler.class); + assertThat(sprinkler.isEmpty()).isFalse(); + assertThat(((Sprinkler) sprinkler.get()).isOn()).isTrue(); + + // phase 3 + Optional fireFh = getFactHandleByType(Fire.class); + assertThat(fireFh.isEmpty()).isFalse(); + delete(fireFh.get()); + assertThat(fireAllRules()).isEqualTo(1); + assertThat(getResults()).containsExactlyInAnyOrder("Cancel alarm rule"); + } + + @ParameterizedTest + @MethodSource("strategyProviderStoresOnlyWithExplicitSafepoints") // does not support PersistedSessionOption.PersistenceObjectsStrategy.SIMPLE + void testPhase1FailoverPhase2FailoverPhase3_ShouldFireRules(PersistedSessionOption.PersistenceStrategy persistenceStrategy, PersistedSessionOption.SafepointStrategy safepointStrategy) { + createSession(FIRE_AND_ALARM, persistenceStrategy, safepointStrategy, PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); + + // phase 1 + Room room1 = new Room("Room 1"); + insert(room1); + insert(new Fire(room1)); + + assertThat(fireAllRules()).isEqualTo(1); + assertThat(getResults()).containsExactlyInAnyOrder("Raise alarm rule"); + + Optional alarm = getObjectByType(Alarm.class); + assertThat(alarm.isEmpty()).isFalse(); + + failover(); + restoreSession(FIRE_AND_ALARM, persistenceStrategy, safepointStrategy, PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); + clearResults(); + + // phase 2 + Optional room = getObjectByType(Room.class); + assertThat(room.isEmpty()).isFalse(); + Sprinkler sprinkler1 = new Sprinkler((Room) room.get()); + insert(sprinkler1); + + assertThat(fireAllRules()).isEqualTo(1); + assertThat(getResults()).containsExactlyInAnyOrder("Turn on sprinkler rule"); + clearResults(); + + Optional sprinkler = getObjectByType(Sprinkler.class); + assertThat(sprinkler.isEmpty()).isFalse(); + assertThat(((Sprinkler) sprinkler.get()).isOn()).isTrue(); + + failover(); + restoreSession(FIRE_AND_ALARM, persistenceStrategy, safepointStrategy, PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); + clearResults(); + + // phase 3 + Optional fireFh = getFactHandleByType(Fire.class); + assertThat(fireFh.isEmpty()).isFalse(); + delete(fireFh.get()); + assertThat(fireAllRules()).isEqualTo(1); + assertThat(getResults()).containsExactlyInAnyOrder("Cancel alarm rule"); + } + + @ParameterizedTest + @MethodSource("strategyProviderStoresOnlyWithExplicitSafepoints") // does not support PersistedSessionOption.PersistenceObjectsStrategy.SIMPLE + void testPhase1Phase2FailoverPhase3_ShouldFireRules(PersistedSessionOption.PersistenceStrategy persistenceStrategy, PersistedSessionOption.SafepointStrategy safepointStrategy) { + createSession(FIRE_AND_ALARM, persistenceStrategy, safepointStrategy, PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); + + // phase 1 + Room room1 = new Room("Room 1"); + insert(room1); + insert(new Fire(room1)); + + assertThat(fireAllRules()).isEqualTo(1); + assertThat(getResults()).containsExactlyInAnyOrder("Raise alarm rule"); clearResults(); + Optional alarm = getObjectByType(Alarm.class); + assertThat(alarm.isEmpty()).isFalse(); + // phase 2 Optional room = getObjectByType(Room.class); assertThat(room.isEmpty()).isFalse(); @@ -144,6 +229,10 @@ void testPhase1FailoverPhase2Phase3_ShouldFireRules(PersistedSessionOption.Persi assertThat(sprinkler.isEmpty()).isFalse(); assertThat(((Sprinkler) sprinkler.get()).isOn()).isTrue(); + failover(); + restoreSession(FIRE_AND_ALARM, persistenceStrategy, safepointStrategy, PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); + clearResults(); + // phase 3 Optional fireFh = getFactHandleByType(Fire.class); assertThat(fireFh.isEmpty()).isFalse(); @@ -151,4 +240,35 @@ void testPhase1FailoverPhase2Phase3_ShouldFireRules(PersistedSessionOption.Persi assertThat(fireAllRules()).isEqualTo(1); assertThat(getResults()).containsExactlyInAnyOrder("Cancel alarm rule"); } + + @ParameterizedTest + @MethodSource("strategyProviderStoresOnlyWithExplicitSafepoints") // does not support PersistedSessionOption.PersistenceObjectsStrategy.SIMPLE + void testInsertFailoverUpdate_shouldFireRules(PersistedSessionOption.PersistenceStrategy persistenceStrategy, PersistedSessionOption.SafepointStrategy safepointStrategy) { + createSession(FIRE_AND_ALARM, persistenceStrategy, safepointStrategy, PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); + + Room room1 = new Room("Room 1"); + insert(room1); + Sprinkler sprinkler1 = new Sprinkler(room1); + insert(sprinkler1); + insert(new Fire(room1)); + + assertThat(fireAllRules()).isEqualTo(2); + assertThat(getResults()).containsExactlyInAnyOrder("Turn on sprinkler rule", "Raise alarm rule"); + + failover(); + restoreSession(FIRE_AND_ALARM, persistenceStrategy, safepointStrategy, PersistedSessionOption.PersistenceObjectsStrategy.OBJECT_REFERENCES); + clearResults(); + + Optional fireFh = this.getFactHandleByType(Fire.class); + delete(fireFh.get()); + + Optional sprinklerFh = this.getFactHandleByType(Sprinkler.class); + Sprinkler sprinkler2 = ((Sprinkler) sprinklerFh.get().getObject()); + sprinkler2.setOn(false); + update(sprinklerFh.get(), sprinkler2); + + assertThat(fireAllRules()).isEqualTo(2); + assertThat(getResults()).containsExactlyInAnyOrder("Everything ok rule", "Cancel alarm rule"); + + } }