github-forks
/
easy-rules
mirror of https://github.com/j-easy/easy-rules.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

issue : add ConditionalRuleGroup implementation

Browse Source
pull/144/head
Mahmoud Ben Hassine
parent 79e68108be
commit 7bb0962e34
2 changed files with 469 additions and 0 deletions

142
easy-rules-support/src/main/java/org/jeasy/rules/support/ConditionalRuleGroup.java
Unescape Escape View File

@ -0,0 +1,142 @@
/**
* The MIT License
*
* Copyright (c) 2017, Mahmoud Ben Hassine (mahmoud.benhassine@icloud.com)
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.jeasy.rules.support;
import org.jeasy.rules.api.Facts;
import org.jeasy.rules.api.Rule;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* A conditional rule group is a composite rule where the rule with the highest priority acts as a condition:
* if the rule with the highest priority evaluates to true, then we try to evaluate the rest of the rules
* and execute the ones that evaluate to true.
*
* @author Dag Framstad (dagframstad@gmail.com)
*/
public class ConditionalRuleGroup extends CompositeRule {
private Set<Rule> successfulEvaluations;
private Rule conditionalRule;
/**
* Create a conditional rule group.
*/
public ConditionalRuleGroup() {
}
/**
* Create a conditional rule group.
*
* @param name of the conditional rule
*/
public ConditionalRuleGroup(String name) {
super(name);
}
/**
* Create a conditional rule group.
*
* @param name of the conditional rule
* @param description of the conditional rule
*/
public ConditionalRuleGroup(String name, String description) {
super(name, description);
}
/**
* Create a conditional rule group.
*
* @param name of the conditional rule
* @param description of the conditional rule
* @param priority of the composite rule
*/
public ConditionalRuleGroup(String name, String description, int priority) {
super(name, description, priority);
}
/**
* A path rule will trigger all it's rules if the path rule's condition is true.
* @param facts The facts.
* @return true if the path rules condition is true.
*/
@Override
public boolean evaluate(Facts facts) {
successfulEvaluations = new HashSet<>();
conditionalRule = getRuleWithHighestPriority();
if (conditionalRule.evaluate(facts)) {
for (Rule rule : rules) {
if (rule != conditionalRule && rule.evaluate(facts)) {
successfulEvaluations.add(rule);
}
}
return true;
}
return false;
}
/**
* When a conditional rule group is applied, all rules that evaluated to true are performed
* in their natural order, but with the conditional rule (the one with the highest priority) first.
*
* @param facts The facts.
*
* @throws Exception thrown if an exception occurs during actions performing
*/
@Override
public void execute(Facts facts) throws Exception {
conditionalRule.execute(facts);
for (Rule rule : successfulEvaluations) {
rule.execute(facts);
}
}
private Rule getRuleWithHighestPriority() {
List<Rule> copy = sortRules();
// make sure that we only have one rule with the highest priority
Rule highest = copy.get(0);
if (copy.size() > 1 && copy.get(1).getPriority() == highest.getPriority()) {
throw new IllegalArgumentException("Only one rule can have highest priority");
}
return highest;
}
private List<Rule> sortRules() {
List<Rule> copy = new ArrayList<>(rules);
Collections.sort(copy, new Comparator<Rule>() {
@Override
public int compare(Rule o1, Rule o2) {
Integer i2 = o2.getPriority();
return i2.compareTo(o1.getPriority());
}
});
return copy;
}
}

327
easy-rules-support/src/test/java/org/jeasy/rules/support/ConditionalRuleGroupTest.java
Unescape Escape View File

@ -0,0 +1,327 @@
/**
* The MIT License
*
* Copyright (c) 2017, Mahmoud Ben Hassine (mahmoud.benhassine@icloud.com)
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.jeasy.rules.support;
import org.jeasy.rules.annotation.Action;
import org.jeasy.rules.annotation.Condition;
import org.jeasy.rules.annotation.Priority;
import org.jeasy.rules.api.Facts;
import org.jeasy.rules.api.Rule;
import org.jeasy.rules.api.Rules;
import org.jeasy.rules.core.DefaultRulesEngine;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class ConditionalRuleGroupTest {
@Mock
private Rule rule1, rule2, conditionalRule;
private Facts facts = new Facts();
private Rules rules = new Rules();
private DefaultRulesEngine rulesEngine = new DefaultRulesEngine();
private ConditionalRuleGroup conditionalRuleGroup;
@Before
public void setUp() {
when(rule1.evaluate(facts)).thenReturn(false);
when(rule1.getPriority()).thenReturn(2);
when(rule2.evaluate(facts)).thenReturn(true);
when(rule2.getPriority()).thenReturn(3);
when(rule2.compareTo(rule1)).thenReturn(1);
when(conditionalRule.compareTo(rule1)).thenReturn(1);
when(conditionalRule.compareTo(rule2)).thenReturn(1);
when(conditionalRule.getPriority()).thenReturn(100);
conditionalRuleGroup = new ConditionalRuleGroup();
}
@Test
public void rulesMustNotBeExecutedIfConditionalRuleEvaluatesToFalse() throws Exception {
// Given
when(conditionalRule.evaluate(facts)).thenReturn(false);
conditionalRuleGroup.addRule(rule1);
conditionalRuleGroup.addRule(rule2);
conditionalRuleGroup.addRule(conditionalRule);
rules.register(conditionalRuleGroup);
// When
rulesEngine.fire(rules, facts);
// Then
/*
* The composing rules should not be executed
* since the conditional rule evaluate to FALSE
*/
// primaryRule should not be executed
verify(conditionalRule, never()).execute(facts);
//Rule 1 should not be executed
verify(rule1, never()).execute(facts);
//Rule 2 should not be executed
verify(rule2, never()).execute(facts);
}
@Test
public void rulesMustBeExecutedForThoseThatEvaluateToTrueIfConditionalRuleEvaluatesToTrue() throws Exception {
// Given
when(conditionalRule.evaluate(facts)).thenReturn(true);
conditionalRuleGroup.addRule(rule1);
conditionalRuleGroup.addRule(rule2);
conditionalRuleGroup.addRule(conditionalRule);
rules.register(conditionalRuleGroup);
// When
rulesEngine.fire(rules, facts);
// Then
/*
* Some of he composing rules should be executed
* since the conditional rule evaluate to TRUE
*/
// primaryRule should be executed
verify(conditionalRule, times(1)).execute(facts);
//Rule 1 should not be executed
verify(rule1, never()).execute(facts);
//Rule 2 should be executed
verify(rule2, times(1)).execute(facts);
}
@Test
public void whenARuleIsRemoved_thenItShouldNotBeEvaluated() throws Exception {
// Given
when(conditionalRule.evaluate(facts)).thenReturn(true);
conditionalRuleGroup.addRule(rule1);
conditionalRuleGroup.addRule(rule2);
conditionalRuleGroup.addRule(conditionalRule);
conditionalRuleGroup.removeRule(rule2);
rules.register(conditionalRuleGroup);
// When
rulesEngine.fire(rules, facts);
// Then
// primaryRule should be executed
verify(conditionalRule, times(1)).execute(facts);
//Rule 1 should not be executed
verify(rule1, times(1)).evaluate(facts);
verify(rule1, never()).execute(facts);
// Rule 2 should not be evaluated nor executed
verify(rule2, never()).evaluate(facts);
verify(rule2, never()).execute(facts);
}
@Test
public void testCompositeRuleWithAnnotatedComposingRules() throws Exception {
// Given
when(conditionalRule.evaluate(facts)).thenReturn(true);
MyRule rule = new MyRule();
conditionalRuleGroup = new ConditionalRuleGroup("myConditinalRule");
conditionalRuleGroup.addRule(rule);
when(conditionalRule.compareTo(any(Rule.class))).thenReturn(1);
conditionalRuleGroup.addRule(conditionalRule);
rules.register(conditionalRuleGroup);
// When
rulesEngine.fire(rules, facts);
// Then
verify(conditionalRule, times(1)).execute(facts);
assertThat(rule.isExecuted()).isTrue();
}
@Test
public void whenAnnotatedRuleIsRemoved_thenItsProxyShouldBeRetrieved() throws Exception {
// Given
when(conditionalRule.evaluate(facts)).thenReturn(true);
MyRule rule = new MyRule();
MyAnnotatedRule annotatedRule = new MyAnnotatedRule();
conditionalRuleGroup = new ConditionalRuleGroup("myCompositeRule", "composite rule with mixed types of rules");
conditionalRuleGroup.addRule(rule);
conditionalRuleGroup.addRule(annotatedRule);
conditionalRuleGroup.removeRule(annotatedRule);
when(conditionalRule.compareTo(any(Rule.class))).thenReturn(1);
conditionalRuleGroup.addRule(conditionalRule);
rules.register(conditionalRuleGroup);
// When
rulesEngine.fire(rules, facts);
// Then
verify(conditionalRule, times(1)).execute(facts);
assertThat(rule.isExecuted()).isTrue();
assertThat(annotatedRule.isExecuted()).isFalse();
}
@Test(expected = IllegalArgumentException.class)
public void twoRulesWithSameHighestPriorityIsNotAllowed() {
conditionalRuleGroup.addRule(new MyOtherRule(1));
conditionalRuleGroup.addRule(new MyOtherRule(2));
conditionalRuleGroup.addRule(new MyRule());
rules.register(conditionalRuleGroup);
rulesEngine.fire(rules, facts);
}
@Test
public void twoRulesWithSamePriorityIsAllowedIfAnotherRuleHasHigherPriority() {
MyOtherRule rule1 = new MyOtherRule(3);
conditionalRuleGroup.addRule(rule1);
conditionalRuleGroup.addRule(new MyOtherRule(2));
conditionalRuleGroup.addRule(new MyRule());
rules.register(conditionalRuleGroup);
rulesEngine.fire(rules, facts);
assertThat(rule1.isExecuted()).isTrue();
}
@SuppressWarnings("unchecked")
@Test
public void aRuleWithoutPriorityHasAHighPriororty() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
MyOtherRule rule1 = new MyOtherRule(3);
conditionalRuleGroup.addRule(rule1);
conditionalRuleGroup.addRule(new UnprioritizedRule());
Method m = conditionalRuleGroup.getClass().getDeclaredMethod("sortRules");
m.setAccessible(true);
List<Rule> sorted = (List<Rule>)m.invoke(conditionalRuleGroup);
assertThat(sorted.get(0).getPriority()).isEqualTo(Integer.MAX_VALUE - 1);
assertThat(sorted.get(1).getPriority()).isEqualTo(3);
}
@org.jeasy.rules.annotation.Rule
public class MyRule {
boolean executed;
@Condition
public boolean when() {
return true;
}
@Action
public void then() {
executed = true;
}
@Priority
public int priority() {
return 2;
}
public boolean isExecuted() {
return executed;
}
}
@org.jeasy.rules.annotation.Rule
public static class MyAnnotatedRule {
private boolean executed;
@Condition
public boolean evaluate() {
return true;
}
@Action
public void execute() {
executed = true;
}
@Priority
public int priority() {
return 3;
}
public boolean isExecuted() {
return executed;
}
}
@org.jeasy.rules.annotation.Rule
public class MyOtherRule {
boolean executed;
private int priority;
public MyOtherRule(int priority) {
this.priority = priority;
}
@Condition
public boolean when() {
return true;
}
@Action
public void then() {
executed = true;
}
@Priority
public int priority() {
return priority;
}
public boolean isExecuted() {
return executed;
}
}
@org.jeasy.rules.annotation.Rule
public class UnprioritizedRule {
boolean executed;
@Condition
public boolean when() {
return false;
}
@Action
public void then() {
executed = true;
}
public boolean isExecuted() {
return executed;
}
}
}
Write Preview
Loading…
Cancel
Save