Unit Tests

The Good, the Bad and the Ugly

Michał Urbanek

What is it not about?

• Integration testing
• UI testing 
• Acceptance testing
• Smoke and sanity testing
• Security testing
• Stress testing
• ...

What is it about then?

Benefits of having UT

Good Unit Tests

• trustworthy
• maintainable
• readable

Trustworthy

• test the right thing
• make it easy to run
• run them often
• failure == problem

Piece of cake?

Obvious, right?

• Always see the failing test first
• Keep your tests independent from each other - enforce test isolation
• Clean the environment before tests, not afterwards ​
• DRY = reuse test code

Naming

Structure

public void shouldCreateUserStoreUserInDatastoreAndPersistAllFields() {
    // given
    User user = new User(id)
    
    // when
    user.save()
    
    // then
    assertThat(User.get(id)).isEqualTo(user)
}

KISS

• No logic in tests! Even the simplest will be evil! 
• test logic == test bugs
• No ifs or switches
• Only
  • create/configure
  • act
  • assert

What to test?

• Write tests which make you confident that your system works 
• Test everything that can possibly break! 
• When your code evolves, take care that your
  tests also evolve 

• Single Responsibility Principle (avoid multiple asserts)
  "Each test method should verify just one scenario". 

• Test only public methods
  "Separate the business scenario from low-level details"
• Or even better
  "Test Behaviour Not Methods!"

What to test?

The rules are there

Assertions

• standard JUnit
• Hamcrest
• FEST assertions/AssertJ

AssertJ

// unique entry point to get access to all assertThat methods and utility methods
import static org.assertj.core.api.Assertions.*;

• rich and easy to use
• customizable
• support for guava/joda

AssertJ

// common assertions
assertThat(frodo.getName()).isEqualTo("Frodo");
assertThat(frodo).isNotEqualTo(sauron)
                 .isIn(fellowshipOfTheRing);
assertThat(sauron).isNotIn(fellowshipOfTheRing);

// String specific assertions
assertThat(frodo.getName()).startsWith("Fro")
                           .endsWith("do")
                           .isEqualToIgnoringCase("frodo");

AssertJ

// collection specific assertions
assertThat(fellowshipOfTheRing).hasSize(9)
                               .contains(frodo, sam)
                               .doesNotContain(sauron);

// extract properties
assertThat(fellowshipOfTheRing).extracting("name").contains("Boromir", "Gandalf", "Frodo")
                                                  .doesNotContain("Sauron", "Elrond");

assertThat(fellowshipOfTheRing).extracting("name", "age", "race.name")
                               .contains(tuple("Boromir", 37, "Man"),
                                         tuple("Sam", 38, "Hobbit"),
                                         tuple("Legolas", 1000, "Elf"));

// map specific assertions
assertThat(ringBearers).hasSize(4)
                       .contains(entry(oneRing, frodo), entry(nenya, galadriel))
                       .containsEntry(narya, gandalf)
                       .doesNotContainEntry(oneRing, aragorn);

AssertJ

• Assertions on results of method call on iterable
• Collect all errors with Soft assertions
• Using String assertions on the content of a file
• Filtering a group of objects before making assertions
• Reflection based assertions

Readable assertions

@Test
public void testChargeInRetryingState() throws Exception {
    // given
    TxDTO request = createTxDTO(RequestType.CHARGE);
    AndroidTx androidTx = ...
    Processor processor = ...
    ... much more complex set-up code here

    // when
    final TxDTO txDTO = processor.processRequest(request);

    // then
    assertEquals(txDTO.getResultCode(), ResultCode.SUCCESS);
    final List<AndroidTxStep> steps = new ArrayList<AndroidTxStep>(
            androidTx.getTxSteps());
    final AndroidTxStep lastStep = steps.get(steps.size() - 1);
    assertEquals(lastStep.getTxState(),
        AndroidTxState.CHARGE_PENDING);
    assertEquals(lastStep.getMessage(), ClientMessage.SUCCESS);
    ... some more assertions here
}

Readable assertions

@Test
public void invalidTxShouldBeCanceled() {
 ... some complex test here
 // then
 String fileContent =
        FileUtils.getContentOfFile("response.csv");
 assertTrue(fileContent.contains("CANCEL,123,123cancel,billing_id_123_cancel,SUCCESS,"));
}

@Test
public void invalidTxShouldBeCanceled() {
  ... some complex test here
  // then
  String fileContent =
        FileUtils.getContentOfFile("response.csv");
  TxDTOAssert.assertThat(fileContent).hasTransaction("123cancel").withResultCode(SUCCESS);
}

VS

Not enough tests

public class FizzBuzzTest {
    @Test
    public void testMultipleOfThreeAndFivePrintsFizzBuzz() {
        assertEquals("FizzBuzz", FizzBuzz.getResult(15));
    } 
    @Test
    public void testMultipleOfThreeOnlyPrintsFizz() {
        assertEquals("Fizz", FizzBuzz.getResult(93));
    }
    @Test
    public void testMultipleOfFiveOnlyPrintsBuzz() {
        assertEquals("Buzz", FizzBuzz.getResult(10));
    }
    @Test
    public void testInputOfEightPrintsTheNumber() {
        assertEquals("8", FizzBuzz.getResult(8));
    }
}

Name variables

Avoid magic numbers/strings
(use constants with meaningful names)

@DataProvider
public static Object[][] userPermissions() {
    return new Object[][]{
        {"user_1", READ},
        {"user_2", READ},
        {"user_2", WRITE},
        {"user_3", READ},
        {"user_3", WRITE},
        {"user_3", DELETE}
    };
}

Expect exception anywhere

@Test(expected=IndexOutOfBoundsException.class)
public void testNegative() {
    MyList<Integer> list = new MyList<Integer>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(3);
    list.add(4);
    list.get(-1);
}

Creation of objects

@Before
public void initialize() {
    User user = new User("email@example.com", "Example", "Example", "qwerty",
        "Europe/Warsaw", UserState.NOT_VERIFIED, new Address());
    ... 
}
@Test
public void shouldCommitTransaction() {
    User user = new User("firstName", "lastName", "password",
        "email@example.com", "qwerty", UserState.ACTIVE, new Address());
    user.setRegistrationDate(oneDayAgo.toDate());
    user.setAccessCode("qwerty");
    ...
}
@Test
public void shouldGetUserByCompanyData() {
    User user = new User("email", "FirstName", "LastName", "Password",
        "Europe/Warsaw", UserState.ACTIVE, address);
    user.setRegistrationDate(new Date());
    user.setCompany(company);
    user.setAccessCode("Access Code");
    ...
}

MockServer server = new MockServer(responseMap, true,
        new URL(SERVER_ROOT).getPort(), false);

Creation of objects

@Test
public void shouldAddTimeZoneToModelAndView() {
    //given
    Context context = mock(Context.class);
    ModelAndView modelAndView = mock(ModelAndView.class);
    given(context.getTimezone()).willReturn("timezone X");

    //when
    new UserDataInterceptor(context)
        .postHandle(null, null, null, modelAndView);

    //then
    verify(modelAndView).addObject("timezone", "timezone X");
}

// argument matchers
verify(mock).someMethod(anyInt(), anyString(), eq("third argument"));

// verify number of interactions
verify(mockedList, times(2)).add("twice");
verify(mockedList, never()).add("never happened");
verify(mockedList, atLeastOnce()).add("three times");
verify(mockedList, atLeast(2)).add("five times");
verify(mockedList, atMost(5)).add("three times");

// stub method to throw an exception
doThrow(new RuntimeException()).when(mockedList).clear();

// verify in order
List singleMock = mock(List.class);
InOrder inOrder = inOrder(singleMock);
inOrder.verify(singleMock).add("was added first");
inOrder.verify(singleMock).add("was added second");

//verify no interaction
verifyZeroInteractions(mockedObject);

import static org.mockito.BDDMockito.*;

Seller seller = mock(Seller.class);
Shop shop = new Shop(seller);
 
public void shouldBuyBread() throws Exception {
  //given
  given(seller.askForBread()).willReturn(new Bread());

  //when
  Goods goods = shop.buyBread();

  //then
  assertThat(goods, containBread());
}

Mocks Are Good 

@Test
public void shouldGetTrafficTrend() {
    //given
    TrafficTrendProvider trafficTrendProvider
            = mock(TrafficTrendProvider.class);
    Report report = new Report(null, "", 1, 2, 3,
            BigDecimal.ONE, BigDecimal.ONE, 1);
    TrafficTrend trafficTrend = new TrafficTrend(report, report,
            new Date(), new Date(), new Date(), new Date());
    given(trafficTrendProvider.getTrafficTrend()).willReturn(trafficTrend);
    TrafficService service = new TrafficService(trafficTrendProvider);

    //when
    TrafficTrend result = service.getTrafficTrend();

    //then
    assertThat(result).isEqualTo(trafficTrend);
}

Jersey Test Framework

public class SimpleTest extends JerseyTest {

    @Path("hello")
    public static class HelloResource {
        @GET
        public String getHello() {
            return "Hello World!";
        }
    }
 
    @Override
    protected Application configure() {
        return new ResourceConfig(HelloResource.class);
    }
 
    @Test
    public void test() {
        final String hello = target("hello").request().get(String.class);
        assertEquals("Hello World!", hello);
    }
}

grizzly vs in memory

Jersey Test Framework

@RunWith(MockitoJUnitRunner.class)
public class TrackerFacadeTest extends BaseFacadeTest {

    @Override
    protected Object facadeInstance() {
        return trackerFacade;
    }


    @Test
    public void shouldCallBee7ServiceAndReturnNoContent() {
        // given
        MultivaluedMap<String, String> params = new Bee7ConversionParamsBuilder() //
                .advertisingId("adid") //
                .app(App.ANDROID_MY_TALKING_TOM) //
                .countryCode("CN") //
                .platform(Platform.ANDROID) //
                .timestamp(123L) //
                .build();
    
        // when
        ClientResponse response = resource()
                                    .path(CONVERSION_PATH)
                                    .queryParams(params)
                                    .get(ClientResponse.class);
    
        // then
        assertThat(response.getStatus(), is(Response.Status.NO_CONTENT.getStatusCode()));
        // verify that bee7Service was really called
    }
}

WebStub

private void mockJerseyClient() {
    Client client = mock( Client.class );
    WebResource webResource = mock( WebResource.class );
    WebResource.Builder builder = mock( WebResource.Builder.class );
 
    ClientResponse clientResponse = mock( ClientResponse.class );
    when( builder.get( ClientResponse.class ) ).thenReturn( clientResponse );
    when( clientResponse.getEntity( String.class ) ).thenReturn( "true" );
    when( webResource.accept( anyString() ) ).thenReturn( builder );
    when( client.resource( anyString() ) ).thenReturn( webResource );
}

@Test
public void testWithAtomicPseudoClosure() {
    await()
        .atMost(10, SECONDS)
        .untilCall(
            to(userRepository).size(), equalTo(3));
}

private AtomicInteger atomic = new AtomicInteger(0);

@Test
public void testWithAtomicNumber() {
    await()
        .untilAtomic(atomic, equalTo(1));
}

Awaitility

Doing things the right way takes more time than doing them any old way.

But this extra effort usually pays off in the long term. 

Things to Remember

Hard to write a test?

Maybe the production code is of low quality?

...or maybe you should consider writing tests before production code?

Things to Remember

Things to Remember

Be pragmatic, and let experience be your guide.

It doesn’t matter if someone advises you to employ some technique or other.

If it doesn’t work for you, simply don’t do it!    

References

• http://joel-costigliola.github.io/assertj/
• http://code.google.com/p/catch-exception/ 
• https://code.google.com/p/junitparams/ 
• https://code.google.com/p/mockito/
• https://code.google.com/p/awaitility/
• https://github.com/tusharm/WebStub

• Lasse Koskela "Effective Unit Testing"
• Tomasz Kaczanowski "Practical Unit Testing"

• Tomasz Kaczanowski "Bad Tests, Good Tests"