/** * Internal method to transform classes implementing a rule into {@link RuleDefinition}s. * * @param ruleClasses * The classes to be transformed. * @return Set of {@link RuleDefinition}s. * @throws RuleDefinitionException * If any {@link RuleDefinition} is invalid. */ private Set<RuleDefinition> prepareRuleDefinitions(Set<Class<?>> ruleClasses) throws RuleDefinitionException { return Rules.define(ruleClasses); } }
@Test(expectedExceptions = RuleDefinitionException.class) public void testMissingTagValueMethod() throws RuleDefinitionException { Rules.define(NoTagValueDefined.class); } }
@Test public void onlyRuleBMatch() throws RuleDefinitionException { RuleDefinition ruleA = Rules.define(RuleA.class); RuleDefinition ruleB = Rules.define(RuleB.class); RuleDefinition ruleC = Rules.define(RuleC.class); Set<RuleDefinition> ruleDefinitions = new HashSet<>(Arrays.asList(ruleA, ruleB, ruleC)); Set<String> availableTagTypes = new HashSet<>(Arrays.asList(new String[] { "A" })); Collection<RuleDefinition> nextRules = session.findNextRules(availableTagTypes, ruleDefinitions); assertThat(nextRules, containsInAnyOrder(ruleB)); }
@Test public void noneMatch() throws RuleDefinitionException { RuleDefinition ruleA = Rules.define(RuleA.class); RuleDefinition ruleB = Rules.define(RuleB.class); RuleDefinition ruleC = Rules.define(RuleC.class); Set<RuleDefinition> ruleDefinitions = new HashSet<>(Arrays.asList(ruleA, ruleB, ruleC)); Set<String> availableTagTypes = new HashSet<>(Arrays.asList(new String[] { "B" })); Collection<RuleDefinition> nextRules = session.findNextRules(availableTagTypes, ruleDefinitions); assertThat(nextRules, empty()); }
@Test public void onlyRuleBAndCMatch() throws RuleDefinitionException { RuleDefinition ruleA = Rules.define(RuleA.class); RuleDefinition ruleB = Rules.define(RuleB.class); RuleDefinition ruleC = Rules.define(RuleC.class); Set<RuleDefinition> ruleDefinitions = new HashSet<>(Arrays.asList(ruleA, ruleB, ruleC)); Set<String> availableTagTypes = new HashSet<>(Arrays.asList(new String[] { "A", "B" })); Collection<RuleDefinition> nextRules = session.findNextRules(availableTagTypes, ruleDefinitions); assertThat(nextRules, containsInAnyOrder(ruleB, ruleC)); }
@Test public void allRulesMatch() throws RuleDefinitionException { Set<RuleDefinition> ruleDefinitions = Rules.define(RuleA.class, RuleB.class, RuleC.class); Set<String> availableTagTypes = new HashSet<>(Arrays.asList(Tags.ROOT_TAG, "A", "B")); Collection<RuleDefinition> nextRules = session.findNextRules(availableTagTypes, ruleDefinitions); assertThat(nextRules, containsInAnyOrder(ruleDefinitions.toArray(new RuleDefinition[0]))); }
@BeforeMethod public void init() throws RuleDefinitionException { rules = Rules.define(RuleA.class, RuleB.class, RuleC.class); sessionContext = new SessionContext<>(rules, storage); }
@Test public void noMatch1() throws RuleDefinitionException, SessionException { RuleDefinition ruleC = Rules.define(RuleC.class); when(outputStorage.findLatestResultsByTagType(Matchers.<Set<String>> anyObject())).thenReturn(Collections.singleton(Rules.triggerRuleOutput("input"))); Collection<RuleInput> ruleInputs = session.collectInputs(ruleC, outputStorage); assertThat(ruleInputs, empty()); }
@Test public void singleTagTypeSingleInput() throws RuleDefinitionException, SessionException { RuleDefinition ruleB = Rules.define(RuleB.class); Tag rootTag = Tags.rootTag("input"); Tag tagA = Tags.tag("A", "input", rootTag); RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptyList(), Collections.singletonList(tagA)); when(outputStorage.findLatestResultsByTagType(Matchers.<Set<String>> anyObject())).thenReturn(Collections.singleton(outputA)); List<RuleInput> ruleInputs = new ArrayList<>(session.collectInputs(ruleB, outputStorage)); assertThat(ruleInputs, hasSize(1)); assertThat(ruleInputs.get(0).getRoot(), equalTo(tagA)); }
@Test public void multipleTagTypesSingleInput() throws RuleDefinitionException, SessionException { RuleDefinition ruleC = Rules.define(RuleC.class); Tag rootTag = Tags.rootTag("input"); Tag tagA = Tags.tag("A", "A1", rootTag); Tag tagB = Tags.tag("B", "B1", tagA); RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptyList(), Collections.singletonList(tagB)); when(outputStorage.findLatestResultsByTagType(Matchers.<Set<String>> anyObject())).thenReturn(Collections.singleton(outputB)); List<RuleInput> ruleInputs = new ArrayList<>(session.collectInputs(ruleC, outputStorage)); assertThat(ruleInputs, hasSize(1)); assertThat(ruleInputs.get(0).getRoot(), equalTo(tagB)); assertThat(ruleInputs.get(0).getUnraveled(), containsInAnyOrder(tagB, tagA)); }
@Test public void ruleWithConditionFailure() throws Exception { session = new Session<>(Rules.define(RuleA.class, RuleG.class), new DefaultSessionResultCollector<String>()); String input = "input"; session.activate(input, Session.EMPTY_SESSION_VARIABLES); DefaultSessionResult<String> result = session.call(); assertThat(session.getState(), equalTo(State.PROCESSED)); assertThat(result.getConditionFailures().keySet(), containsInAnyOrder("RuleG")); assertThat(result.getEndTags().keySet(), hasSize(1)); assertThat(result.getEndTags().keySet(), containsInAnyOrder("A")); }
@Test public void ruleWithConditionFailureExecution() throws RuleDefinitionException, RuleExecutionException { RuleDefinition ruleDefinition = Rules.define(RuleG.class); String inputStr = "hallo"; RuleInput input = new RuleInput(Tags.tag("A", inputStr)); RuleOutput output = ruleDefinition.execute(input, Collections.<String, Object> emptyMap()); assertThat(output.getRuleName(), equalTo(ruleDefinition.getName())); assertThat(output.getConditionFailures(), hasSize(1)); assertThat(output.getTags(), empty()); } }
@Test public void fromActivated() throws Exception { session = new Session<>(Rules.define(RuleA.class, RuleB.class, RuleC.class), new DefaultSessionResultCollector<String>()); String input = "input"; session.activate(input, Session.EMPTY_SESSION_VARIABLES); DefaultSessionResult<String> result = session.call(); assertThat(session.getState(), equalTo(State.PROCESSED)); assertThat(result.getConditionFailures().keys(), empty()); assertThat(result.getEndTags().keySet(), containsInAnyOrder("C")); assertThat(result.getEndTags().get("C"), hasSize(1)); assertThat(((Integer) result.getEndTags().get("C").iterator().next().getValue()), equalTo((input.length() * 2) + 2)); }
@Test public void simpleRuleExecution() throws RuleDefinitionException, RuleExecutionException { RuleDefinition ruleDefinition = Rules.define(RuleA.class); String inputStr = "hallo"; RuleInput input = new RuleInput(Tags.tag(Tags.ROOT_TAG, inputStr)); RuleOutput output = ruleDefinition.execute(input, Collections.<String, Object> emptyMap()); assertThat(output.getRuleName(), equalTo(ruleDefinition.getName())); assertThat(output.getTags(), hasSize(1)); assertThat(output.getTags().iterator().next().getValue(), equalTo((Object) (inputStr + inputStr))); }
@Test public void ruleWithSessionVariableExecution() throws RuleDefinitionException, RuleExecutionException { RuleDefinition ruleDefinition = Rules.define(RuleWithSessionVariable.class); String inputStr = "hallo"; String sessionVar = "sessionVar"; RuleInput input = new RuleInput(Tags.tag(Tags.ROOT_TAG, inputStr)); RuleOutput output = ruleDefinition.execute(input, Collections.singletonMap(sessionVar, (Object) sessionVar)); assertThat(output.getRuleName(), equalTo(ruleDefinition.getName())); assertThat(output.getTags(), hasSize(1)); assertThat(output.getTags().iterator().next().getValue(), equalTo((Object) (inputStr + sessionVar))); }
@Test public void noMatch2() throws RuleDefinitionException, SessionException { RuleDefinition ruleC = Rules.define(RuleC.class); Tag rootTag = Tags.rootTag("input"); Tag tagA1 = Tags.tag("A", "A1", rootTag); Tag tagB1 = Tags.tag("B", "B1", rootTag); RuleOutput outputB1 = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptyList(), Arrays.asList(tagB1)); when(outputStorage.findLatestResultsByTagType(Matchers.<Set<String>> anyObject())).thenReturn(Arrays.asList(outputB1)); Collection<RuleInput> ruleInputs = session.collectInputs(ruleC, outputStorage); assertThat(ruleInputs, empty()); } }
@Test public void twoOfThreeRulesApply() throws Exception { session = new Session<>(Rules.define(RuleA.class, RuleE.class, RuleF.class), new DefaultSessionResultCollector<String>()); String input = "input"; session.activate(input, Session.EMPTY_SESSION_VARIABLES); DefaultSessionResult<String> result = session.call(); assertThat(session.getState(), equalTo(State.PROCESSED)); assertThat(result.getConditionFailures().keys(), empty()); assertThat(result.getEndTags().keySet(), hasSize(2)); assertThat(result.getEndTags().keySet(), containsInAnyOrder("A", "E")); }
@Test public void multipleTagTypesMultipleInputs1() throws RuleDefinitionException, SessionException { RuleDefinition ruleC = Rules.define(RuleC.class); Tag rootTag = Tags.rootTag("input"); Tag tagA = Tags.tag("A", "A1", rootTag); Tag tagB1 = Tags.tag("B", "B1", tagA); Tag tagB2 = Tags.tag("B", "B2", tagA); RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptyList(), Arrays.asList(tagB1, tagB2)); when(outputStorage.findLatestResultsByTagType(Matchers.<Set<String>> anyObject())).thenReturn(Collections.singleton(outputB)); Collection<RuleInput> ruleInputs = session.collectInputs(ruleC, outputStorage); assertThat(ruleInputs, hasSize(2)); assertThat(ruleInputs, containsInAnyOrder(new RuleInput(tagB1, Sets.newHashSet(tagA, tagB1)), new RuleInput(tagB2, Sets.newHashSet(tagA, tagB2)))); }
@Test(expectedExceptions = { SessionException.class }) public void fromNonActivatedState() throws Exception { session = new Session<>(Rules.define(RuleA.class, RuleB.class, RuleC.class), new DefaultSessionResultCollector<String>()); session.call(); }
@Test(expectedExceptions = { SessionException.class }) public void withRuleException() throws Exception { session = new Session<>(Rules.define(RuleA.class, RuleD.class), new DefaultSessionResultCollector<String>()); String input = "input"; session.activate(input, Session.EMPTY_SESSION_VARIABLES); session.call(); } }