src/test/java/com/github/sebhoss/reguloj/ChainedRuleEngineTest.java

   1 /*
   2  * Copyright © 2010 Sebastian Hoß <mail@shoss.de>
   3  * This work is free. You can redistribute it and/or modify it under the
   4  * terms of the Do What The Fuck You Want To Public License, Version 2,
   5  * as published by Sam Hocevar. See http://www.wtfpl.net/ for more details.
   6  */
   7 package com.github.sebhoss.reguloj;
   8
   9 import java.util.HashSet;
  10 import java.util.Set;
  11
  12 import com.github.sebhoss.warnings.CompilerWarnings;
  13 import com.google.common.collect.ImmutableList;
  14
  15 import org.junit.Assert;
  16 import org.junit.Before;
  17 import org.junit.Test;
  18 import org.junit.rules.ExpectedException;
  19 import org.mockito.BDDMockito;
  20 import org.mockito.Mockito;
  21
  22 /**
  23  * Test cases for the ChainedRuleEngine.
  24  */
  25 @SuppressWarnings({ CompilerWarnings.BOXING, CompilerWarnings.UNCHECKED })
  26 public class ChainedRuleEngineTest {
  27
  28     /** Checks expected exception inside single test cases. */
  29     @org.junit.Rule
  30     public ExpectedException            thrown = ExpectedException.none();
  31
  32     private RuleEngine<Context<Object>> engine;
  33     private Context<Object>             context;
  34     private Rule<Context<Object>>       rule;
  35
  36     /**
  37      * Creates rule engine and context.
  38      */
  39     @Before
  40     public void setup() {
  41         engine = new ChainedRuleEngine<>();
  42         context = Mockito.mock(Context.class);
  43         rule = Mockito.mock(Rule.class);
  44     }
  45
  46     /**
  47      * <p>
  48      * Test method for ChainedRuleEngine#analyze(Context, java.util.Set)
  49      * </p>
  50      * <p>
  51      * Ensures that <code>false</code> is returned when passing in an empty set.
  52      * </p>
  53      */
  54     @Test
  55     public void shouldReturnFalseForEmptyRuleSet() {
  56         final Set<Rule<Context<Object>>> rules = new HashSet<>();
  57
  58         final boolean fired = engine.analyze(rules, context);
  59
  60         Assert.assertFalse(fired);
  61     }
  62
  63     /**
  64      * <p>
  65      * Test method for ChainedRuleEngine#analyze(Context, Set)
  66      * </p>
  67      * <p>
  68      * Ensures that <code>true</code> is returned if any rule can fire.
  69      * </p>
  70      */
  71     @Test
  72     public void shouldReturnTrueIfRuleFired() {
  73         BDDMockito.given(rule.fires(context)).willReturn(Boolean.TRUE);
  74
  75         final boolean fired = engine.analyze(ImmutableList.of(rule), context);
  76
  77         Assert.assertTrue(fired);
  78     }
  79
  80     /**
  81      * <p>
  82      * Test method for ChainedRuleEngine#analyze(Context, Set)
  83      * </p>
  84      * <p>
  85      * Ensures that <code>false</code> is returned if no rule can fire.
  86      * </p>
  87      */
  88     @Test
  89     public void shouldReturnFalseIfNoRuleFires() {
  90         BDDMockito.given(rule.fires(context)).willReturn(Boolean.FALSE);
  91
  92         final boolean fired = engine.analyze(ImmutableList.of(rule), context);
  93
  94         Assert.assertFalse(fired);
  95     }
  96
  97     /**
  98      * <p>
  99      * Test method for ChainedRuleEngine#infer(Context, Set)
 100      * </p>
 101      * <p>
 102      * Ensures that the engine can handle an empty rule set.
 103      * </p>
 104      */
 105
 106     @Test
 107     public void shouldRunWithEmptyRuleSet() {
 108         final Set<Rule<Context<Object>>> rules = new HashSet<>();
 109
 110         engine.infer(rules, context);
 111     }
 112
 113     /**
 114      * <p>
 115      * Test method for ChainedRuleEngine#infer(Context, Set)
 116      * </p>
 117      * <p>
 118      * Ensures that the engine loops if any rule can fire.
 119      * </p>
 120      */
 121     @Test
 122     public void shouldLoopWithFiringRule() {
 123         BDDMockito.given(rule.run(context)).willReturn(Boolean.TRUE).willReturn(Boolean.FALSE);
 124
 125         engine.infer(ImmutableList.of(rule), context);
 126
 127         Mockito.verify(rule, Mockito.times(2)).run(context);
 128     }
 129
 130     /**
 131      * <p>
 132      * Test method for ChainedRuleEngine#infer(Context, Set)
 133      * </p>
 134      * <p>
 135      * Ensures that the engine does not loop if no rule can fire.
 136      * </p>
 137      */
 138     @Test
 139     public void shouldNotLoopWithNotFiringRule() {
 140         BDDMockito.given(rule.run(context)).willReturn(Boolean.FALSE);
 141
 142         engine.infer(ImmutableList.of(rule), context);
 143
 144         Mockito.verify(rule, Mockito.times(1)).run(context);
 145     }
 146 }