/** * 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 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()); }
/** * Executes the Session. Invocation is exclusively possible if {@link Session} is in ACTIVATED * state, any other state forces a {@link SessionException}. Processing is enabled inserting a * initial RuleOutput to the {@link IRuleOutputStorage} which will act as input to further * rules. If processing completes without errors the {@link Session} enters PROCESSED state. In * any case of error it enters FAILURE state. * * @throws Exception * If Session lifecycle is in an invalid state. * @return The diagnosis result. */ @Override public R call() throws Exception { // Processes and collect results. // If a Session is used as Callable this call might horribly fail if sessions are not // retrieved from SessionPool and a sessions lifeCycle is neglected. But we have not chance // to activate a // session internally due to missing input information. So simply fail switch (state) { case ACTIVATED: sessionContext.getStorage().store(Rules.triggerRuleOutput(sessionContext.getInput())); doProcess(); state = State.PROCESSED; break; default: throw new SessionException("Session can not enter process stated from: " + state + " state. Ensure that Session is in ACTIVATED state before processing."); } return resultCollector.collect(sessionContext); }
/** * Methods transforms all given classes to {@link RuleDefinition}s. * <p> * Throws: RuleDefinitionException if a class transformation fails. * * @param classes * The classes to be transformed. * @return Set of {@link RuleDefinition}s. * @throws RuleDefinitionException * If any {@link RuleDefinition} is invalid. */ public static Set<RuleDefinition> define(Class<?>... classes) throws RuleDefinitionException { return define(Arrays.asList(checkNotNull(classes, "Rule classes array must not be null!"))); }
@Test(expectedExceptions = RuleDefinitionException.class) public void testMissingTagValueMethod() throws RuleDefinitionException { Rules.define(NoTagValueDefined.class); } }
@Test(expectedExceptions = RuleDefinitionException.class) public void testWithoutRuleAnnotation() throws RuleDefinitionException { Rules.define(MissingAnnotation.class); }
@Test(expectedExceptions = RuleDefinitionException.class) public void testMissingActionMethod() throws RuleDefinitionException { Rules.define(NoActionMethodDefined.class); }
@Test(expectedExceptions = RuleDefinitionException.class) public void testMultipleActionMethods() throws RuleDefinitionException { Rules.define(MultipleActionMethodsDefined.class); }
@Test(expectedExceptions = RuleDefinitionException.class) public void testInvalidActionMethodReturnType() throws RuleDefinitionException { Rules.define(InvalidActionMethodReturnType.class); }
/** * Methods transforms all given classes to {@link RuleDefinition}s. * * Throws: RuleDefinitionException if a class transformation fails. * * @param classes * The classes to be transformed. * @return Set of {@link RuleDefinition}s. * @throws RuleDefinitionException * If any {@link RuleDefinition} is invalid. * */ public static Set<RuleDefinition> define(Collection<Class<?>> classes) throws RuleDefinitionException { checkArgument(CollectionUtils.isNotEmpty(classes), "Rule classes must not be null or empty!"); Set<RuleDefinition> ruleSet = Sets.newHashSet(); for (Class<?> clazz : classes) { ruleSet.add(define(clazz)); } return ruleSet; }
@BeforeMethod public void init() throws RuleDefinitionException { rules = Rules.define(RuleA.class, RuleB.class, RuleC.class); sessionContext = new SessionContext<>(rules, storage); }
@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]))); }
@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 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(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(); } }
@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 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()); } }