JUnit using only annotations

To be honest I tried annotations with JUnit recently, but the first time I tried, it didn't go well, so I procrastinate it.
But for this "experimento", I'd to retake it with excellent results
, and this is one of test cases [I had to create a base TestCase class - you know how lazy I'm:) to avoid the process of loading my context and Log4J]
Don't forget my "golden rule", use Maven!!! I'm using JUnit 4.8
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = { "file:src/main/webapp/WEB-INF/conf/spring/daoApplicationContext.xml", "file:src/main/webapp/WEB-INF/conf/spring/serviceApplicationContext.xml" }) public abstract class BaseTestCase { static{ DOMConfigurator.configure("src/main/webapp/WEB-INF/conf/log4j/log4j-config-minimal.xml"); } } } As you can see, there isn't too much to explain. Only we're using "SpringJUnit4ClassRunner.class", because to do my tests I need my Spring App Context (with all my beans)

This is a portion of my test case public class TestCustomerService extends BaseTestCase { private static final Logger log = Logger .getLogger(TestCustomerService.class); @Autowired private ICustomerService customerService; @BeforeClass public static void executeBeforeClass() { log.info("Execute to inizitalize class with @BeforeClass"); } @AfterClass public static void executeAfterClass() { log.info("Execute to finalize class with @AfterClass"); } @After public void executeAfter() { log.info("This should be executed after each method with @After"); } @Before public void executeBefore() { log.info("This should be executed before each method with @Before"); } } I haven't used much the annotations Before and After, but some day I'll find them an application.

Something really cool is the part where we can define if my test method will be Transactional, if we want to Repeat it or if after test is executed we want to Rollback the Tx.
Because, for a regular Test, just with the annotation @Test will be enough. @Test public void testGetAllCreditCards() { log.info("Starting test - testGetAllCreditCards"); List<CreditCardDTO> result = null; try { result = this.customerService.getAllCreditCards(1); } catch (Exception ex) { ex.printStackTrace(); } Assert.assertNotNull(result); log.debug(result); log.info("End of test - testGetAllCreditCards"); } @Test public void testDoSignIn() { log.info("Starting test - testDoSignIn"); CustomerDTO result = null; try { result = this.customerService.doSignIn("juca.cruz@gmail.com","contraseña"); } catch (Exception ex) { ex.printStackTrace(); } Assert.assertNotNull(result); log.debug(result); log.info("End of test - testDoSignIn"); }
I felt in love with these annotations, because finally I don't have to load the a test Database and Clean it after my testing is done (I know, you still have to re initiate the sequences, but who cares, they're UNIQUE), I can reuse my existing initial DB and play with it, and nobody will see my garbage/testing data; unless I want it
@Test @Transactional @Rollback @Repeat(2) public void testAddUpdatePaymentInformation() { log.info("Starting test - testAddUpdatePaymentInformation"); Boolean result = false; CustomerDTO customerDTO = new CustomerDTO(); customerDTO.setIdCustomer(RandomUtils.JVM_RANDOM.nextInt(2)); CreditCardDTO creditCardDTO = new CreditCardDTO(); creditCardDTO.setCustomerDTO(customerDTO); creditCardDTO.setExpirationDate(DateUtils.formatDate(new java.util.Date(), DateUtils.FORMAT_MMYYYY)); creditCardDTO.setNumber(RandomStringUtils.randomNumeric(16)); creditCardDTO.setSecurityCode(RandomStringUtils.randomNumeric(3)); this.populateCreditCardType(creditCardDTO); try { result = this.customerService.addUpdatePaymentInformation(creditCardDTO); } catch (Exception ex) { ex.printStackTrace(); } Assert.assertTrue(result); log.debug(result); log.info("End of test - testAddUpdatePaymentInformation"); }

 
@Transactional  --> There is a Tx involved on this test
@Rollback  --> When is done (rollback Tx)
@Repeat(2)  --> Repeat 2 Times this execution

That's what I'm talking about!!!
¡JUnit Rules!