Added tests for template-method pattern

Author: fluxw42

template-method/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>

template-method/src/test/java/com/iluwatar/templatemethod/HalflingThiefTest.java

@@ -0,0 +1,50 @@
+package com.iluwatar.templatemethod;
+
+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 - 18:15 PM
+ *
+ * @author Jeroen Meulemeester
+ */
+public class HalflingThiefTest {
+
+  /**
+   * Verify if the thief uses the provided stealing method
+   */
+  @Test
+  public void testSteal() {
+    final StealingMethod method = mock(StealingMethod.class);
+    final HalflingThief thief = new HalflingThief(method);
+
+    thief.steal();
+    verify(method).steal();
+
+    verifyNoMoreInteractions(method);
+  }
+
+  /**
+   * Verify if the thief uses the provided stealing method, and the new method after changing it
+   */
+  @Test
+  public void testChangeMethod() {
+    final StealingMethod initialMethod = mock(StealingMethod.class);
+    final HalflingThief thief = new HalflingThief(initialMethod);
+
+    thief.steal();
+    verify(initialMethod).steal();
+
+    final StealingMethod newMethod = mock(StealingMethod.class);
+    thief.changeMethod(newMethod);
+
+    thief.steal();
+    verify(newMethod).steal();
+
+    verifyNoMoreInteractions(initialMethod, newMethod);
+
+  }
+}

template-method/src/test/java/com/iluwatar/templatemethod/HitAndRunMethodTest.java

@@ -0,0 +1,23 @@
+package com.iluwatar.templatemethod;
+
+/**
+ * Date: 12/30/15 - 18:12 PM
+ *
+ * @author Jeroen Meulemeester
+ */
+public class HitAndRunMethodTest extends StealingMethodTest<HitAndRunMethod> {
+
+  /**
+   * Create a new test for the {@link HitAndRunMethod}
+   */
+  public HitAndRunMethodTest() {
+    super(
+        new HitAndRunMethod(),
+        "old goblin woman",
+        "The target has been chosen as old goblin woman.",
+        "Approach the old goblin woman from behind.",
+        "Grab the handbag and run away fast!"
+    );
+  }
+
+}

template-method/src/test/java/com/iluwatar/templatemethod/StealingMethodTest.java

@@ -0,0 +1,142 @@
+package com.iluwatar.templatemethod;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InOrder;
+
+import java.io.PrintStream;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+/**
+ * Date: 12/30/15 - 18:12 PM
+ *
+ * @author Jeroen Meulemeester
+ */
+public abstract class StealingMethodTest<M extends StealingMethod> {
+
+  /**
+   * The tested stealing method
+   */
+  private final M method;
+
+  /**
+   * The expected target
+   */
+  private final String expectedTarget;
+
+  /**
+   * The expected target picking result
+   */
+  private final String expectedTargetResult;
+
+  /**
+   * The expected confusion method
+   */
+  private final String expectedConfuseMethod;
+
+  /**
+   * The expected stealing method
+   */
+  private final String expectedStealMethod;
+
+  /**
+   * 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 for the given stealing method, together with the expected results
+   *
+   * @param method                The tested stealing method
+   * @param expectedTarget        The expected target name
+   * @param expectedTargetResult  The expected target picking result
+   * @param expectedConfuseMethod The expected confusion method
+   * @param expectedStealMethod   The expected stealing method
+   */
+  public StealingMethodTest(final M method, String expectedTarget, final String expectedTargetResult,
+                            final String expectedConfuseMethod, final String expectedStealMethod) {
+
+    this.method = method;
+    this.expectedTarget = expectedTarget;
+    this.expectedTargetResult = expectedTargetResult;
+    this.expectedConfuseMethod = expectedConfuseMethod;
+    this.expectedStealMethod = expectedStealMethod;
+  }
+
+  /**
+   * 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);
+  }
+
+  /**
+   * Verify if the thief picks the correct target
+   */
+  @Test
+  public void testPickTarget() {
+    assertEquals(expectedTarget, this.method.pickTarget());
+  }
+
+  /**
+   * Verify if the target confusing step goes as planned
+   */
+  @Test
+  public void testConfuseTarget() {
+    verifyZeroInteractions(this.stdOutMock);
+
+    this.method.confuseTarget(this.expectedTarget);
+    verify(this.stdOutMock).println(this.expectedConfuseMethod);
+    verifyNoMoreInteractions(this.stdOutMock);
+  }
+
+  /**
+   * Verify if the stealing step goes as planned
+   */
+  @Test
+  public void testStealTheItem() {
+    verifyZeroInteractions(this.stdOutMock);
+
+    this.method.stealTheItem(this.expectedTarget);
+    verify(this.stdOutMock).println(this.expectedStealMethod);
+    verifyNoMoreInteractions(this.stdOutMock);
+  }
+
+  /**
+   * Verify if the complete steal process goes as planned
+   */
+  @Test
+  public void testSteal() {
+    final InOrder inOrder = inOrder(this.stdOutMock);
+
+    this.method.steal();
+
+    inOrder.verify(this.stdOutMock).println(this.expectedTargetResult);
+    inOrder.verify(this.stdOutMock).println(this.expectedConfuseMethod);
+    inOrder.verify(this.stdOutMock).println(this.expectedStealMethod);
+    inOrder.verifyNoMoreInteractions();
+  }
+
+}

template-method/src/test/java/com/iluwatar/templatemethod/SubtleMethodTest.java

@@ -0,0 +1,23 @@
+package com.iluwatar.templatemethod;
+
+/**
+ * Date: 12/30/15 - 18:19 PM
+ *
+ * @author Jeroen Meulemeester
+ */
+public class SubtleMethodTest extends StealingMethodTest<SubtleMethod> {
+
+  /**
+   * Create a new test for the {@link SubtleMethod}
+   */
+  public SubtleMethodTest() {
+    super(
+        new SubtleMethod(),
+        "shop keeper",
+        "The target has been chosen as shop keeper.",
+        "Approach the shop keeper with tears running and hug him!",
+        "While in close contact grab the shop keeper's wallet."
+    );
+  }
+
+}