JUnit has been refined over time. Mockito tastes really well. Spring is very refreshing.
dirty-mockito, on the other hand is not for everybody. Nevertheless, we hope some of you might like it.
dirty-mockito 0.2.3 released
This is just a minor revision that basically 'reverts' to the old-style @Before mocking and instantiation in ActiveTest. This is to 'workaround' the fact that in JUnit 4.7, test @Before methods run before @Rules. This release will once again ensure that mocked/instantiated fields will be accessible in @Before methods.
The next release of JUnit will execute @Rules before @Before methods, which will let ActiveTest use the ActiveTestInterceptor as a proper @Rule once more.
Also, we now only register a PersistenceContextBeanPostProcessor if an EntityManager has been @Mocked. That is, it allows you to write a test for a class that contains a @PersistenceContext even if your test does not declare a @Mock EntityManager. Of course, it'll be up to you to provide the rest of the dependencies. For example,
public class WidgetServiceTest extends ActiveTest<WidgetService> {
@Mock
private WidgetDao widgetDao;
private WidgetService widgetService;
@Before
public void setMockDaoManually() {
widgetService.setWidgetDao(widgetDao);
}
...Will now work properly, whereas before Spring would complain open seeing a @PersistenceContext annotation (in WidgetService) that an EntityManager or EntityManagerFactory was not registered.
dirty-mockito 0.2.2 now supports mock EntityManager injection to JPA DAOs
dirty-mockito 0.2.2 has just been released. This version adds transparent support for JPA data access objects (DAO), using various Spring bean post-processors and an internal, custom EntityManagerFactory.
JPA DAO classes can be written three ways:
Using JPA @PersistenceContext
It is possible to declare a Java EE 5 style DAO as follows:
public class WidgetDao {
@PersistenceContext
private EntityManager em;
...Using constructor injection
public class WidgetDao {
private final EntityManager em;
public WidgetDao(EntityManager em) {
this.em = em;
}
...Using Spring JpaDaoSupport-derived classes
public class WidgetDao extends JpaDaoSupport {
...Announcing dirty-mockito 0.2
dirty-mockito 0.2 has been released. This version upgrades dirty-mockito dependencies to JUnit 4.7 and Mockito 1.8.0.
dirty-mockito 0.2 has been rewritten to take advantage of JUnit's interceptors (@Rules). For more information about JUnit interceptors, read Kent Beck's blog entry or JUnit 4.7's release notes.
Now, to write a JUnit test with Mockito mock objects and Spring bean autowiring you don't have to extend ActiveTest. Your unit test can now be a POJO (or descend from any other base class) and you just need to use an ActiveTestInterceptor, like so:
public class WidgetTest {
@Rule
public ActiveTestInterceptor<Widget> interceptor =
ActiveTestInterceptor.thatWorksOn(Widget.class);
// ...Usage
To use dirty-mockito in your Maven projects, simply add the following to the appropriate sections of your pom.xml:
<project>
<dependencies>
<dependency>
<groupId>dirty-mockito</groupId>
<artifactId>dirty-mockito</artifactId>
<version>0.2.2</version>
<scope>test</scope>
</dependency>
</dependencies>
<repositories>
<repository>
<id>dirty-mockito</id>
<url>http://dirty-mockito.googlecode.com/svn/maven2/releases</url>
</repository>
</repositories>
</project>Disclaimer
dirty-mockito is NOT affiliated with the Mockito project, NOR with the JUnit project, NOR the Spring Framework project.