Why Unit Test?

"But it was working yesterday..."

Bugs are expensive!

Fail Fast and Early

Configuring Your Project

git clone git@github.com:Mobiquity/AndroidUnitTests.git

Clone the Repository

DEMO!

Running the Tests

Unit Tests

./gradlew testDebugUnitTest

Results are under: app/build/reports/tests/{buildFlavor}/index.html

Running the Tests

Functional Tests

./gradlew connectedDebugAndroidTest

Results are under: app/build/reports/androidTests/connected/index.html

Tests require an emulator or a physical device

Running the Tests

Code Coverage

./gradlew testDebugUnitTestCoverage
./gradlew fullTestDebugUnitTestCoverage

Results are under: app/build/reports/jacoco/{coverageType}/html/index.html

A JUnit Overview

My First Simple Unit Test: Testing Addition

public class AdditionOperator extends Operator {

    public AdditionOperator() {
        super("+", InputType.OPERATOR);
    }

    @Override
    public double execute(double param1, double param2) {
        return add(param1, param2);
    }

    @Override
    public int getPrecedence() {
        return Precedence.ADDITION_PRECEDENCE.getValue();
    }

    @Override
    public boolean isLeftAssociative() {
        return true;
    }

    private double add(double firstAddend, double secondAddend) {
        return firstAddend + secondAddend;
    }
}

• Does the operation add the params correctly?

• Correct precedence?

• Correct operator associativity?

public class AdditionOperatorTest {

    private AdditionOperator additionOperator;

    @Before
    public void setUp() {
        additionOperator = new AdditionOperator();
    }

    ...

    @Test
    public void testGetPrecedence_IsEqualToAdditionPrecedence() {
        assertThat(additionOperator.getPrecedence())
                .isEqualTo(Operator.Precedence.ADDITION_PRECEDENCE.getValue());
    }

    @Test
    public void testShouldBeLeftAssociative() {
        assertThat(additionOperator.isLeftAssociative()).isTrue();
    }

    @Test
    public void testExecute_ShouldAddOperands() {
        assertThat(additionOperator.execute(2,3)).isWithin(5);
        assertThat(additionOperator.execute(0,10)).isWithin(10);
        assertThat(additionOperator.execute(10,-10)).isWithin(0);
        assertThat(additionOperator.execute(-2,-3)).isWithin(-5);
    }
}

@AppScope
public class Calculator {

    private InfixInputParser infixInputParser;
    ...
    @Inject
    public Calculator(InfixInputParser infixInputParser) {
        this.infixInputParser = infixInputParser;
    }

    public double evaluate(Input[] inputs) throws CalculatorEvaluationException {
        try {
            Queue<Input> postfixInputs = infixInputParser.toPostfix(inputs);

            // Return if there are no inputs to evaluate
            if (postfixInputs.isEmpty()) {
                return 0;
            }

            Stack<Double> stack = new Stack<>();
            for (Input input : postfixInputs) {
                switch (input.getType()) {
                    case NUMBER:
                        NumericInput numericInput = (NumericInput) input;
                        stack.push(numericInput.getValue());
                        break;
                    case OPERATOR:
                        Operator operator = (Operator) input;
                        double secondOperand = stack.pop();
                        double firstOperand = stack.pop();

                        double result = operator.isLeftAssociative() ?
                                operator.execute(firstOperand, secondOperand) :
                                operator.execute(secondOperand, firstOperand);

                        stack.push(result);
                        break;

                }
            }

            // prevents calculator from returning -0
            return stack.pop() + 0.0;
        } catch (EmptyStackException | InfixInputParser.InputParserException | NumberFormatException e) {
            throw new CalculatorEvaluationException("Invalid Expression");
        }
    }
}

We need to test that, given postfix input, our calculator returns the correct result.

Testing the Calculator

public Calculator(InfixInputParser infixInputParser) {
    ...
}

We want to test the behavior of the Calculator class, not our InfixInputParser

Mock External Dependencies with Mockito

public class CalculatorTest {

    private Calculator calculator;
    @Mock InfixInputParser infixInputParser;

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        calculator = new Calculator(infixInputParser);
    }
    ...

    // Our tests ...

    private void mockPostFix(Input[] input, Input[] expectedInput) {
        Mockito.when(infixInputParser.toPostfix(input)).thenReturn(
            new LinkedList<>(Arrays.asList(expectedInput))
        );
    }
}

Mocking with Mockito

What does this mean?

If something

Our Calculator Test

@Test
public void testEvaluate_AdditionMultiply() throws Exception {
    //Test: 1 + 2 * 3 = 7

    Input input[] = new Input[]{
            new NumericInput(1),
            new AdditionOperator(),
            new NumericInput(2),
            new MultiplicationOperator(),
            new NumericInput(3)
    };
    double expectedResult = 7;

    // Assume the infix input parser works and provide the correct postfix for the input
    Input[] postfixInput = new Input[] {
            new NumericInput(1),
            new NumericInput(2),
            new NumericInput(3),
            new MultiplicationOperator(),
            new AdditionOperator()
    };
    mockPostFix(input, postfixInput);

    double result = calculator.evaluate(input);
    assertThat(result).isWithin(expectedResult);
}

Infix Input Parser Test

/**
  * Before: 3 + 4 * 5
  * After: 3 4 5 * +
  */
@Test
public void testToPostfix_AdditionMultiplication() {
    Input[] inputs = new Input[] {
            three,
            plus,
            four,
            times,
            five
    };

    Queue<Input> postfixOutput = infixInputParser.toPostfix(inputs);
    assertThat(postfixOutput).containsExactly(three, four, five, times, plus)
            .inOrder();
}

Testing Networking Logic and Callbacks

Our Wolfram Presenter

@AppScope
public class WolframPresenter extends Presenter<WolframView> {

    private WolframService wolframService;

    @Inject
    public WolframPresenter(WolframService wolframService) {
        this.wolframService = wolframService;
    }

    public void startQuery(String query) {
        wolframService.query(query).enqueue(new Callback<WolframResponse>() {
            @Override
            public void onResponse(Call<WolframResponse> call, Response<WolframResponse> response) {
                view().updatePods(response.body().getPods());
            }

            @Override
            public void onFailure(Call<WolframResponse> call, Throwable t) {
                Timber.e(t, t.getMessage());
                view().showWolframFailure();
            }
        });
    }
}

What do we need to do?

Mock the Wolfram Service with Mockito

We should also mock our UI (WolframView)

@Mock(answer = RETURNS_DEEP_STUBS) WolframService wolframService;
@Mock WolframView wolframView;

Argument Captor and Mockito

Use it to capture argument values for further assertions

We can use ArgumentCaptor to

control

our callback path

Testing the Success Case

    @Test
    public void testStartQuery_SuccessfulQuery() {
        wolframPresenter.bind(wolframView);
        wolframPresenter.startQuery(Mockito.anyString());
        Mockito.verify(wolframService.query(Mockito.anyString()))
                .enqueue(responseCaptor.capture());

        responseCaptor.getValue().onResponse(
            Mockito.mock(Call.class), Response.success(mockResponse)
        );
        Mockito.verify(wolframView).updatePods(Mockito.anyList());
    }

Testing the Failure Case

    @Test
    public void testStartQuery_FailedQuery() {
        wolframPresenter.bind(wolframView);
        wolframPresenter.startQuery(Mockito.anyString());
        Mockito.verify(wolframService.query(Mockito.anyString()))
                .enqueue(responseCaptor.capture());

        responseCaptor.getValue().onFailure(
            Mockito.mock(Call.class), Mockito.mock(Throwable.class)
        );
        Mockito.verify(wolframView).showWolframFailure();
    }

Unit testing activities

we can mock android dependencies with robolectric!

This allows us to test classes with android dependencies WITHOUT needing an actual device

Setting up Robolectric

Unit Testing our Calculator Activity

Our CalculatorActivity implements CalculatorView for MVP

Do the methods do what we think?

Set Up the Activity

@RunWith(CustomGradleRunner.class)
public class CalculatorActivityViewTest {

    private CalculatorActivity calculatorActivity;

    @Before
    public void setUp() {
        calculatorActivity = Robolectric.setupActivity(CalculatorActivity.class);
    }
    
    ...
}

    @Test
    public void testUpdateDisplay_ChangesDisplayText() {
        String expectedDisplayText = "1+1";
        calculatorActivity.updateDisplayText(expectedDisplayText);

        assertThat(calculatorActivity.displayInput.getText().toString())
                .isEqualTo(expectedDisplayText);
    }

    @Test
    public void testShowSuccessfulCalculation_ChangesResultText() {
        String expectedResultText = "12";
        calculatorActivity.showSuccessfulCalculation(expectedResultText);

        assertThat(calculatorActivity.resultText.getText().toString())
                .isEqualTo(expectedResultText);
    }

Testing our CalculatorView methods in isolation

With Robolectric and Mockito, you can mock dependencies and test your components in isolation!

+

Functional Testing

Now That We Have tested the Components in Isolation...

We need to test the behavior of the app as a 

whole

What is Espresso?

Configuration

defaultConfig {
    testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}

dependencies {
    androidTestCompile "com.android.support.test.espresso:espresso-core:2.2.1",
    androidTestCompile "com.android.support.test.espresso:espresso-intents:2.2.1"
    androidTestCompile ("com.android.support.test.espresso:espresso-contrib:2.2.1") {
        exclude module: 'support-annotations'
        exclude module: 'gridlayout-v7'
        exclude module: 'recyclerview-v7'
        exclude module: 'support-v4'
    }
}

configurations.all {
    resolutionStrategy {
        force "com.android.support:support-annotations:23.3.0"
    }
}

Espresso recommends disabling animations for tests

Simulating User Input with Espresso

https://google.github.io/android-testing-support-library/docs/espresso/cheatsheet/

Android Test Rules 

Make use of the JUnit @Rule annotation

@Rule
public ActivityTestRule<CalculatorActivity> activityRule = new ActivityTestRule<>(CalculatorActivity.class);

Calculator Activity Functional Test

@RunWith(AndroidJUnit4.class)
public class CalculatorActivityTest {

    @Rule
    public ActivityTestRule<CalculatorActivity> activityRule = new ActivityTestRule<>(CalculatorActivity.class);

    @Rule
    public DisableAnimationsRule disableAnimationsRule = new DisableAnimationsRule();

    @Test
    public void shouldConcatNumberInput() {
        onView(withId(R.id.digit_1)).perform(click());
        onView(withId(R.id.add_op)).perform(click());
        onView(withId(R.id.digit_1)).perform(click());
        onView(withId(R.id.digit_2)).perform(click());
        onView(withId(R.id.display_input)).check(matches(withText("1+12")));
    }

    ...

}

Ex: Test that numbers are displayed correctly when the user types on the calculator