Added tests for strategy pattern

Author: fluxw42

strategy/pom.xml

@@ -14,5 +14,10 @@
       <artifactId>junit</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 </project>

strategy/src/test/java/com/iluwatar/strategy/DragonSlayerTest.java

@@ -0,0 +1,48 @@
+package com.iluwatar.strategy;
+
+import org.junit.Test;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+/**
+ * Date: 12/29/15 - 10:50 PM
+ *
+ * @author Jeroen Meulemeester
+ */
+public class DragonSlayerTest {
+
+  /**
+   * Verify if the dragon slayer uses the strategy during battle
+   */
+  @Test
+  public void testGoToBattle() {
+    final DragonSlayingStrategy strategy = mock(DragonSlayingStrategy.class);
+    final DragonSlayer dragonSlayer = new DragonSlayer(strategy);
+
+    dragonSlayer.goToBattle();
+    verify(strategy).execute();
+    verifyNoMoreInteractions(strategy);
+  }
+
+  /**
+   * Verify if the dragon slayer uses the new strategy during battle after a change of strategy
+   */
+  @Test
+  public void testChangeStrategy() throws Exception {
+    final DragonSlayingStrategy initialStrategy = mock(DragonSlayingStrategy.class);
+    final DragonSlayer dragonSlayer = new DragonSlayer(initialStrategy);
+
+    dragonSlayer.goToBattle();
+    verify(initialStrategy).execute();
+
+    final DragonSlayingStrategy newStrategy = mock(DragonSlayingStrategy.class);
+    dragonSlayer.changeStrategy(newStrategy);
+
+    dragonSlayer.goToBattle();
+    verify(newStrategy).execute();
+
+    verifyNoMoreInteractions(initialStrategy, newStrategy);
+  }
+}

strategy/src/test/java/com/iluwatar/strategy/DragonSlayingStrategyTest.java

@@ -0,0 +1,104 @@
+package com.iluwatar.strategy;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.io.PrintStream;
+import java.util.Arrays;
+import java.util.Collection;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+/**
+ * Date: 12/29/15 - 10:58 PM
+ *
+ * @author Jeroen Meulemeester
+ */
+@RunWith(Parameterized.class)
+public class DragonSlayingStrategyTest {
+
+  /**
+   * @return The test parameters for each cycle
+   */
+  @Parameterized.Parameters
+  public static Collection<Object[]> data() {
+    return Arrays.asList(
+        new Object[]{
+            new MeleeStrategy(),
+            "With your Excalibur you severe the dragon's head!"
+        },
+        new Object[]{
+            new ProjectileStrategy(),
+            "You shoot the dragon with the magical crossbow and it falls dead on the ground!"
+        },
+        new Object[]{
+            new SpellStrategy(),
+            "You cast the spell of disintegration and the dragon vaporizes in a pile of dust!"
+        }
+    );
+  }
+
+  /**
+   * The tested strategy
+   */
+  private final DragonSlayingStrategy strategy;
+
+  /**
+   * The expected action on the std-out
+   */
+  private final String expectedResult;
+
+  /**
+   * The mocked standard out {@link PrintStream}, required since some actions don't have any
+   * influence on accessible objects, except for writing to std-out using {@link System#out}
+   */
+  private final PrintStream stdOutMock = mock(PrintStream.class);
+
+  /**
+   * Keep the original std-out so it can be restored after the test
+   */
+  private final PrintStream stdOutOrig = System.out;
+
+  /**
+   * Create a new test instance for the given strategy
+   *
+   * @param strategy       The tested strategy
+   * @param expectedResult The expected result
+   */
+  public DragonSlayingStrategyTest(final DragonSlayingStrategy strategy, final String expectedResult) {
+    this.strategy = strategy;
+    this.expectedResult = expectedResult;
+  }
+
+  /**
+   * Inject the mocked std-out {@link PrintStream} into the {@link System} class before each test
+   */
+  @Before
+  public void setUp() {
+    System.setOut(this.stdOutMock);
+  }
+
+  /**
+   * Removed the mocked std-out {@link PrintStream} again from the {@link System} class
+   */
+  @After
+  public void tearDown() {
+    System.setOut(this.stdOutOrig);
+  }
+
+  /**
+   * Test if executing the strategy gives the correct response
+   */
+  @Test
+  public void testExecute() {
+    this.strategy.execute();
+    verify(this.stdOutMock).println(this.expectedResult);
+    verifyNoMoreInteractions(this.stdOutMock);
+  }
+
+}