/** * Utility method to mark a <code>Tag</code> as parent by setting the state to * {@link TagState#PARENT}. */ private void markParent() { if (state.equals(TagState.LEAF)) { state = TagState.PARENT; } }
/** * 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); }
/** * Factory method to create a new Tag. * * @param type * The type of the {@link Tag}. * @param input * The input object to be analyzed. * @param parent * The parent {@link Tag}. * @return A new Tag */ public static Tag tag(String type, Object input, Tag parent) { return new Tag(type, input, parent); }
@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 nullRootTagInput() { rocks.inspectit.server.diagnosis.engine.tag.Tag tag = rocks.inspectit.server.diagnosis.engine.tag.Tags.rootTag(null); assertThat(tag.getType(), equalTo(rocks.inspectit.server.diagnosis.engine.tag.Tags.ROOT_TAG)); assertThat(tag.getValue(), equalTo(null)); assertThat(tag.getParent(), equalTo(null)); assertThat(tag.getState(), equalTo(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; }
@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 shouldProduceSingleTagWithSingleObjectValue() throws Exception { // prepare Mocks Tag rootTag = Tags.rootTag("Input"); Tag expectedResultTag = new Tag("T1", "oneResult", rootTag); when(dummy.action()).thenReturn("oneResult"); when(input.getRoot()).thenReturn(rootTag); // Create TestMethod ActionMethod action = new ActionMethod(RuleDummy.actionMethod(), "T1", Action.Quantity.SINGLE); // execute Collection<Tag> result = action.execute(context); // verify assertThat(result, hasSize(1)); assertThat(result, hasItem(expectedResultTag)); }
@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))); }
/** * {@inheritDoc} */ @Override public int hashCode() { final int prime = 31; int result = 1; result = (prime * result) + ((this.parent == null) ? 0 : this.parent.hashCode()); result = (prime * result) + ((this.state == null) ? 0 : this.state.hashCode()); result = (prime * result) + ((this.type == null) ? 0 : this.type.hashCode()); result = (prime * result) + ((this.value == null) ? 0 : this.value.hashCode()); return result; }
/** * Factory method to create a collection of {@link Tag}s. * * @param type * The type of all {@link Tag}s. * @param parent * The parent {@link Tag}. * @param values * The values to be wrapped in {@link Tag}. For each value a new {@link Tag} is * created. * @return A collection of Tags. */ public static Collection<Tag> tags(String type, Tag parent, Object... values) { return tags(type, parent, Arrays.asList(values)); }
/** * 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))); }
/** * Creates a Tag with a value and a parent. * * @param type * The type of this <code>Tag</code>. * @param value * The value of this <code>Tag</code> * @param parent * The <code>Tag</code> which is considered as the predecessor of this * <code>Tag</code>. */ public Tag(String type, Object value, Tag parent) { this.value = value; this.type = type; this.parent = parent; if (this.parent != null) { this.parent.markParent(); } }
/** * {@inheritDoc} */ @Override public int hashCode() { final int prime = 31; int result = 1; result = (prime * result) + ((this.root == null) ? 0 : this.root.hashCode()); result = (prime * result) + ((this.unraveled == null) ? 0 : this.unraveled.hashCode()); return result; }
@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 validRootTagInput() { rocks.inspectit.server.diagnosis.engine.tag.Tag tag = rocks.inspectit.server.diagnosis.engine.tag.Tags.rootTag("TestInput"); assertThat(tag.getType(), equalTo(rocks.inspectit.server.diagnosis.engine.tag.Tags.ROOT_TAG)); assertThat(tag.getValue().toString(), equalTo("TestInput")); assertThat(tag.getParent(), equalTo(null)); assertThat(tag.getState(), equalTo(TagState.LEAF)); }
@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))); }
/** * 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 nullParentTag() { Collection<rocks.inspectit.server.diagnosis.engine.tag.Tag> tags = rocks.inspectit.server.diagnosis.engine.tag.Tags.tags("A", null, "TestInput1", "TestInput2"); rocks.inspectit.server.diagnosis.engine.tag.Tag[] tagArray = tags.toArray(new rocks.inspectit.server.diagnosis.engine.tag.Tag[0]); assertThat(tags, hasSize(2)); assertThat(tagArray[0].getType(), equalTo("A")); assertThat(tagArray[1].getType(), equalTo("A")); assertThat(tagArray[0].getValue().toString(), equalTo("TestInput1")); assertThat(tagArray[1].getValue().toString(), equalTo("TestInput2")); assertThat(tagArray[0].getParent(), equalTo(null)); assertThat(tagArray[1].getParent(), equalTo(null)); assertThat(tagArray[0].getState(), equalTo(TagState.LEAF)); assertThat(tagArray[1].getState(), equalTo(TagState.LEAF)); }
@Test public void withParentTag() { rocks.inspectit.server.diagnosis.engine.tag.Tag tagA = rocks.inspectit.server.diagnosis.engine.tag.Tags.tag("A", "TestInput"); Collection<rocks.inspectit.server.diagnosis.engine.tag.Tag> tags = rocks.inspectit.server.diagnosis.engine.tag.Tags.tags("B", tagA, "TestInput1", "TestInput2"); rocks.inspectit.server.diagnosis.engine.tag.Tag[] tagArray = tags.toArray(new rocks.inspectit.server.diagnosis.engine.tag.Tag[0]); assertThat(tags, hasSize(2)); assertThat(tagArray[0].getType(), equalTo("B")); assertThat(tagArray[1].getType(), equalTo("B")); assertThat(tagArray[0].getValue().toString(), equalTo("TestInput1")); assertThat(tagArray[1].getValue().toString(), equalTo("TestInput2")); assertThat(tagArray[0].getParent(), equalTo(tagA)); assertThat(tagArray[1].getParent(), equalTo(tagA)); assertThat(tagArray[0].getState(), equalTo(TagState.LEAF)); assertThat(tagArray[1].getState(), equalTo(TagState.LEAF)); assertThat(tagA.getState(), equalTo(TagState.PARENT)); } }