rocks.inspectit.server.diagnosis.engine.rule.RuleOutput.<init> java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Gson g =new Gson()
GsonBuilder gsonBuilder;gsonBuilder.create()
new GsonBuilder().create()
Smart code suggestions by Codota
}

/**
 * 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)));
}

@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 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 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 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 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 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 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 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 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 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 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 multipleTagTypesMultipleInputs2() 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", tagA1);
  Tag tagA2 = Tags.tag("A", "A2", rootTag);
  Tag tagB2 = Tags.tag("B", "B2", tagA2);
  RuleOutput outputB1 = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptyList(), Arrays.asList(tagB1));
  RuleOutput outputB2 = new RuleOutput("RuleB", "B", Collections.<ConditionFailure> emptyList(), Arrays.asList(tagB2));
  when(outputStorage.findLatestResultsByTagType(Matchers.<Set<String>> anyObject())).thenReturn(Arrays.asList(outputB1, outputB2));
  Collection<RuleInput> ruleInputs = session.collectInputs(ruleC, outputStorage);
  assertThat(ruleInputs, hasSize(2));
  assertThat(ruleInputs, containsInAnyOrder(new RuleInput(tagB1, Sets.newHashSet(tagA1, tagB1)), new RuleInput(tagB2, Sets.newHashSet(tagA2, 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 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))));
}

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);

return new RuleOutput(getName(), getActionMethod().getResultTag(), conditionFailures, tags);

Javadoc

Default constructor.

Popular methods of RuleOutput

getConditionFailures
Gets #conditionFailures.
getRuleName
Gets #ruleName.
getTags
Gets #tags.
getEmbeddedTagType
Gets #embeddedTagType.
hasConditionFailures
Convenience method to check if the rule execution failed due to failed conditions.
hasResultTags
Convenience method to check if the rule execution produced result tags.

Popular in Java

Reactive rest calls using spring rest template
getResourceAsStream (ClassLoader)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
orElseThrow (Optional)
Graphics2D (java.awt)
This Graphics2D class extends the Graphics class to provide more sophisticated control overgraphics
Runnable (java.lang)
Represents a command that can be executed. Often used to run code in a different Thread.
GregorianCalendar (java.util)
GregorianCalendar is a concrete subclass of Calendarand provides the standard calendar used by most
Options (org.apache.commons.cli)
Main entry-point into the library. Options represents a collection of Option objects, which describ
StringUtils (org.apache.commons.lang)
Operations on java.lang.String that arenull safe. * IsEmpty/IsBlank - checks if a String contains
Runner (org.openjdk.jmh.runner)

How to use rocks.inspectit.server.diagnosis.engine.rule.RuleOutputconstructor

Best Java code snippets using rocks.inspectit.server.diagnosis.engine.rule.RuleOutput.<init> (Showing top 19 results out of 315)

How to use
rocks.inspectit.server.diagnosis.engine.rule.RuleOutput
constructor