/** * {@inheritDoc} */ @Override public void store(Collection<RuleOutput> output) { for (RuleOutput single : output) { store(single); } }
/** * Constructor. * * @param ruleDefinitions * Set of {@link RuleDefinition} instances. * @param sessionResultCollector * The {@link ISessionResultCollector} for the results of the session. */ public Session(Set<RuleDefinition> ruleDefinitions, ISessionResultCollector<I, R> sessionResultCollector) { this(ruleDefinitions, sessionResultCollector, new DefaultRuleOutputStorage()); }
/** * Passivates the <code>SessionContext</code> by clearing th {@link #ruleSet}, the * {@link #sessionVariables}, the {@link #storage}, and the {@link #input}. * * @return The SessionContext itself. * @see Session * @see Session#passivate() */ SessionContext<I> passivate() { this.input = null; // NOPMD this.ruleSet.clear(); this.storage.clear(); this.executions.clear(); this.sessionVariables.clear(); // NOPMD return this; }
@Test public void storeWithConditionFailures() { ConditionFailure failure = new ConditionFailure("ConditionX", "SomeHint"); RuleOutput output = new RuleOutput("RuleA", "A", Collections.singleton(failure), Collections.<Tag> emptySet()); storage.store(output); assertThat(storage.getAvailableTagTypes(), empty()); assertThat(storage.getAllOutputs().keySet(), empty()); assertThat(storage.getAllOutputsWithConditionFailures().keySet(), hasSize(1)); assertThat(storage.getAllOutputsWithConditionFailures().get("A"), containsInAnyOrder(output)); }
@Test public void mapSimpleLeafs() { Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root"); Tag tagA = Tags.tag("A", "inputA", rootTag); Tag tagB = Tags.tag("B", "inputB", rootTag); Tag tagC = Tags.tag("C", "inputC", tagB); Tag tagD = Tags.tag("D", "inputD", tagA); RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagA)); RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagB)); RuleOutput outputC = new RuleOutput("RuleC", "C", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagC)); RuleOutput outputD = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD)); storage.store(Arrays.asList(outputA, outputB, outputC, outputD)); Multimap<String, Tag> tags = storage.mapTags(TagState.LEAF); assertThat(tags.size(), equalTo(2)); assertThat(tags.keySet(), hasSize(2)); assertThat(tags.get("A"), empty()); assertThat(tags.get("B"), empty()); assertThat(tags.get("C"), containsInAnyOrder(tagC)); assertThat(tags.get("D"), containsInAnyOrder(tagD)); }
@Test public void findWithSingleTagType() { Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root"); Tag tagA = Tags.tag("A", "inputA", rootTag); Tag tagB = Tags.tag("B", "inputB", rootTag); Tag tagC1 = Tags.tag("C", "inputC1", tagB); Tag tagC2 = Tags.tag("C", "inputC2", tagB); Tag tagD1 = Tags.tag("D", "inputD1", tagA); Tag tagD2 = Tags.tag("D", "inputD2", tagA); RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagA)); RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagB)); RuleOutput outputC = new RuleOutput("RuleC", "C", Collections.<ConditionFailure> emptySet(), Arrays.asList(tagC1, tagC2)); RuleOutput outputD1 = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD1)); RuleOutput outputD2 = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD2)); storage.store(Arrays.asList(outputA, outputB, outputC, outputD1, outputD2)); Collection<RuleOutput> outputs = storage.findLatestResultsByTagType(new HashSet<>(Arrays.asList("D"))); assertThat(outputs, hasSize(2)); assertThat(outputs, containsInAnyOrder(outputD1, outputD2)); }
@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()); }
@Override public DefaultSessionResult<I> collect(SessionContext<I> context) { Multimap<String, ConditionFailure> conditionFailures = ArrayListMultimap.create(); //unpack condition errors for (RuleOutput output : context.getStorage().getAllOutputsWithConditionFailures().values()) { conditionFailures.putAll(output.getRuleName(), output.getConditionFailures()); } return new DefaultSessionResult<>(context.getInput(), conditionFailures, context.getStorage().mapTags(TagState.LEAF)); }
Collection<RuleDefinition> nextRules = findNextRules(sessionContext.getStorage().getAvailableTagTypes(), sessionContext.getRuleSet()); sessionContext.getStorage().store(outputs); anyRuleExecuted = true; nextRules = findNextRules(sessionContext.getStorage().getAvailableTagTypes(), sessionContext.getRuleSet()); } else { break;
/** * 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); }
@Test public void storeWithoutConditionFailures() { Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root"); Tag tagA = Tags.tag("A", "inputA", rootTag); RuleOutput output = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagA)); storage.store(output); assertThat(storage.getAvailableTagTypes(), containsInAnyOrder("A")); assertThat(storage.getAllOutputs().keySet(), hasSize(1)); assertThat(storage.getAllOutputs().keySet(), containsInAnyOrder("A")); assertThat(storage.getAllOutputs().get("A"), containsInAnyOrder(output)); assertThat(storage.getAllOutputsWithConditionFailures().keySet(), hasSize(0)); }
@Test public void mapMultiTagLeafs() { Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root"); Tag tagA = Tags.tag("A", "inputA", rootTag); Tag tagB = Tags.tag("B", "inputB", rootTag); Tag tagC1 = Tags.tag("C", "inputC1", tagB); Tag tagC2 = Tags.tag("C", "inputC2", tagB); Tag tagD1 = Tags.tag("D", "inputD1", tagA); Tag tagD2 = Tags.tag("D", "inputD2", tagA); RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagA)); RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagB)); RuleOutput outputC = new RuleOutput("RuleC", "C", Collections.<ConditionFailure> emptySet(), Arrays.asList(tagC1, tagC2)); RuleOutput outputD1 = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD1)); RuleOutput outputD2 = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD2)); storage.store(Arrays.asList(outputA, outputB, outputC, outputD1, outputD2)); Multimap<String, Tag> tags = storage.mapTags(TagState.LEAF); assertThat(tags.size(), equalTo(4)); assertThat(tags.keySet(), hasSize(2)); assertThat(tags.get("A"), empty()); assertThat(tags.get("B"), empty()); assertThat(tags.get("C"), containsInAnyOrder(tagC1, tagC2)); assertThat(tags.get("D"), containsInAnyOrder(tagD1, tagD2)); }
@Test public void findWithMultipleTagTypes() { Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root"); Tag tagA = Tags.tag("A", "inputA", rootTag); Tag tagB = Tags.tag("B", "inputB", rootTag); Tag tagC1 = Tags.tag("C", "inputC1", tagB); Tag tagC2 = Tags.tag("C", "inputC2", tagB); Tag tagD1 = Tags.tag("D", "inputD1", tagA); Tag tagD2 = Tags.tag("D", "inputD2", tagA); RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagA)); RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagB)); RuleOutput outputC = new RuleOutput("RuleC", "C", Collections.<ConditionFailure> emptySet(), Arrays.asList(tagC1, tagC2)); RuleOutput outputD1 = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD1)); RuleOutput outputD2 = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD2)); storage.store(Arrays.asList(outputA, outputB, outputC, outputD1, outputD2)); Collection<RuleOutput> outputs = storage.findLatestResultsByTagType(new HashSet<>(Arrays.asList("D", "C"))); assertThat(outputs, hasSize(3)); assertThat(outputs, containsInAnyOrder(outputD1, outputD2, outputC)); } }
@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 storeMultipleWithConditionFailures() { ConditionFailure failure1 = new ConditionFailure("ConditionX", "SomeHint"); ConditionFailure failure2 = new ConditionFailure("ConditionY", "SomeHint"); RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.singleton(failure1), Collections.<Tag> emptySet()); RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.singleton(failure2), Collections.<Tag> emptySet()); storage.store(Arrays.asList(outputA, outputB)); assertThat(storage.getAvailableTagTypes(), empty()); assertThat(storage.getAllOutputs().keySet(), empty()); assertThat(storage.getAllOutputsWithConditionFailures().keySet(), hasSize(2)); assertThat(storage.getAllOutputsWithConditionFailures().get("A"), containsInAnyOrder(outputA)); assertThat(storage.getAllOutputsWithConditionFailures().get("B"), containsInAnyOrder(outputB)); }
@Test public void mapWithConditionFailuresLeafs() { Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root"); Tag tagA = Tags.tag("A", "inputA", rootTag); Tag tagB = Tags.tag("B", "inputB", rootTag); Tags.tag("C", "inputC", tagB); ConditionFailure failure = new ConditionFailure("ConditionX", "SomeHint"); Tag tagD = Tags.tag("D", "inputD", tagA); RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagA)); RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagB)); RuleOutput outputC = new RuleOutput("RuleC", "C", Collections.singleton(failure), Collections.<Tag> emptySet()); RuleOutput outputD = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagD)); storage.store(Arrays.asList(outputA, outputB, outputC, outputD)); Multimap<String, Tag> tags = storage.mapTags(TagState.LEAF); assertThat(tags.size(), equalTo(1)); assertThat(tags.get("A"), empty()); assertThat(tags.get("B"), empty()); assertThat(tags.get("C"), empty()); assertThat(tags.get("D"), containsInAnyOrder(tagD)); } }
@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 storeMultipleWithoutConditionFailures() { Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root"); Tag tagA = Tags.tag("A", "inputA", rootTag); Tag tagB = Tags.tag("B", "inputB", rootTag); RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagA)); RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagB)); storage.store(Arrays.asList(outputA, outputB)); assertThat(storage.getAvailableTagTypes(), containsInAnyOrder("A", "B")); assertThat(storage.getAllOutputs().keySet(), hasSize(2)); assertThat(storage.getAllOutputs().keySet(), containsInAnyOrder("A", "B")); assertThat(storage.getAllOutputs().get("A"), containsInAnyOrder(outputA)); assertThat(storage.getAllOutputs().get("B"), containsInAnyOrder(outputB)); assertThat(storage.getAllOutputsWithConditionFailures().keySet(), hasSize(0)); }
@Test public void singleTagTypeMultipleInputs() throws RuleDefinitionException, SessionException { RuleDefinition ruleB = Rules.define(RuleB.class); Tag rootTag = Tags.rootTag("input"); Tag tagA1 = Tags.tag("A", "A1", rootTag); Tag tagA2 = Tags.tag("A", "A2", rootTag); Tag tagA3 = Tags.tag("A", "A3", rootTag); RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.<ConditionFailure> emptyList(), Arrays.asList(tagA1, tagA2, tagA3)); when(outputStorage.findLatestResultsByTagType(Matchers.<Set<String>> anyObject())).thenReturn(Collections.singleton(outputA)); Collection<RuleInput> ruleInputs = session.collectInputs(ruleB, outputStorage); assertThat(ruleInputs, hasSize(3)); assertThat(ruleInputs, containsInAnyOrder(new RuleInput(tagA1, Sets.newHashSet(tagA1)), new RuleInput(tagA2, Sets.newHashSet(tagA2)), new RuleInput(tagA3, Sets.newHashSet(tagA3)))); }
@Test public void storeWithAndWithoutConditionFailure() { ConditionFailure failure = new ConditionFailure("ConditionX", "SomeHint"); RuleOutput outputA = new RuleOutput("RuleA", "A", Collections.singleton(failure), Collections.<Tag> emptySet()); Tag rootTag = Tags.tag(Tags.ROOT_TAG, "root"); Tag tagB = Tags.tag("B", "inputB", rootTag); RuleOutput outputB = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptySet(), Collections.singleton(tagB)); storage.store(Arrays.asList(outputA, outputB)); assertThat(storage.getAvailableTagTypes(), containsInAnyOrder("B")); assertThat(storage.getAllOutputs().keySet(), hasSize(1)); assertThat(storage.getAllOutputs().keySet(), containsInAnyOrder("B")); assertThat(storage.getAllOutputs().get("A"), empty()); assertThat(storage.getAllOutputs().get("B"), containsInAnyOrder(outputB)); assertThat(storage.getAllOutputsWithConditionFailures().keySet(), hasSize(1)); assertThat(storage.getAllOutputsWithConditionFailures().get("A"), containsInAnyOrder(outputA)); }