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

  /**
   * Internal method to transform classes implementing a rule into {@link RuleDefinition}s.
   *
   * @param ruleClasses
   *            The classes to be transformed.
   * @return Set of {@link RuleDefinition}s.
   * @throws RuleDefinitionException
   *             If any {@link RuleDefinition} is invalid.
   */
  private Set<RuleDefinition> prepareRuleDefinitions(Set<Class<?>> ruleClasses) throws RuleDefinitionException {
    return Rules.define(ruleClasses);
  }
}

@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());
}

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

/**
 * Methods transforms all given classes to {@link RuleDefinition}s.
 * <p>
 * Throws: RuleDefinitionException if a class transformation fails.
 *
 * @param classes
 *            The classes to be transformed.
 * @return Set of {@link RuleDefinition}s.
 * @throws RuleDefinitionException
 *             If any {@link RuleDefinition} is invalid.
 */
public static Set<RuleDefinition> define(Class<?>... classes) throws RuleDefinitionException {
  return define(Arrays.asList(checkNotNull(classes, "Rule classes array must not be null!")));
}

  @Test(expectedExceptions = RuleDefinitionException.class)
  public void testMissingTagValueMethod() throws RuleDefinitionException {
    Rules.define(NoTagValueDefined.class);
  }
}

@Test(expectedExceptions = RuleDefinitionException.class)
public void testWithoutRuleAnnotation() throws RuleDefinitionException {
  Rules.define(MissingAnnotation.class);
}

@Test(expectedExceptions = RuleDefinitionException.class)
public void testMissingActionMethod() throws RuleDefinitionException {
  Rules.define(NoActionMethodDefined.class);
}

@Test(expectedExceptions = RuleDefinitionException.class)
public void testMultipleActionMethods() throws RuleDefinitionException {
  Rules.define(MultipleActionMethodsDefined.class);
}

@Test(expectedExceptions = RuleDefinitionException.class)
public void testInvalidActionMethodReturnType() throws RuleDefinitionException {
  Rules.define(InvalidActionMethodReturnType.class);
}

/**
 * Methods transforms all given classes to {@link RuleDefinition}s.
 *
 * Throws: RuleDefinitionException if a class transformation fails.
 *
 * @param classes
 *            The classes to be transformed.
 * @return Set of {@link RuleDefinition}s.
 * @throws RuleDefinitionException
 *             If any {@link RuleDefinition} is invalid.
 *
 */
public static Set<RuleDefinition> define(Collection<Class<?>> classes) throws RuleDefinitionException {
  checkArgument(CollectionUtils.isNotEmpty(classes), "Rule classes must not be null or empty!");
  Set<RuleDefinition> ruleSet = Sets.newHashSet();
  for (Class<?> clazz : classes) {
    ruleSet.add(define(clazz));
  }
  return ruleSet;
}

@BeforeMethod
public void init() throws RuleDefinitionException {
  rules = Rules.define(RuleA.class, RuleB.class, RuleC.class);
  sessionContext = new SessionContext<>(rules, storage);
}

@Test
public void onlyRuleBMatch() throws RuleDefinitionException {
  RuleDefinition ruleA = Rules.define(RuleA.class);
  RuleDefinition ruleB = Rules.define(RuleB.class);
  RuleDefinition ruleC = Rules.define(RuleC.class);
  Set<RuleDefinition> ruleDefinitions = new HashSet<>(Arrays.asList(ruleA, ruleB, ruleC));
  Set<String> availableTagTypes = new HashSet<>(Arrays.asList(new String[] { "A" }));
  Collection<RuleDefinition> nextRules = session.findNextRules(availableTagTypes, ruleDefinitions);
  assertThat(nextRules, containsInAnyOrder(ruleB));
}

@Test
public void noneMatch() throws RuleDefinitionException {
  RuleDefinition ruleA = Rules.define(RuleA.class);
  RuleDefinition ruleB = Rules.define(RuleB.class);
  RuleDefinition ruleC = Rules.define(RuleC.class);
  Set<RuleDefinition> ruleDefinitions = new HashSet<>(Arrays.asList(ruleA, ruleB, ruleC));
  Set<String> availableTagTypes = new HashSet<>(Arrays.asList(new String[] { "B" }));
  Collection<RuleDefinition> nextRules = session.findNextRules(availableTagTypes, ruleDefinitions);
  assertThat(nextRules, empty());
}

@Test
public void onlyRuleBAndCMatch() throws RuleDefinitionException {
  RuleDefinition ruleA = Rules.define(RuleA.class);
  RuleDefinition ruleB = Rules.define(RuleB.class);
  RuleDefinition ruleC = Rules.define(RuleC.class);
  Set<RuleDefinition> ruleDefinitions = new HashSet<>(Arrays.asList(ruleA, ruleB, ruleC));
  Set<String> availableTagTypes = new HashSet<>(Arrays.asList(new String[] { "A", "B" }));
  Collection<RuleDefinition> nextRules = session.findNextRules(availableTagTypes, ruleDefinitions);
  assertThat(nextRules, containsInAnyOrder(ruleB, ruleC));
}

@Test
public void allRulesMatch() throws RuleDefinitionException {
  Set<RuleDefinition> ruleDefinitions = Rules.define(RuleA.class, RuleB.class, RuleC.class);
  Set<String> availableTagTypes = new HashSet<>(Arrays.asList(Tags.ROOT_TAG, "A", "B"));
  Collection<RuleDefinition> nextRules = session.findNextRules(availableTagTypes, ruleDefinitions);
  assertThat(nextRules, containsInAnyOrder(ruleDefinitions.toArray(new RuleDefinition[0])));
}

@Test(expectedExceptions = { SessionException.class })
public void fromNonActivatedState() throws Exception {
  session = new Session<>(Rules.define(RuleA.class, RuleB.class, RuleC.class), new DefaultSessionResultCollector<String>());
  session.call();
}

@Test
public void ruleWithConditionFailure() throws Exception {
  session = new Session<>(Rules.define(RuleA.class, RuleG.class), new DefaultSessionResultCollector<String>());
  String input = "input";
  session.activate(input, Session.EMPTY_SESSION_VARIABLES);
  DefaultSessionResult<String> result = session.call();
  assertThat(session.getState(), equalTo(State.PROCESSED));
  assertThat(result.getConditionFailures().keySet(), containsInAnyOrder("RuleG"));
  assertThat(result.getEndTags().keySet(), hasSize(1));
  assertThat(result.getEndTags().keySet(), containsInAnyOrder("A"));
}

  @Test(expectedExceptions = { SessionException.class })
  public void withRuleException() throws Exception {
    session = new Session<>(Rules.define(RuleA.class, RuleD.class), new DefaultSessionResultCollector<String>());
    String input = "input";
    session.activate(input, Session.EMPTY_SESSION_VARIABLES);
    session.call();
  }
}

@Test
public void twoOfThreeRulesApply() throws Exception {
  session = new Session<>(Rules.define(RuleA.class, RuleE.class, RuleF.class), new DefaultSessionResultCollector<String>());
  String input = "input";
  session.activate(input, Session.EMPTY_SESSION_VARIABLES);
  DefaultSessionResult<String> result = session.call();
  assertThat(session.getState(), equalTo(State.PROCESSED));
  assertThat(result.getConditionFailures().keys(), empty());
  assertThat(result.getEndTags().keySet(), hasSize(2));
  assertThat(result.getEndTags().keySet(), containsInAnyOrder("A", "E"));
}

  @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());
  }
}