Merge pull request #294 from DevFactory/release1

Unit tests for adapter, business-delegate, factory-method and command modules

CODE_COVERAGE.md

@@ -0,0 +1,13 @@
+# Code Coverage Report generation
+
+To generate the code coverage report, execute the following command:
+> mvn clean verify
+
+This will generate code coverage report in each of the modules. In order to view the same, open the following file in your browser.
+> target/site/jacoco/index.html 
+
+Please note that the above folder is created under each of the modules. For example:
+* adapter/target/site/jacoco/index.html 
+* busniess-delegate/target/site/jacoco/index.html 
+
+

adapter/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>

adapter/src/main/java/com/iluwatar/adapter/App.java

@@ -1,30 +1,28 @@
 package com.iluwatar.adapter;
 
 /**
- *
  * An adapter helps two incompatible interfaces to work together. This is the real world definition
  * for an adapter. Interfaces may be incompatible but the inner functionality should suit the need.
  * The Adapter design pattern allows otherwise incompatible classes to work together by converting
  * the interface of one class into an interface expected by the clients.
- * <p>
+ * 
- * There are two variations of the Adapter pattern: The class adapter implements the adaptee's
+ * <p>There are two variations of the Adapter pattern: The class adapter implements the adaptee's
  * interface whereas the object adapter uses composition to contain the adaptee in the adapter
  * object. This example uses the object adapter approach.
- * <p>
+ * 
- * The Adapter ({@link GnomeEngineer}) converts the interface of the target class (
+ * <p>The Adapter ({@link GnomeEngineer}) converts the interface of the target class (
  * {@link GoblinGlider}) into a suitable one expected by the client ({@link GnomeEngineeringManager}
  * ).
- * 
  */
 public class App {
 
   /**
-   * Program entry point
+   * Program entry point.
-   * 
+   *
    * @param args command line args
    */
   public static void main(String[] args) {
-    Engineer manager = new GnomeEngineeringManager();
+    Engineer manager = new GnomeEngineeringManager(new GnomeEngineer());
     manager.operateDevice();
   }
 }

adapter/src/main/java/com/iluwatar/adapter/GnomeEngineeringManager.java

@@ -1,20 +1,26 @@
 package com.iluwatar.adapter;
 
 /**
- * 
  * GnomeEngineering manager uses {@link Engineer} to operate devices.
- * 
  */
 public class GnomeEngineeringManager implements Engineer {
 
   private Engineer engineer;
 
   public GnomeEngineeringManager() {
-    engineer = new GnomeEngineer();
+
+  }
+
+  public GnomeEngineeringManager(Engineer engineer) {
+    this.engineer = engineer;
   }
 
   @Override
   public void operateDevice() {
     engineer.operateDevice();
   }
+
+  public void setEngineer(Engineer engineer) {
+    this.engineer = engineer;
+  }
 }

adapter/src/test/java/com/iluwatar/adapter/AdapterPatternTest.java

@@ -0,0 +1,68 @@
+package com.iluwatar.adapter;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * An adapter helps two incompatible interfaces to work together. This is the real world definition
+ * for an adapter. Interfaces may be incompatible but the inner functionality should suit the need.
+ * The Adapter design pattern allows otherwise incompatible classes to work together by converting
+ * the interface of one class into an interface expected by the clients.
+ * 
+ * <p>There are two variations of the Adapter pattern: 
+ * The class adapter implements the adaptee's
+ * interface whereas the object adapter uses composition to contain the adaptee in the adapter
+ * object. This example uses the object adapter approach.
+ * 
+ * <p>The Adapter ({@link GnomeEngineer}) converts the interface 
+ * of the target class ({@link GoblinGlider}) into a suitable one expected by 
+ * the client ({@link GnomeEngineeringManager}
+ * ).
+ */
+public class AdapterPatternTest {
+
+  private Map<String, Object> beans;
+
+  private static final String ENGINEER_BEAN = "engineer";
+
+  private static final String MANAGER_BEAN = "manager";
+
+  /**
+   * This method runs before the test execution and sets the bean objects in the beans Map.
+   */
+  @Before
+  public void setup() {
+    beans = new HashMap<>();
+
+    GnomeEngineer gnomeEngineer = spy(new GnomeEngineer());
+    beans.put(ENGINEER_BEAN, gnomeEngineer);
+
+    GnomeEngineeringManager manager = new GnomeEngineeringManager();
+    manager.setEngineer((GnomeEngineer) beans.get(ENGINEER_BEAN));
+    beans.put(MANAGER_BEAN, manager);
+  }
+
+  /**
+   * This test asserts that when we call operateDevice() method on a manager bean, it is internally
+   * calling operateDevice method on the engineer object. The Adapter ({@link GnomeEngineer})
+   * converts the interface of the target class ( {@link GoblinGlider}) into a suitable one expected
+   * by the client ({@link GnomeEngineeringManager} ).
+   */
+  @Test
+  public void testAdapter() {
+    Engineer manager = (Engineer) beans.get(MANAGER_BEAN);
+
+    // when manager is asked to operate device
+    manager.operateDevice();
+
+    // Manager internally calls the engineer object to operateDevice
+    Engineer engineer = (Engineer) beans.get(ENGINEER_BEAN);
+    verify(engineer).operateDevice();
+  }
+}

adapter/src/test/java/com/iluwatar/adapter/AppTest.java

@@ -1,19 +0,0 @@
-package com.iluwatar.adapter;
-
-import org.junit.Test;
-
-import com.iluwatar.adapter.App;
-
-/**
- * 
- * Application test
- *
- */
-public class AppTest {
-
-  @Test
-  public void test() {
-    String[] args = {};
-    App.main(args);
-  }
-}

business-delegate/pom.xml

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

business-delegate/src/main/java/com/iluwatar/business/delegate/App.java

@@ -1,31 +1,34 @@
 package com.iluwatar.business.delegate;
 
 /**
- * 
  * The Business Delegate pattern adds an abstraction layer between the presentation and business
  * tiers. By using the pattern we gain loose coupling between the tiers. The Business Delegate
  * encapsulates knowledge about how to locate, connect to, and interact with the business objects
  * that make up the application.
- * <p>
+ * 
- * Some of the services the Business Delegate uses are instantiated directly, and some can be
+ * <p>Some of the services the Business Delegate uses are instantiated directly, and some can be
  * retrieved through service lookups. The Business Delegate itself may contain business logic too
  * potentially tying together multiple service calls, exception handling, retrying etc.
- * <p>
+ * 
- * In this example the client ({@link Client}) utilizes a business delegate (
+ * <p>In this example the client ({@link Client}) utilizes a business delegate (
  * {@link BusinessDelegate}) to execute a task. The Business Delegate then selects the appropriate
  * service and makes the service call.
- *
  */
 public class App {
 
   /**
-   * Program entry point
+   * Program entry point.
-   * 
+   *
    * @param args command line args
    */
   public static void main(String[] args) {
 
     BusinessDelegate businessDelegate = new BusinessDelegate();
+    BusinessLookup businessLookup = new BusinessLookup();
+    businessLookup.setEjbService(new EjbService());
+    businessLookup.setJmsService(new JmsService());
+
+    businessDelegate.setLookupService(businessLookup);
     businessDelegate.setServiceType(ServiceType.EJB);
 
     Client client = new Client(businessDelegate);

business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessDelegate.java

@@ -1,22 +1,24 @@
 package com.iluwatar.business.delegate;
 
 /**
- * 
  * BusinessDelegate separates the presentation and business tiers
- *
  */
 public class BusinessDelegate {
 
-  private BusinessLookup lookupService = new BusinessLookup();
+    private BusinessLookup lookupService;
-  private BusinessService businessService;
+    private BusinessService businessService;
-  private ServiceType serviceType;
+    private ServiceType serviceType;
 
-  public void setServiceType(ServiceType serviceType) {
+    public void setLookupService(BusinessLookup businessLookup) {
-    this.serviceType = serviceType;
+        this.lookupService = businessLookup;
-  }
+    }
 
-  public void doTask() {
+    public void setServiceType(ServiceType serviceType) {
-    businessService = lookupService.getBusinessService(serviceType);
+        this.serviceType = serviceType;
-    businessService.doProcessing();
+    }
-  }
+
+    public void doTask() {
+        businessService = lookupService.getBusinessService(serviceType);
+        businessService.doProcessing();
+    }
 }

business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessLookup.java

@@ -1,17 +1,31 @@
 package com.iluwatar.business.delegate;
 
 /**
- * 
+ * Class for performing service lookups.
- * Class for performing service lookups
- *
  */
 public class BusinessLookup {
 
+  private EjbService ejbService;
+
+  private JmsService jmsService;
+
+  /**
+   * @param serviceType Type of service instance to be returned.
+   * @return Service instance.
+   */
   public BusinessService getBusinessService(ServiceType serviceType) {
     if (serviceType.equals(ServiceType.EJB)) {
-      return new EjbService();
+      return ejbService;
     } else {
-      return new JmsService();
+      return jmsService;
     }
   }
+
+  public void setJmsService(JmsService jmsService) {
+    this.jmsService = jmsService;
+  }
+
+  public void setEjbService(EjbService ejbService) {
+    this.ejbService = ejbService;
+  }
 }

business-delegate/src/test/java/com/iluwatar/business/delegate/AppTest.java

@@ -1,19 +0,0 @@
-package com.iluwatar.business.delegate;
-
-import org.junit.Test;
-
-import com.iluwatar.business.delegate.App;
-
-/**
- * 
- * Application test
- *
- */
-public class AppTest {
-
-  @Test
-  public void test() {
-    String[] args = {};
-    App.main(args);
-  }
-}

business-delegate/src/test/java/com/iluwatar/business/delegate/BusinessDelegateTest.java

@@ -0,0 +1,78 @@
+package com.iluwatar.business.delegate;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * The Business Delegate pattern adds an abstraction layer between the presentation and business
+ * tiers. By using the pattern we gain loose coupling between the tiers. The Business Delegate
+ * encapsulates knowledge about how to locate, connect to, and interact with the business objects
+ * that make up the application.
+ * 
+ * <p>Some of the services the Business Delegate uses are instantiated directly, and some can be
+ * retrieved through service lookups. The Business Delegate itself may contain business logic too
+ * potentially tying together multiple service calls, exception handling, retrying etc.
+ */
+public class BusinessDelegateTest {
+
+  private EjbService ejbService;
+
+  private JmsService jmsService;
+
+  private BusinessLookup businessLookup;
+
+  private BusinessDelegate businessDelegate;
+
+  /**
+   * This method sets up the instance variables of this test class. It is executed before the
+   * execution of every test.
+   */
+  @Before
+  public void setup() {
+    ejbService = spy(new EjbService());
+    jmsService = spy(new JmsService());
+
+    businessLookup = spy(new BusinessLookup());
+    businessLookup.setEjbService(ejbService);
+    businessLookup.setJmsService(jmsService);
+
+    businessDelegate = spy(new BusinessDelegate());
+    businessDelegate.setLookupService(businessLookup);
+  }
+
+  /**
+   * In this example the client ({@link Client}) utilizes a business delegate (
+   * {@link BusinessDelegate}) to execute a task. The Business Delegate then selects the appropriate
+   * service and makes the service call.
+   */
+  @Test
+  public void testBusinessDelegate() {
+
+    // setup a client object
+    Client client = new Client(businessDelegate);
+
+    // set the service type
+    businessDelegate.setServiceType(ServiceType.EJB);
+
+    // action
+    client.doTask();
+
+    // verifying that the businessDelegate was used by client during doTask() method.
+    verify(businessDelegate).doTask();
+    verify(ejbService).doProcessing();
+
+    // set the service type
+    businessDelegate.setServiceType(ServiceType.JMS);
+
+    // action
+    client.doTask();
+
+    // verifying that the businessDelegate was used by client during doTask() method.
+    verify(businessDelegate, times(2)).doTask();
+    verify(jmsService).doProcessing();
+  }
+}

command/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>

command/src/test/java/com/iluwatar/command/AppTest.java

@@ -1,19 +0,0 @@
-package com.iluwatar.command;
-
-import org.junit.Test;
-
-import com.iluwatar.command.App;
-
-/**
- * 
- * Application test
- *
- */
-public class AppTest {
-
-  @Test
-  public void test() {
-    String[] args = {};
-    App.main(args);
-  }
-}

command/src/test/java/com/iluwatar/command/CommandTest.java

@@ -0,0 +1,71 @@
+package com.iluwatar.command;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+/**
+ * The Command pattern is a behavioral design pattern in which an object is used to encapsulate all
+ * information needed to perform an action or trigger an event at a later time. This information
+ * includes the method name, the object that owns the method and values for the method parameters.
+ * 
+ * <p>Four terms always associated with the command pattern are command, receiver, invoker and 
+ * client. A command object (spell) knows about the receiver (target) and invokes a method of 
+ * the receiver.Values for parameters of the receiver method are stored in the command. The receiver
+ * then does the work. An invoker object (wizard) knows how to execute a command, and optionally 
+ * does bookkeeping about the command execution. The invoker does not know anything about a 
+ * concrete command, it knows only about command interface. Both an invoker object and several 
+ * command objects are held by a client object (app). The client decides which commands to execute
+ * at which points. To execute a command, it passes the command object to the invoker object.
+ */
+public class CommandTest {
+
+  private static final String GOBLIN = "Goblin";
+
+  /**
+   * This test verifies that when the wizard casts spells on the goblin. The wizard keeps track of
+   * the previous spells cast, so it is easy to undo them. In addition, it also verifies that the
+   * wizard keeps track of the spells undone, so they can be redone.
+   */
+  @Test
+  public void testCommand() {
+
+    Wizard wizard = new Wizard();
+    Goblin goblin = new Goblin();
+
+    wizard.castSpell(new ShrinkSpell(), goblin);
+    verifyGoblin(goblin, GOBLIN, Size.SMALL, Visibility.VISIBLE);
+
+    wizard.castSpell(new InvisibilitySpell(), goblin);
+    verifyGoblin(goblin, GOBLIN, Size.SMALL, Visibility.INVISIBLE);
+
+    wizard.undoLastSpell();
+    verifyGoblin(goblin, GOBLIN, Size.SMALL, Visibility.VISIBLE);
+
+    wizard.undoLastSpell();
+    verifyGoblin(goblin, GOBLIN, Size.NORMAL, Visibility.VISIBLE);
+
+    wizard.redoLastSpell();
+    verifyGoblin(goblin, GOBLIN, Size.SMALL, Visibility.VISIBLE);
+
+    wizard.redoLastSpell();
+    verifyGoblin(goblin, GOBLIN, Size.SMALL, Visibility.INVISIBLE);
+  }
+
+  /**
+   * This method asserts that the passed goblin object has the name as expectedName, size as
+   * expectedSize and visibility as expectedVisibility.
+   *
+   * @param goblin a goblin object whose state is to be verified against other parameters
+   * @param expectedName expectedName of the goblin
+   * @param expectedSize expected size of the goblin
+   * @param expectedVisibilty exepcted visibility of the goblin
+   */
+  private void verifyGoblin(Goblin goblin, String expectedName, Size expectedSize,
+      Visibility expectedVisibilty) {
+    assertEquals("Goblin's name must be same as expectedName", expectedName, goblin.toString());
+    assertEquals("Goblin's size must be same as expectedSize", expectedSize, goblin.getSize());
+    assertEquals("Goblin's visibility must be same as expectedVisibility", expectedVisibilty,
+        goblin.getVisibility());
+  }
+}

factory-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>

factory-method/src/main/java/com/iluwatar/factory/method/ElfWeapon.java

@@ -1,9 +1,7 @@
 package com.iluwatar.factory.method;
 
 /**
- * 
+ * ElfWeapon.
- * ElfWeapon
- *
  */
 public class ElfWeapon implements Weapon {
 
@@ -17,4 +15,9 @@ public class ElfWeapon implements Weapon {
   public String toString() {
     return "Elven " + weaponType;
   }
+
+  @Override
+  public WeaponType getWeaponType() {
+    return weaponType;
+  }
 }

factory-method/src/main/java/com/iluwatar/factory/method/OrcWeapon.java

@@ -1,9 +1,7 @@
 package com.iluwatar.factory.method;
 
 /**
- * 
+ * OrcWeapon.
- * OrcWeapon
- *
  */
 public class OrcWeapon implements Weapon {
 
@@ -17,4 +15,9 @@ public class OrcWeapon implements Weapon {
   public String toString() {
     return "Orcish " + weaponType;
   }
+
+  @Override
+  public WeaponType getWeaponType() {
+    return weaponType;
+  }
 }

factory-method/src/main/java/com/iluwatar/factory/method/Weapon.java

@@ -1,10 +1,10 @@
 package com.iluwatar.factory.method;
 
 /**
- * 
+ * Weapon interface.
- * Weapon interface
- *
  */
 public interface Weapon {
 
+  WeaponType getWeaponType();
+
 }

factory-method/src/test/java/com/iluwatar/factory/method/AppTest.java

@@ -1,19 +0,0 @@
-package com.iluwatar.factory.method;
-
-import org.junit.Test;
-
-import com.iluwatar.factory.method.App;
-
-/**
- * 
- * Application test
- *
- */
-public class AppTest {
-
-  @Test
-  public void test() {
-    String[] args = {};
-    App.main(args);
-  }
-}

factory-method/src/test/java/com/iluwatar/factory/method/FactoryMethodTest.java

@@ -0,0 +1,79 @@
+package com.iluwatar.factory.method;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * The Factory Method is a creational design pattern which uses factory methods to deal with the
+ * problem of creating objects without specifying the exact class of object that will be created.
+ * This is done by creating objects via calling a factory method either specified in an interface
+ * and implemented by child classes, or implemented in a base class and optionally overridden by
+ * derived classes—rather than by calling a constructor.
+ * 
+ * <p>Factory produces the object of its liking. 
+ * The weapon {@link Weapon} manufactured by the
+ * blacksmith depends on the kind of factory implementation it is referring to.
+ * </p>
+ */
+public class FactoryMethodTest {
+
+  /**
+   * Testing {@link OrcBlacksmith} to produce a SPEAR asserting that the Weapon is an instance 
+   * of {@link OrcWeapon}.
+   */
+  @Test
+  public void testOrcBlacksmithWithSpear() {
+    Blacksmith blacksmith = new OrcBlacksmith();
+    Weapon weapon = blacksmith.manufactureWeapon(WeaponType.SPEAR);
+    verifyWeapon(weapon, WeaponType.SPEAR, OrcWeapon.class);
+  }
+
+  /**
+   * Testing {@link OrcBlacksmith} to produce a AXE asserting that the Weapon is an instance
+   *  of {@link OrcWeapon}.
+   */
+  @Test
+  public void testOrcBlacksmithWithAxe() {
+    Blacksmith blacksmith = new OrcBlacksmith();
+    Weapon weapon = blacksmith.manufactureWeapon(WeaponType.AXE);
+    verifyWeapon(weapon, WeaponType.AXE, OrcWeapon.class);
+  }
+
+  /**
+   * Testing {@link ElfBlacksmith} to produce a SHORT_SWORD asserting that the Weapon is an
+   * instance of {@link ElfWeapon}.
+   */
+  @Test
+  public void testElfBlacksmithWithShortSword() {
+    Blacksmith blacksmith = new ElfBlacksmith();
+    Weapon weapon = blacksmith.manufactureWeapon(WeaponType.SHORT_SWORD);
+    verifyWeapon(weapon, WeaponType.SHORT_SWORD, ElfWeapon.class);
+  }
+
+  /**
+   * Testing {@link ElfBlacksmith} to produce a SPEAR asserting that the Weapon is an instance
+   * of {@link ElfWeapon}.
+   */
+  @Test
+  public void testElfBlacksmithWithSpear() {
+    Blacksmith blacksmith = new ElfBlacksmith();
+    Weapon weapon = blacksmith.manufactureWeapon(WeaponType.SPEAR);
+    verifyWeapon(weapon, WeaponType.SPEAR, ElfWeapon.class);
+  }
+
+  /**
+   * This method asserts that the weapon object that is passed is an instance of the clazz and the
+   * weapon is of type expectedWeaponType.
+   * 
+   * @param weapon weapon object which is to be verified
+   * @param expectedWeaponType expected WeaponType of the weapon
+   * @param clazz expected class of the weapon
+   */
+  private void verifyWeapon(Weapon weapon, WeaponType expectedWeaponType, Class clazz) {
+    assertTrue("Weapon must be an object of: " + clazz.getName(), clazz.isInstance(weapon));
+    assertEquals("Weapon must be of weaponType: " + clazz.getName(), expectedWeaponType,
+        weapon.getWeaponType());
+  }
+}

pom.xml

@@ -131,6 +131,12 @@
 				<version>${junit.version}</version>
 				<scope>test</scope>
 			</dependency>
+			<dependency>
+				<groupId>org.mockito</groupId>
+				<artifactId>mockito-core</artifactId>
+				<version>1.10.19</version>
+				<scope>test</scope>
+			</dependency>
 			<dependency>
 				<groupId>log4j</groupId>
 				<artifactId>log4j</artifactId>
@@ -243,6 +249,41 @@
 					</execution>
 				</executions>
 			</plugin>
+
+			<plugin>
+				<groupId>org.jacoco</groupId>
+				<artifactId>jacoco-maven-plugin</artifactId>
+				<version>0.7.5.201505241946</version>
+				<executions>
+					<execution>
+						<goals>
+							<goal>prepare-agent</goal>
+						</goals>
+					</execution>
+					<execution>
+						<id>report</id>
+						<phase>prepare-package</phase>
+						<goals>
+							<goal>report</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>2.18.1</version>
+				<dependencies>
+					<dependency>
+						<groupId>org.apache.maven.surefire</groupId>
+						<artifactId>surefire-junit47</artifactId>
+						<version>2.18.1</version>
+					</dependency>
+				</dependencies>
+				<configuration>
+					<argLine>-Xmx1024M ${argLine}</argLine>
+				</configuration>
+			</plugin>
 		</plugins>
 	</build>