How to use

Rules

in

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

ActionMethod actionMethod = describeActionMethod(clazz);
List<ConditionMethod> conditionMethods = describeConditionMethods(clazz);
List<TagInjection> tagInjections = describeTagInjection(clazz);
List<SessionVariableInjection> variableInjections = describeSessionParameterInjections(clazz);
FireCondition fireCondition = describeFireCondition(annotation, tagInjections);

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

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

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

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

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

@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 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 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
public void fromActivated() throws Exception {
  session = new Session<>(Rules.define(RuleA.class, RuleB.class, RuleC.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(), containsInAnyOrder("C"));
  assertThat(result.getEndTags().get("C"), hasSize(1));
  assertThat(((Integer) result.getEndTags().get("C").iterator().next().getValue()), equalTo((input.length() * 2) + 2));
}