Testing in Android

Question 1

Why Unit Tests?

Answer 1

• are good documentation
• reduce bugs in new and existing features
• allow refactoring (no fear of breaking existing code-> so you can constantly improve the program)
• reduce fear

Question 2

Categories of tests in Android

Answer 2

Local Unit Tests

Instrumented Test

Question 3

Local Unit Tests

Answer 3

• Run on your machine’s local JVM
• Used when :
  
  • No Android Framework dependecies
  • You can mock the android dependecies

Question 4

Intrumented Tests

Answer 4

• Run on a hardware edvice or emulator
• Give you acces to info such as the Context
• Used when you write Integration and Functional UI tests to automate User Interaction.

Question 5

What is a Unit Test?

Answer 5

A unit test verifies in isolation the functionality of a certain component.

Question 6

Mocking dependecies

Answer 6

It might happen that a class eg.Presenter doesn’t stand in isolation- it also requires a View that updates UI and a Repository, where data is stored.

We dont care about the concrete impleemntation of the View and Repository, at this point, we only want to make sure that Presenter behaves as expected.

So, instead of relying on actual implementations of these dependecies we can use Mock Objects to test our class.

Mocking is creating objects that simulate the behaviour of real objects

One popular framework for mocking on Android is MOCKITO.

Question 7

Mockito

Answer 7

Mockito uses RUNTIME CODE GENERATION techniques to build implementations of mocks.

For ex:
ArrayList mock = mock(ArrayList.class)

Mockito is building a new generatoed class that extends ArrayList, but has 'mock' implementation that can be configured by you. 
When your Java process running the test exits, the generated types vanish. They live, only at runtime.

Question 8

Test doubles

Answer 8

Test double is a generic term used for indicating some kind of dependency substitution for the test purposes
Test doubles are:
- STUB uses STATE verification while
- MOCK uses BEHAVIOR verification.
- SPY is a STUB, that use BEHAVIOR verification

Question 9

Difference between Mock and Stub

Answer 9

WHAT IS and WHEN TO USE MOCK?

• A mock is a simulation of an object, used to replacing a dependency, they are programmed with expectations.
• Used to verify object behaviour during a test (ex. if are called corect methods)

WHAT IS and WHEN TO USE STUB?

• Stub is a hand-written class that mimic the dependency’s behavior, but do that with significant shortcuts, to help with testing.
• You can use them to replace problematic pieces of code (for ex. 1. stub a database by implemented a simple structure for storing some data, SO we no longer need an actual database for our test 2. avoid making actual requests to a server from tests);

WHEN TO USE SPY?

• Spy object is a partial mock, diferece is that a spy guaratess that real methods are called.
• Used to track all interactions with it (many times a function was called, what arguments were passed)

Question 10

Difference between Mock and Spy

Answer 10

• When Mockito creates a mock – it does so from the Class of an Type, not from an actual instance. The mock simply creates a bare-bones shell instance of the Class, entirely instrumented to track interactions with it.
• The Spy will wrap an existing instance. It will still behave in the same way as the normal instance – the only difference is that it will also be instrumented to track all the interactions with it.

Question 11

Example

Answer 11

@Mock
Dependecy mockDep;
ObjUnderTest objUnderTest;

@Before
init(){
    objUnderTest = new ObjUnderTest(); // real instance
    MockitoAnnotations.initMocks(this);
}

@Test
testSomething(){   
    objUnderTest.testSomething();
    verify(mockDep).methodToBeCalled();
}

Question 12

UI Testing Android

Answer 12

UI Automator - allows many system stuff, as example turn on/off wifi, notification, access to any application

Espresso -allows you test many things inside your application, simulating user interactions.

Question 13

Steps to manually test UI with Espresso

Answer 13

1. Match the view (ViewMatcher offers withId, withText ..)
2. Act on the view (ViewAction offers click, doubleclick..)
3. Check if what happened matches what we expected
   (ViewAssertion matches, isDisplay(), isBelow())

onView(ViewMatcher)
.perform(ViewAction)
.check(ViewAssertion);