From b577890db4c2aa8274983667bc0dd96e8b3d10e6 Mon Sep 17 00:00:00 2001 From: mfarid Date: Sun, 22 Nov 2015 05:44:45 +0530 Subject: [PATCH 1/5] Added UnitTest cases for adapter. --- adapter/pom.xml | 5 ++ .../main/java/com/iluwatar/adapter/App.java | 16 ++--- .../adapter/GnomeEngineeringManager.java | 12 +++- .../iluwatar/adapter/AdapterPatternTest.java | 68 +++++++++++++++++++ .../java/com/iluwatar/adapter/AppTest.java | 19 ------ 5 files changed, 89 insertions(+), 31 deletions(-) create mode 100644 adapter/src/test/java/com/iluwatar/adapter/AdapterPatternTest.java delete mode 100644 adapter/src/test/java/com/iluwatar/adapter/AppTest.java diff --git a/adapter/pom.xml b/adapter/pom.xml index 2284c2974..ddb81441f 100644 --- a/adapter/pom.xml +++ b/adapter/pom.xml @@ -14,5 +14,10 @@ junit test + + org.mockito + mockito-core + test + diff --git a/adapter/src/main/java/com/iluwatar/adapter/App.java b/adapter/src/main/java/com/iluwatar/adapter/App.java index f912efb03..d2353eec4 100644 --- a/adapter/src/main/java/com/iluwatar/adapter/App.java +++ b/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. - *

- * There are two variations of the Adapter pattern: The class adapter implements the adaptee's + * + *

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. - *

- * The Adapter ({@link GnomeEngineer}) converts the interface of the target class ( + * + *

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(); } } diff --git a/adapter/src/main/java/com/iluwatar/adapter/GnomeEngineeringManager.java b/adapter/src/main/java/com/iluwatar/adapter/GnomeEngineeringManager.java index a2faf1e54..ff4ddb617 100644 --- a/adapter/src/main/java/com/iluwatar/adapter/GnomeEngineeringManager.java +++ b/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; + } } diff --git a/adapter/src/test/java/com/iluwatar/adapter/AdapterPatternTest.java b/adapter/src/test/java/com/iluwatar/adapter/AdapterPatternTest.java new file mode 100644 index 000000000..866bfb968 --- /dev/null +++ b/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. + * + *

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. + * + *

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 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(); + } +} diff --git a/adapter/src/test/java/com/iluwatar/adapter/AppTest.java b/adapter/src/test/java/com/iluwatar/adapter/AppTest.java deleted file mode 100644 index a7462bd9a..000000000 --- a/adapter/src/test/java/com/iluwatar/adapter/AppTest.java +++ /dev/null @@ -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); - } -} From 012b638023980a5cdbc16bc63025fe4f3ad485ad Mon Sep 17 00:00:00 2001 From: mfarid Date: Sun, 22 Nov 2015 05:45:14 +0530 Subject: [PATCH 2/5] Added UnitTest cases for business delegate. --- business-delegate/pom.xml | 5 ++ .../com/iluwatar/business/delegate/App.java | 19 +++-- .../business/delegate/BusinessDelegate.java | 26 ++++--- .../business/delegate/BusinessLookup.java | 24 ++++-- .../iluwatar/business/delegate/AppTest.java | 19 ----- .../delegate/BusinessDelegateTest.java | 78 +++++++++++++++++++ 6 files changed, 127 insertions(+), 44 deletions(-) delete mode 100644 business-delegate/src/test/java/com/iluwatar/business/delegate/AppTest.java create mode 100644 business-delegate/src/test/java/com/iluwatar/business/delegate/BusinessDelegateTest.java diff --git a/business-delegate/pom.xml b/business-delegate/pom.xml index cfd7d6e5d..d07f2c0ae 100644 --- a/business-delegate/pom.xml +++ b/business-delegate/pom.xml @@ -15,5 +15,10 @@ junit test + + org.mockito + mockito-core + test + diff --git a/business-delegate/src/main/java/com/iluwatar/business/delegate/App.java b/business-delegate/src/main/java/com/iluwatar/business/delegate/App.java index c900f7366..371ec3ce4 100644 --- a/business-delegate/src/main/java/com/iluwatar/business/delegate/App.java +++ b/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. - *

- * Some of the services the Business Delegate uses are instantiated directly, and some can be + * + *

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. - *

- * In this example the client ({@link Client}) utilizes a business delegate ( + * + *

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); diff --git a/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessDelegate.java b/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessDelegate.java index b8a70aa0e..a3c9a00e7 100644 --- a/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessDelegate.java +++ b/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 BusinessService businessService; - private ServiceType serviceType; + private BusinessLookup lookupService; + private BusinessService businessService; + private ServiceType serviceType; - public void setServiceType(ServiceType serviceType) { - this.serviceType = serviceType; - } + public void setLookupService(BusinessLookup businessLookup) { + this.lookupService = businessLookup; + } - public void doTask() { - businessService = lookupService.getBusinessService(serviceType); - businessService.doProcessing(); - } + public void setServiceType(ServiceType serviceType) { + this.serviceType = serviceType; + } + + public void doTask() { + businessService = lookupService.getBusinessService(serviceType); + businessService.doProcessing(); + } } diff --git a/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessLookup.java b/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessLookup.java index 7cea16580..310f7f433 100644 --- a/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessLookup.java +++ b/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; + } } diff --git a/business-delegate/src/test/java/com/iluwatar/business/delegate/AppTest.java b/business-delegate/src/test/java/com/iluwatar/business/delegate/AppTest.java deleted file mode 100644 index 5ff7e6784..000000000 --- a/business-delegate/src/test/java/com/iluwatar/business/delegate/AppTest.java +++ /dev/null @@ -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); - } -} diff --git a/business-delegate/src/test/java/com/iluwatar/business/delegate/BusinessDelegateTest.java b/business-delegate/src/test/java/com/iluwatar/business/delegate/BusinessDelegateTest.java new file mode 100644 index 000000000..ebacd6b78 --- /dev/null +++ b/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. + * + *

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(); + } +} From e5614e5a208071070db190871b8adcc8eeaac020 Mon Sep 17 00:00:00 2001 From: mfarid Date: Sun, 22 Nov 2015 05:45:45 +0530 Subject: [PATCH 3/5] Added UnitTest cases for command. --- command/pom.xml | 5 ++ .../java/com/iluwatar/command/AppTest.java | 19 ----- .../com/iluwatar/command/CommandTest.java | 71 +++++++++++++++++++ 3 files changed, 76 insertions(+), 19 deletions(-) delete mode 100644 command/src/test/java/com/iluwatar/command/AppTest.java create mode 100644 command/src/test/java/com/iluwatar/command/CommandTest.java diff --git a/command/pom.xml b/command/pom.xml index 08ff32d3b..6001ebc33 100644 --- a/command/pom.xml +++ b/command/pom.xml @@ -14,5 +14,10 @@ junit test + + org.mockito + mockito-core + test + diff --git a/command/src/test/java/com/iluwatar/command/AppTest.java b/command/src/test/java/com/iluwatar/command/AppTest.java deleted file mode 100644 index aa0af3571..000000000 --- a/command/src/test/java/com/iluwatar/command/AppTest.java +++ /dev/null @@ -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); - } -} diff --git a/command/src/test/java/com/iluwatar/command/CommandTest.java b/command/src/test/java/com/iluwatar/command/CommandTest.java new file mode 100644 index 000000000..fd1076840 --- /dev/null +++ b/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. + * + *

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()); + } +} From ced317bc9dcc6158d86253d093f9c3a77ee91348 Mon Sep 17 00:00:00 2001 From: mfarid Date: Sun, 22 Nov 2015 05:46:14 +0530 Subject: [PATCH 4/5] Added UnitTest cases for factory method. --- factory-method/pom.xml | 5 ++ .../iluwatar/factory/method/ElfWeapon.java | 9 ++- .../iluwatar/factory/method/OrcWeapon.java | 9 ++- .../com/iluwatar/factory/method/Weapon.java | 6 +- .../com/iluwatar/factory/method/AppTest.java | 19 ----- .../factory/method/FactoryMethodTest.java | 79 +++++++++++++++++++ 6 files changed, 99 insertions(+), 28 deletions(-) delete mode 100644 factory-method/src/test/java/com/iluwatar/factory/method/AppTest.java create mode 100644 factory-method/src/test/java/com/iluwatar/factory/method/FactoryMethodTest.java diff --git a/factory-method/pom.xml b/factory-method/pom.xml index 0d1e435f9..97c1c5681 100644 --- a/factory-method/pom.xml +++ b/factory-method/pom.xml @@ -14,5 +14,10 @@ junit test + + org.mockito + mockito-core + test + diff --git a/factory-method/src/main/java/com/iluwatar/factory/method/ElfWeapon.java b/factory-method/src/main/java/com/iluwatar/factory/method/ElfWeapon.java index d2f38bc48..b0ff33f2b 100644 --- a/factory-method/src/main/java/com/iluwatar/factory/method/ElfWeapon.java +++ b/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; + } } diff --git a/factory-method/src/main/java/com/iluwatar/factory/method/OrcWeapon.java b/factory-method/src/main/java/com/iluwatar/factory/method/OrcWeapon.java index 48cd9c5a3..e1ec0f560 100644 --- a/factory-method/src/main/java/com/iluwatar/factory/method/OrcWeapon.java +++ b/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; + } } diff --git a/factory-method/src/main/java/com/iluwatar/factory/method/Weapon.java b/factory-method/src/main/java/com/iluwatar/factory/method/Weapon.java index a5ae99254..3b9a80f0f 100644 --- a/factory-method/src/main/java/com/iluwatar/factory/method/Weapon.java +++ b/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(); + } diff --git a/factory-method/src/test/java/com/iluwatar/factory/method/AppTest.java b/factory-method/src/test/java/com/iluwatar/factory/method/AppTest.java deleted file mode 100644 index cb48d9ad7..000000000 --- a/factory-method/src/test/java/com/iluwatar/factory/method/AppTest.java +++ /dev/null @@ -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); - } -} diff --git a/factory-method/src/test/java/com/iluwatar/factory/method/FactoryMethodTest.java b/factory-method/src/test/java/com/iluwatar/factory/method/FactoryMethodTest.java new file mode 100644 index 000000000..a6786a717 --- /dev/null +++ b/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. + * + *

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. + *

+ */ +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()); + } +} From 6b99f2669ee2cd57d177f3802b7666449937f97f Mon Sep 17 00:00:00 2001 From: mfarid Date: Sun, 22 Nov 2015 05:47:36 +0530 Subject: [PATCH 5/5] Added capability for test coverage report generation and steps to do so. --- CODE_COVERAGE.md | 13 +++++++++++++ pom.xml | 41 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+) create mode 100644 CODE_COVERAGE.md diff --git a/CODE_COVERAGE.md b/CODE_COVERAGE.md new file mode 100644 index 000000000..589c7ad79 --- /dev/null +++ b/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 + + diff --git a/pom.xml b/pom.xml index 4419fb98a..2fc34f661 100644 --- a/pom.xml +++ b/pom.xml @@ -130,6 +130,12 @@ ${junit.version} test + + org.mockito + mockito-core + 1.10.19 + test + log4j log4j @@ -242,6 +248,41 @@ + + + org.jacoco + jacoco-maven-plugin + 0.7.5.201505241946 + + + + prepare-agent + + + + report + prepare-package + + report + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 2.18.1 + + + org.apache.maven.surefire + surefire-junit47 + 2.18.1 + + + + -Xmx1024M ${argLine} + +