Testable Android Apps DroidCon Italy 2015

Testable Android Apps
Fabio Collini

DroidCon Italy – Torino – April 2015 – @fabioCollini 2
Fabio Collini
@fabioCollini
linkedin.com/in/fabiocollini
Folder Organizer
cosenonjaviste.it
nana bianca
Freapp
instal.com
Rain tomorrow?

Quick survey
Do you write automated tests?

Return of Investment - ROI
Net profit
Investment

Agenda
1. Legacy code
2. Dependency Injection
3. Mockito
4. Dagger
5. Dagger & Android
6. Model View Presenter

TestableAndroidAppsDroidCon15
https://github.com/fabioCollini/

DroidCon Italy - Torino - April 2015 - @fabioCollini
1Legacy code

Legacy code
Edit and pray
Vs
Cover and modify
Legacy code is code
without unit tests

Instrumentation tests
run on a device (real or emulated)
high code coverage
Vs
JVM tests
fast
low code coverage

Espresso
public class PostListActivityTest {
//see https://gist.github.com/JakeWharton/1c2f2cadab2ddd97f9fb 
@Rule 
public ActivityRule<PostListActivity> rule =
new ActivityRule<>(PostListActivity.class); 
 
}
@Test public void showListActivity() { 
onView(withText("???"))
.check(matches(isDisplayed())); 
} 
@Test public void showErrorLayoutOnServerError() { 
//??? 
onView(withId(R.id.error_layout))
.check(matches(isDisplayed()));
}

Legacy code dilemma
When we change code,
we should have tests in place.
To put tests in place,
we often have to change code.
Michael Feathers

TestablePostListActivity
public class TestablePostListActivity
extends PostListActivity { 
 
public static Observable<List<Post>> result; 
 
@Override
protected Observable<List<Post>> createListObservable() { 
return result; 
} 
}

PostListActivityTest
public class PostListActivityTest {
 
@Rule public ActivityRule<TestablePostListActivity> rule =
new ActivityRule<>(
TestablePostListActivity.class,
false
); 
 
@Test public void showListActivity() { 
TestablePostListActivity.result = Observable.just( 
createPost(1), createPost(2), createPost(3) 
).toList(); 
 
rule.launchActivity(); 
 
onView(withText("title 1”))
}

@Test public void checkErrorLayoutDisplayed() { 
TestablePostListActivity.result =
Observable.error(new IOException()); 
 
 
}

Legacy code
Not the perfect solution
First step to increase coverage
Then modify and refactor

2Dependency Injection

PostBatch
public void execute() { 
PostResponse postResponse = createService().listPosts(); 
EmailSender emailSender = new EmailSender(); 
 
List<Post> posts = postResponse.getPosts(); 
for (Post post : posts) { 
emailSender.sendEmail(post); 
} 
} 
 
private static WordPressService createService() { 
//... 
}

PostBatch
WordPressService
EmailSender
Class under test
Collaborator
Collaborator

PostBatchTest
public class PostBatchTest { 
 
private PostBatch postBatch = new PostBatch(); 
 
@Test 
public void testExecute() { 
postBatch.execute(); 
//??? 
} 
}

Inversion Of Control
private WordPressService wordPressService; 
 
private EmailSender emailSender; 
 
public PostBatch(WordPressService wordPressService,
EmailSender emailSender) { 
this.wordPressService = wordPressService; 
this.emailSender = emailSender; 
} 
 
public void execute() { 
PostResponse postResponse = wordPressService.listPosts(); 
List<Post> posts = postResponse.getPosts(); 
for (Post post : posts) { 
emailSender.sendEmail(post); 
} 
}

Dependency Injection
public class Main { 
 
public static void main(String[] args) { 
new PostBatch(
createService(), new EmailSender()
).execute(); 
} 
 
private static WordPressService createService() { 
//... 
} 
}

WordPressServiceStub
public class WordPressServiceStub
implements WordPressService { 
 
private PostResponse postResponse; 
 
public WordPressServiceStub(PostResponse postResponse) { 
this.postResponse = postResponse; 
} 
 
@Override public PostResponse listPosts() { 
return postResponse; 
} 
}

EmailSenderSpy
public class EmailSenderSpy extends EmailSender { 
 
private int emailCount; 
 
@Override public void sendEmail(Post p) { 
emailCount++; 
} 
 
public int getEmailCount() { 
return emailCount; 
} 
}

PostBatch
WordPressService
EmailSender
Stub
Spy

Test doubles
private PostBatch postBatch; 
 
private EmailSenderSpy emailSenderSpy; 
 
private WordPressServiceStub serviceStub;
@Test 
assertEquals(3, emailSenderSpy.getEmailCount()); 
}
@Before public void init() { 
emailSenderSpy = new EmailSenderSpy(); 
serviceStub = new WordPressServiceStub(
new PostResponse(new Post(), new Post(), new Post())
); 
postBatch = new PostBatch(serviceStub, emailSenderSpy); 
}

3Mockito

Mockito
private WordPressService service; 
private PostBatch postBatch; 
@Before public void init() { 
emailSender = Mockito.mock(EmailSender.class); 
service = Mockito.mock(WordPressService.class); 
postBatch = new PostBatch(service, emailSender); 
}
@Test public void testExecute() { 
when(service.listPosts()).thenReturn(
new PostResponse(new Post(), new Post(), new Post())); 
 
 
verify(emailSender, times(3)).sendEmail(any(Post.class)); 
}
ArrangeActAssert

@InjectMocks
@RunWith(MockitoJUnitRunner.class) 
public class PostBatchTest { 
 
@Mock WordPressService service; 
 
@Mock EmailSender sender; 
 
@InjectMocks PostBatch postBatch; 
 
@Test 
when(service.listPosts()).thenReturn(
new PostResponse(new Post(), new Post(), new Post())); 
 
 
verify(sender, times(3)).sendEmail(any(Post.class)); 
} 
}

4Dagger

Dagger
A fast dependency injector for Android and Java
v1 developed at Square
https://github.com/square/dagger
v2 developed at Google
https://github.com/google/dagger
Configuration using annotations and Java classes
Based on annotation processing (no reflection)

Module
@Module 
public class MainModule {
 
@Provides @Singleton EmailSender provideEmailSender() { 
return new EmailSender(); 
} 
 
@Provides @Singleton WordPressService provideService() { 
//... 
} 
 
@Provides PostBatch providePostsBatch(
WordPressService wordPressService,
return new PostBatch(wordPressService, emailSender); 
} 
}

PostBatch
WordPressService
EmailSender
Component
Main

Component
@Singleton 
@Component(modules = MainModule.class) 
public interface MainComponent { 
PostBatch getBatch(); 
}
public class Main { 
public static void main(String[] args) { 
MainComponent component = DaggerMainComponent.create();
PostBatch batch = component.getBatch(); 
batch.execute(); 
} 
}

Inject annotation
public class PostBatch { 
private WordPressService wordPressService; 
 
@Inject public PostBatch(
WordPressService wordPressService,
this.wordPressService = wordPressService; 
this.emailSender = emailSender; 
}
}
public class PostBatch { 
@Inject WordPressService wordPressService; 
@Inject EmailSender emailSender; 
@Inject public PostBatch() { 
} 
}

5Dagger & Android

PostListActivity
WordPressService
ShareActivity
ShareExecutor

ShareExecutor
public class ShareExecutor { 
private Context context;
 
public ShareExecutor(Context context) { 
this.context = context; 
} 
 
public void startSendActivity(String title, String body) { 
Intent intent = new Intent(); 
intent.setAction(Intent.ACTION_SEND); 
intent.putExtra(Intent.EXTRA_TITLE, title); 
intent.putExtra(Intent.EXTRA_TEXT, body); 
intent.setType("text/plain"); 
Intent chooserIntent = Intent.createChooser(intent,
context.getResources().getText(R.string.share)); 
chooserIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(chooserIntent);
} 
}

ApplicationModule
@Module public class ApplicationModule { 
private Application application; 
public ApplicationModule(Application application) { 
this.application = application; 
}
 
@Provides @Singleton WordPressService providesService() { 
//... 
} 
@Provides @Singleton ShareExecutor shareExecutor() { 
return new ShareExecutor(application); 
} 
}

ApplicationComponent
@Singleton
@Component(modules = ApplicationModule.class) 
public interface ApplicationComponent {
 
void inject(PostListActivity activity); 
void inject(ShareActivity activity);
}

Component
PostListActivity
Application
ShareActivity
ShareExecutorWordPressService

Application
public class CnjApplication extends Application { 
 
private ApplicationComponent component; 
 
@Override public void onCreate() { 
super.onCreate(); 
component = DaggerApplicationComponent.builder() 
.applicationModule(new ApplicationModule(this)) 
.build(); 
} 
 
public ApplicationComponent getComponent() { 
return component; 
} 
 
public void setComponent(ApplicationComponent c) { 
this.component = c; 
} 
}

PostListActivity
public class PostListActivity extends ActionBarActivity { 
//... 
 
@Override 
protected void onCreate(Bundle savedInstanceState) { 
super.onCreate(savedInstanceState); 
CnjApplication app =
(CnjApplication) getApplicationContext();
ApplicationComponent component = app.getComponent(); 
component.inject(this); 
 
//... 
} 
//... 
}

Component
PostListActivity
Application
ShareExecutorWordPressService
TestComponent
MockMock
Test

TestModule
@Module 
public class TestModule { 
@Provides @Singleton
ShareExecutor provideShareExecutor() { 
return Mockito.mock(ShareExecutor.class); 
} 
@Provides @Singleton
WordPressService providesWordPressService() { 
return Mockito.mock(WordPressService.class); 
} 
}

TestComponent
@Singleton 
@Component(modules = TestModule.class) 
public interface TestComponent
extends ApplicationComponent { 
void inject(PostListActivityTest test); 
 
void inject(ShareActivityTest test); 
}

public class PostListActivityTest { 
 
 
@Rule public ActivityRule<PostListActivity> rule =
new ActivityRule<>(PostListActivity.class, false); 
@Before public void setUp() { 
TestComponent component =
DaggerTestComponent.create(); 
CnjApplication application =
(CnjApplication) rule.getApplication(); 
application.setComponent(component); 
component.inject(this); 
}
//...

@Test
public void showListActivity() { 
when(wordPressService.listPosts()).thenReturn(
Observable.just(new PostResponse(createPost(1),
createPost(2), createPost(3)))); 
 
 
onView(withText("title 1”))
}

 
@Test
public void showErrorLayoutOnServerError() { 
Observable.error(new IOException("error!"))); 
 
 
}

6Model View Presenter

Model View Presenter
View
Presenter
Model

View Presenter RetrofitService
onClick
update
update(model)
Model
View Presenter RetrofitServiceModel
request
response

View Presenter MockService
perform(click())
update
update(model)
Model
request
response
EspressoTest
View Presenter MockServiceModelEspressoTest
onView
verify
when().thenReturn()
onClick

MockView Presenter MockService
onClick
update
update(model)
Model
request
response
JVM Test
MockView Presenter MockServiceModelJVM Test
verify
verify
assert
when().thenReturn()

View Presenter
init
update(model)
ModelEspressoTest
View Presenter ModelEspressoTest
onView
create

Android Model View Presenter
Activity (or Fragment) is the View
All the business logic is in the Presenter
Presenter is managed using Dagger
Model is the Activity (or Fragment) state
Presenter is retained on configuration change

PostListPresenter JVM Test
public class PostListPresenterTest { 
 
@Mock WordPressService wordPressService; 
 
@Mock PostListActivity view; 
 
private PostListPresenter postListPresenter; 
 
@Before public void setUp() {
SchedulerManager schedulerManager =
new SchedulerManager(
Schedulers.immediate(), Schedulers.immediate());
 
postListPresenter = new PostListPresenter(
wordPressService, schedulerManager
); 
} 
//...

@Test 
public void loadingPosts() {
Observable.just(new PostResponse(new Post(),
new Post(), new Post()))); 
 
PostListModel model = new PostListModel(); 
postListPresenter.setModel(model); 
postListPresenter.resume(view); 
 
assertEquals(3, model.getItems().size()); 
}

@Test 
public void clickOnItem() { 
PostListModel model = new PostListModel(); 
model.setItems(Arrays.asList(
createPost(1), createPost(2), createPost(3))); 
postListPresenter.setModel(model); 
postListPresenter.resume(view); 
 
postListPresenter.onItemClick(1); 
 
verify(view).startShareActivity(
eq("title 2"), eq("name 2 last name 2nexcerpt 2")); 
}

SharePresenter JVM Test
public class SharePresenterTest { 
 
@Mock ShareExecutor shareExecutor; 
 
@Mock ShareActivity view; 
 
@InjectMocks SharePresenter sharePresenter; 
 
@Test public void testValidationOk() {
ShareModel model = new ShareModel(); 
sharePresenter.init(view, model); 
 
sharePresenter.share("title", "body"); 
 
verify(shareExecutor)
.startSendActivity(eq("title"), eq("body")); 
} 
}

TL;DR
Dagger
Mockito
Espresso UI tests
JVM Presenter tests

Thanks for your attention!
Questions?
github.com/fabioCollini/
github.com/google/dagger
mockito.org
cosenonjaviste.it/libri

Testable Android Apps DroidCon Italy 2015

More Related Content

What's hot

Viewers also liked

Similar to Testable Android Apps DroidCon Italy 2015

More from Fabio Collini

Recently uploaded

Testable Android Apps DroidCon Italy 2015