/** * Creates the faked output of an internal rule to start process of other rules. If we wrap the * input to be analyzed into a RuleOutput the entire rule processing works exactly the same way * and and the input can be access of type {@link Tags#ROOT_TAG}. * * @param input * The input to be wrapped in output. * @return RuleOutput providing the input as value of {@link Tags#ROOT_TAG}. */ public static RuleOutput triggerRuleOutput(Object input) { return new RuleOutput(TRIGGER_RULE, Tags.ROOT_TAG, Collections.<ConditionFailure> emptyList(), Collections.singleton(Tags.rootTag(input))); }
@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)); }
/** * {@inheritDoc} */ @Override public Multimap<String, Tag> mapTags(TagState state) { Multimap<String, Tag> tags = ArrayListMultimap.create(); for (Map.Entry<String, RuleOutput> entry : allOutputs.entries()) { if (entry.getValue().hasResultTags()) { for (Tag tag : entry.getValue().getTags()) { if (tag.getState().equals(state)) { tags.put(tag.getType(), tag); } } } } return tags; }
/** * {@inheritDoc} */ @Override public void store(RuleOutput output) { if (output.hasConditionFailures()) { conditionFailures.put(output.getEmbeddedTagType(), output); } else { allOutputs.put(output.getEmbeddedTagType(), output); } }
@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 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()); } }
ConditionFailure cFailure1 = new ConditionFailure("Cond1", "test hint"); ConditionFailure cFailure2 = new ConditionFailure("Cond2", "test hint2"); RuleOutput output1 = new RuleOutput("RuleA", "A", Arrays.asList(cFailure1), Arrays.asList(tagA)); RuleOutput output2 = new RuleOutput("RuleB", "B", Arrays.asList(cFailure2), Arrays.asList(tagB)); RuleOutput output3 = new RuleOutput("RuleC", "C", Collections.<ConditionFailure> emptyList(), Arrays.asList(tagC)); RuleOutput output4 = new RuleOutput("RuleD", "D", Collections.<ConditionFailure> emptyList(), Arrays.asList(tagD1, tagD2)); outputMap.put(output1.getRuleName(), output1); outputMap.put(output2.getRuleName(), output2); outputMap.put(output3.getRuleName(), output3); outputMap.put(output4.getRuleName(), output4); Multimap<String, Tag> tagMap = ArrayListMultimap.create(); tagMap.put("D", tagD1);
for (Tag leafTag : output.getTags()) { Collection<Tag> tags = Tags.unwrap(leafTag, requiredInputTags); if (tags.size() == requiredInputTags.size()) {
@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 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 ruleWithConditionSuccessExecution() throws RuleDefinitionException, RuleExecutionException { RuleDefinition ruleDefinition = Rules.define(RuleF.class); String inputStrA = "hallo"; String inputStrE = "again"; Tag tagA = Tags.tag("A", inputStrA); Tag tagE = Tags.tag("E", inputStrE); RuleInput inputE = new RuleInput(tagE, Arrays.asList(tagA, tagE)); RuleOutput output = ruleDefinition.execute(inputE, Collections.<String, Object> emptyMap()); assertThat(output.getRuleName(), equalTo(ruleDefinition.getName())); assertThat(output.getTags(), hasSize(1)); assertThat(output.getTags().iterator().next().getValue(), equalTo((Object) (inputStrA + inputStrE))); }
@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 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 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)); }
@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 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 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 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 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)); }