@Override public TagInjection visit(TagValue annotation, Field field) { return new TagInjection(annotation.type(), field, annotation.injectionStrategy()); } });
/** * {@inheritDoc} */ @Override public String toString() { return "TagInjection [type=" + type + ", injectionStrategy=" + injectionStrategy + ", getInjectee()=" + getInjectee() + "]"; }
@Test public void shouldInjectValue() throws RuleExecutionException { // prepare when(input.getUnraveled()).thenReturn(Tags.tags("T1", null, "InjectedValue")); // execute new TagInjection("T1", RuleDummy.tagStringValueField()).execute(context); // verify assertThat(ruleImpl.tagStringValueField, is("InjectedValue")); }
/** * {@inheritDoc} * * @throws RuleExecutionException * If tag injection fails. */ @Override public Object determineValueToInject(ExecutionContext context) throws RuleExecutionException { // extract the required type form the unraveled list of input Tags for (Tag tag : context.getRuleInput().getUnraveled()) { if (tag.getType().equals(getType())) { return InjectionStrategy.BY_VALUE.equals(getInjectionStrategy()) ? tag.getValue() : tag; } } throw new RuleExecutionException("Unable to find Tag: " + getType() + " in RuleInput.", context); }
injection.execute(ctx);
/** * Utility method to create a {@link FireCondition} either from a {@link Rule} annotation or * from {@link TagInjection}s. The values defined in the annotation overrules the * {@link TagInjection}s. * * @param rule * The {@link Rule} annotation. * @param tagInjections * The list of {@link TagInjection}s to extract a {@link FireCondition}. * @return A new {@link FireCondition} */ public static FireCondition describeFireCondition(Rule rule, List<TagInjection> tagInjections) { if ((rule != null) && ArrayUtils.isNotEmpty(rule.fireCondition())) { return new FireCondition(Sets.newHashSet(Arrays.asList(rule.fireCondition()))); } else { Set<String> requiredTypes = new HashSet<>(); for (TagInjection injection : tagInjections) { requiredTypes.add(injection.getType()); } return new FireCondition(requiredTypes); } }
@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"))); } }
@Test public void testWithRuleAnnotation() throws Exception { RuleDefinition definition = Rules.define(ValidAndAnnotated.class); assertThat(definition.getName(), is("AnnotatedRule")); assertThat(definition.getDescription(), is("Description")); assertThat(definition.getFireCondition().getTagTypes(), containsInAnyOrder("T1", "T2")); // Test tag injections TagInjection tagInjection = new TagInjection("T1", ValidAndAnnotated.class.getDeclaredField("t1AsTag"), TagValue.InjectionStrategy.BY_TAG); TagInjection tagInjection1 = new TagInjection("T2", ValidAndAnnotated.class.getDeclaredField("t2TagValue"), TagValue.InjectionStrategy.BY_VALUE); assertThat(definition.getTagInjections(), is(notNullValue())); assertThat(definition.getTagInjections(), containsInAnyOrder(tagInjection, tagInjection1)); // Test session variables SessionVariableInjection s1 = new SessionVariableInjection("baseline", false, ValidAndAnnotated.class.getDeclaredField("baseline")); SessionVariableInjection s2 = new SessionVariableInjection("baseline2", true, ValidAndAnnotated.class.getDeclaredField("baseline2")); assertThat(definition.getSessionVariableInjections(), containsInAnyOrder(s1, s2)); // Test action method assertThat(definition.getActionMethod(), is(new ActionMethod(ValidAndAnnotated.class.getDeclaredMethod("action"), "T2", Action.Quantity.SINGLE))); // Test condition method ConditionMethod conditionMethod = new ConditionMethod("myCondition", "No way out", ValidAndAnnotated.class.getDeclaredMethod("condition")); assertThat(definition.getConditionMethods(), containsInAnyOrder(conditionMethod)); }