/** * Factory method to create the root {@link Tag} of type {@link #ROOT_TAG}. * * @param input * The input object to be analyzed. * @return A new Tag */ public static Tag rootTag(Object input) { return tag(ROOT_TAG, input); }
@Test public void shouldInjectTag() throws RuleExecutionException { // prepare when(input.getUnraveled()).thenReturn(Tags.tags("T1", null, "InjectedValue")); // execute new TagInjection("T1", RuleDummy.tagAsTagField(), TagValue.InjectionStrategy.BY_TAG).execute(context); // verify assertThat(ruleImpl.tagAsTagField, is(Tags.tag("T1", "InjectedValue"))); } }
/** * Factory method to create a new Tag. * * @param type * The type of the {@link Tag}. * @param input * The input object to be analyzed. * @return A new Tag */ public static Tag tag(String type, Object input) { return tag(type, input, null); }
@Test public void filterNotMatchingAtAll() { rocks.inspectit.server.diagnosis.engine.tag.Tag tagA = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("A", "IN-A"); rocks.inspectit.server.diagnosis.engine.tag.Tag tagB1 = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("B", "IN-B1", tagA); rocks.inspectit.server.diagnosis.engine.tag.Tag tagB2 = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("B", "IN-B2", tagA); rocks.inspectit.server.diagnosis.engine.tag.Tag tagC1 = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("C", "IN-C1", tagB1); rocks.inspectit.server.diagnosis.engine.tag.Tag tagC2 = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("C", "IN-C2", tagB2); rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("D", "IN-D1", tagC1); rocks.inspectit.server.diagnosis.engine.tag.Tag tagD2 = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("D", "IN-D2", tagC2); Collection<rocks.inspectit.server.diagnosis.engine.tag.Tag> tags = rocks.inspectit.server.diagnosis.engine.tag.Tags.unwrap(tagD2, Arrays.asList(new String[] { "X", "Y", "Z" })); assertThat(tags, hasSize(1)); assertThat(tags, containsInAnyOrder(tagD2)); } }
@Test public void filterInReverseOrder() { rocks.inspectit.server.diagnosis.engine.tag.Tag tagA = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("A", "IN-A"); rocks.inspectit.server.diagnosis.engine.tag.Tag tagB1 = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("B", "IN-B1", tagA); rocks.inspectit.server.diagnosis.engine.tag.Tag tagB2 = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("B", "IN-B2", tagA); rocks.inspectit.server.diagnosis.engine.tag.Tag tagC1 = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("C", "IN-C1", tagB1); rocks.inspectit.server.diagnosis.engine.tag.Tag tagC2 = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("C", "IN-C2", tagB2); rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("D", "IN-D1", tagC1); rocks.inspectit.server.diagnosis.engine.tag.Tag tagD2 = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("D", "IN-D2", tagC2); Collection<rocks.inspectit.server.diagnosis.engine.tag.Tag> tags = rocks.inspectit.server.diagnosis.engine.tag.Tags.unwrap(tagD2, Arrays.asList(new String[] { "D", "B", "A", })); assertThat(tags, hasSize(3)); assertThat(tags, containsInAnyOrder(tagA, tagB2, tagD2)); assertThat(tags, not(contains(tagB1))); }
@Test public void add() { RuleInput input = new RuleInput(Tags.tag("A", "input")); sessionContext.addExecution(rules.iterator().next(), input); assertThat(sessionContext.getExecutions().get(rules.iterator().next()), containsInAnyOrder(input)); } }
@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 filterOne() throws RuleDefinitionException, SessionException { RuleDefinition ruleB = Rules.define(RuleB.class); RuleInput inputA1 = new RuleInput(Tags.tag("A", "A1")); RuleInput inputA2 = new RuleInput(Tags.tag("A", "A2")); RuleInput inputA3 = new RuleInput(Tags.tag("A", "A3")); RuleInput inputB = new RuleInput(Tags.tag("B", "XY")); RuleInput inputC = new RuleInput(Tags.tag("C", "XY")); Collection<RuleInput> inputs = Arrays.asList(inputA1, inputA2, inputA3, inputB, inputC); Multimap<RuleDefinition, RuleInput> executions = ArrayListMultimap.create(); executions.put(ruleB, inputA1); inputs = session.filterProcessedInputs(executions, ruleB, inputs); assertThat(inputs, containsInAnyOrder(inputA2, inputA3, inputB, inputC)); }
@Test public void withParentTag() { rocks.inspectit.server.diagnosis.engine.tag.Tag tagA = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("A", "TestInput"); assertThat(tagA.getState(), equalTo(TagState.LEAF)); rocks.inspectit.server.diagnosis.engine.tag.Tag tagB = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("B", "TestInput", tagA); assertThat(tagB.getType(), equalTo("B")); assertThat(tagB.getValue().toString(), equalTo("TestInput")); assertThat(tagB.getParent(), equalTo(tagA)); assertThat(tagB.getState(), equalTo(TagState.LEAF)); assertThat(tagA.getState(), equalTo(TagState.PARENT)); } }
@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 nullParentTag() { rocks.inspectit.server.diagnosis.engine.tag.Tag tag = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("A", "TestInput"); assertThat(tag.getType(), equalTo("A")); assertThat(tag.getValue().toString(), equalTo("TestInput")); assertThat(tag.getParent(), equalTo(null)); assertThat(tag.getState(), equalTo(TagState.LEAF)); }
@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 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 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)); }
@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 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 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 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))); }