/** * 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); } }
ActionMethod actionMethod = describeActionMethod(clazz); List<ConditionMethod> conditionMethods = describeConditionMethods(clazz); List<TagInjection> tagInjections = describeTagInjection(clazz); List<SessionVariableInjection> variableInjections = describeSessionParameterInjections(clazz); FireCondition fireCondition = describeFireCondition(annotation, tagInjections);
@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!"))); }
/** * 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; }
@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); }
@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 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 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)); }