Do you program or do you already TDD? đ
If you prefer to do TDD you will love the eclipse plug-in called MoreUnit. It is as simple as powerful. All it does is executing tests from corresponding productive class and makes it very simple to change between them.
Just press Ctrl-J (like Jump) to jump from test to implementing class and the other way. Or press Ctrl-R (like Run) to run the test regardless if you are in the test or the implementation class.
Configuration
There are just a few things you have to configure. I recommend to remove the prefix for tests because I name test classes like the original name with the suffix test.
Find classes with different names
If you have more than one test class for an implementation you prefer to decide into which test to jump. If you like this enable the option âEnable flexible naming of testsâ. (At beginning I could not imagin who could have like this but since a short time I use it very intensive)
Mocks
There is a experimental feature to create mocks for dependencies. If you have a class which has a constructor to get some configurations MoreUnit is able to create initializing our testee with a mock. I tried it with mockito as mocking framework. My sample is a simple class which takes an object of type Param to be configured.
public class Feature { private final Param param; public Feature(final Param param) { this.param = param; } public void create() { System.out.println(param); } } public interface Param { }
While creating the test with MoreUnit (just press Ctrl-J in the Feature class) it will as us in the second step of creation wizard which dependencies should be mocked.
As you can see I selected the constructor which takes an instance of Param. I donât select any method to create a test method for it. So it will create a test class like this:
@RunWith(MockitoJUnitRunner.class) public class FeatureTest { @Mock private Param param; private Feature feature; @Before public void createFeature() throws Exception { feature = new Feature(param); } }
In my opinion this is not bad but, Iâd prefere to have the initialisation for mocking within the @Before method and not with the @RunWith. Because sometimes I have other JUnit runners like the Parameterized.class. So I have to remove the @RunWith and add the âMockitoAnnotations.initMocks(this);â. So the test will look like this:
public class FeatureTest { @Mock private Param param; private Feature feature; @Before public void createFeature() throws Exception { MockitoAnnotations.initMocks(this); feature = new Feature(param); } }
You might say: âIf I have to do so much I just can write it on myselfâ. Nearly right. Imagin you have more than just one parameter. MoreUnit will create all the members with corresponding Annotations. There are some problems with the current version (2.4.2). Creating the mocks in an already existing test will have the result there is a second member for the unit under test and if the annotation @RunWith is already on the class it will be added twice. So it will be very helpful while creating a new test but not very comfortable if the test is existing and contains mocks.
Where to find
http://moreunit.sourceforge.net
Update-Site: http://moreunit.sourceforge.net/update-site
The plugin should also be available in the Eclipse Marketplace. Just search for âmoreunitâ
I think it is a very helpful tool if you will program with TDD. Because it helps you to change between implementation an test very quick. (Yes, much faster than Ctrl-F6, try it đ )