TDAD

TDAD
TEST DRIVEN ANDROID DEVELOPMENT

The Goal
Write Android applications
that will not turn into monsters
in the next few months (years).

The actual goal
Write an Android application to display ﬁrst
generation of Pokemon in a Grid.

Why TDD
Customer/Goal-Centric
Faster FeedbackHigher Acceptance
Avoid Scope Creep
Modulation

What’s Clean Architecture
“The ratio of time spent reading
(code) versus writing is well over
10 to 1 … (therefore) making it
easy to read makes it easier to
write.”
“Write code for your
mates not for the
machine.”

But which (real) architecture?
Model-View-Presenter
Model-View-ViewModel Viper
Model-View-Adapter

Why MVP
Android development is hard.

Why MVP
No architecture enforced by the platform,
no MVC (which sucks anyways) like iOS.

Real MVP Architecture
UI

Activity/
view
Presenter Interactor Repository
API
DB
Android Plain Java/Kotlin

UI

Activity/
view
API
DB
Android Plain Java/Kotlin
Background Thread

UI

Activity/
view
API
DB
Plain Java/Kotlin
Background Thread
Espresso Unit Test
Android

Try to not re-invent the wheel
Retroﬁt
Dagger2
Android-priority-queue v2
EventBus

Try to not re-invent the wheel
Retroﬁt
Dagger2
Android-priority-queue v2
EventBus
http request
dependency injection
job scheduler
communication

Why Kotlin
Can be used with existing Java frameworks and libraries
Costs nothing to adoptCompiles to JVM bytecode
No runtime overhead
Streams & lambdas
Because Lucio is in the room and can’t stand
Java for too long

MVP Architecture
UI

Activity/
view
API
DB
Plain Java/Kotlin
Background Thread
Espresso Unit Test
Android

http://pokeapi.co/api/v2/pokemon/

interface PokemonService { 
@GET("api/v2/pokemon") 
fun listPokemon(@Query("offset") offset: String = "0"): Call<ListPokemonResponse> 
}
class ListPokemonResponse(val count : Int, val results: List<PokemonResponse>)
data class PokemonResponse(val url: String = "", val name: String)
NO TESTS HERE

class PokemonRestClientTest { 
 
lateinit var underTest: PokemonRestClient
 
@Before 
fun setUp() { 
underTest = PokemonRestClientImpl() 
} 
 
@Test 
fun `shouldCallRetrofitClient_andReturnResponse`() { 
} 
}

 
lateinit var underTest: PokemonRestClient
@Mock 
lateinit var pokemons: ListPokemonResponse
 
@Before 
fun setUp() { 
underTest = PokemonRestClientImpl() 
} 
 
@Test 
val result = underTest.listPokemon()
assertEquals(pokemons, result)
} 
}

 
lateinit var underTest: PokemonRestClient 
 
@Mock 
lateinit var service: PokemonService 
 
@Mock 
lateinit var call: Call<ListPokemonResponse> 
 
@Mock 
lateinit var response: Response<ListPokemonResponse> 
 
@Mock 
lateinit var pokemons: ListPokemonResponse 
 
@Before 
fun setUp() { 
Mockito.`when`(service.listPokemon()).thenReturn(call) 
Mockito.`when`(call.execute()).thenReturn(response) 
Mockito.`when`(response.body()).thenReturn(pokemons) 
underTest = PokemonRestClientImpl(service) 
} 
 
@Test 
val result = underTest.listPokemon() 
 
verify(service).listPokemon() 
assertEquals(pokemons, result) 
verifyNoMoreInteractions(service) 
} 
}

interface PokemonRestClient { 
fun listPokemon(offset: String = "0"): ListPokemonResponse 
}

interface PokemonRestClient { 
fun listPokemon(offset: String = "0"): ListPokemonResponse 
}
class PokemonRestClientImpl(val pokemonService: PokemonService) : PokemonRestClient {
 
override fun listPokemon(offset: String): ListPokemonResponse { 
return pokemonService.listPokemon(offset).execute().body() 
}
 
}

class PokemonRepositoryTest { 
 
lateinit var underTest: PokemonRepository 
 
 
@Before 
fun setUp() { 
underTest = PokemonRepositoryImpl() 
} 
 
@Test 
fun `shouldCallServiceListPokemon`() {
} 
}

 
 
@Mock 
lateinit var client: PokemonRestClient 
 
@Before 
fun setUp() { 
underTest = PokemonRepositoryImpl(client) 
} 
 
@Test 
fun `shouldCallServiceListPokemon`() {
underTest.getPokemon() 
verify(client).listPokemon() 
verifyNoMoreInteractions(client) 
} 
}

interface PokemonRepository { 
fun getPokemon() 
}
class PokemonRepositoryImpl(val client: PokemonClient) : PokemonRepository{
 
override fun getPokemon(){ 
client.listPokemon() 
}
 
}

 
val SQUIRTLE = "Squirtle" 
val CHARMENDER = "Charmender" 
val NUMBER_OF_POKEMONS = 2 
 
 
@Mock 
lateinit var client: PokemonClient 
 
@Before 
fun setUp() { 
} 
 
@Test 
fun `shouldReturnPokemonsFromNetwork`() { 
val squirtle = PokemonResponse(name = SQUIRTLE) 
val charmender = PokemonResponse(name = CHARMENDER) 
val pokemonsResponse = ListPokemonResponse(NUMBER_OF_POKEMONS, listOf(squirtle, charmender)) 
Mockito.`when`(client.listPokemon()).thenReturn(pokemonsResponse) 
 
val result = underTest.getPokemon() 
 
assertNotNull(result) 
assertEquals(NUMBER_OF_POKEMONS, result.size) 
assertEquals(SQUIRTLE, result[0].name) 
assertEquals(CHARMENDER, result[1].name) 
} 
}

 
val SQUIRTLE = "Squirtle" 
val CHARMENDER = "Charmender" 
val NUMBER_OF_POKEMONS = 2 
 
@Rule @JvmField var mockitoRule = MockitoJUnit.rule() 
 
 
@Mock 
lateinit var client: PokemonRestClient 
 
@Before 
fun setUp() { 
val squirtle = PokemonResponse(name = SQUIRTLE) 
val charmender = PokemonResponse(name = CHARMENDER) 
val pokemonsResponse = ListPokemonResponse(NUMBER_OF_POKEMONS, listOf(squirtle, charmender)) 
Mockito.`when`(client.listPokemon()).thenReturn(pokemonsResponse) 
} 
 
@Test 
fun `shouldCallPokemonRestClient`() { 
underTest.getPokemon() 
 
verify(client).listPokemon() 
verifyNoMoreInteractions(client) 
} 
 
@Test 
fun `shouldReturnPokemonsFromNetwork`() { 
val result = underTest.getPokemon() 
 
assertNotNull(result) 
assertEquals(NUMBER_OF_POKEMONS, result.size) 
assertEquals(SQUIRTLE, result[0].name) 
assertEquals(CHARMENDER, result[1].name) 
} 
}
Those are Pokemon objects not
PokemonResponse objects

data class Pokemon(val name:String)

data class Pokemon(val name:String)
public class PokemonJava { 
 
private final String name; 
 
public PokemonJava(String name) { 
this.name = name; 
} 
 
public String getName() { 
return name; 
} 
 
@Override 
public boolean equals(Object o) { 
if (this == o) return true; 
if (o == null || getClass() != o.getClass()) return false; 
 
PokemonJava that = (PokemonJava) o; 
 
return name != null ? name.equals(that.name) : that.name == null; 
 
} 
 
@Override 
public int hashCode() { 
return name != null ? name.hashCode() : 0; 
} 
 
@Override 
public String toString() { 
return "PokemonJava{" + 
"name='" + name + ''' + 
'}'; 
} 
}
1 line vs 26 lines

class PokemonRepositoryImpl(val client: PokemonRestClient) : PokemonRepository { 
override fun getPokemon(): List<Pokemon> { 
return client.listPokemon().results.map { Pokemon(it.name) } 
} 
}

} 
}
public class PokemonRepositoryImplJava implements PokemonRepository { 
 
private final PokemonRestClient client; 
 
public PokemonRepositoryImplJava(PokemonRestClient client) { 
this.client = client; 
} 
 
@NotNull 
@Override 
public List<Pokemon> getPokemon() { 
try { 
ListPokemonResponse listPokemonResponse = client.listPokemon().getResults(); 
List<Pokemon> result = new ArrayList<>(listPokemonResponse.getCount()); 
for (PokemonResponse pokemonResponse : listPokemonResponse.getResults()){ 
result.add(new Pokemon(pokemonResponse.getName())); 
} 
return result; 
} catch (IOException e) { 
e.printStackTrace(); 
} 
return null; 
} 
}
5 lines vs 21 lines

class GetPokemonJobTest { 
 
lateinit var underTest: GetPokemonJob 
 
@Mock 
lateinit var params: Params 
 
@Mock 
lateinit var bus: EventBus 
 
@Mock 
lateinit var repository: PokemonRepository 
 
@Before 
fun setUp() { 
underTest = GetPokemonJob(params, repository, bus) 
} 
 
@Test 
fun `shouldCallRepository_andPostEventOnBus`() { 
underTest.onRun() 
 
verify(repository).getPokemon() 
}
}

class GetPokemonJobTest { 
 
 
lateinit var underTest: GetPokemonJob 
 
@Mock 
lateinit var params: Params 
 
@Mock 
 
@Mock 
 
val finishedEventCaptor: ArgumentCaptor<GetPokemonJob.FinishedEvent> =
ArgumentCaptor.forClass(GetPokemonJob.FinishedEvent::class.java) 
val list = arrayListOf(Pokemon("Squirtle"), Pokemon("Bulbasaur")) 
 
@Before 
fun setUp() { 
Mockito.`when`(repository.getPokemon()).thenReturn(list) 
underTest = GetPokemonJob(params, repository, bus) 
} 
 
@Test 
fun `shouldCallRepository_andPostEventOnBus`() { 
underTest.onRun() 
 
verify(bus).postSticky(finishedEventCaptor.capture()) 
assertTrue(finishedEventCaptor.value.success) 
assertEquals(finishedEventCaptor.value.pokemon, list) 
 
verify(repository).getPokemon() 
verifyNoMoreInteractions(repository, bus) 
}
}

class GetPokemonJob(val params: Params?, val repository: PokemonRepository,
val bus: EventBus) : Job(params) { 
 
override fun shouldReRunOnThrowable(throwable: Throwable, runCount: Int,
maxRunCount: Int): RetryConstraint { 
} 
 
override fun onAdded() { 
} 
 
override fun onCancel(cancelReason: Int, throwable: Throwable?) { 
} 
 
override fun onRun() { 
} 
 
}

class GetPokemonJob(val params: Params?, val repository: PokemonRepository,
val bus: EventBus) : Job(params) { 
 
override fun shouldReRunOnThrowable(throwable: Throwable,
runCount: Int, maxRunCount: Int): RetryConstraint { 
return RetryConstraint(false) 
} 
 
override fun onAdded() { 
} 
 
override fun onCancel(cancelReason: Int, throwable: Throwable?) { 
} 
 
override fun onRun() { 
val pokemon = repository.getPokemon() 
bus.postSticky(FinishedEvent(true, pokemon)) 
} 
 
open class FinishedEvent(val success: Boolean,
open val pokemon: List<Pokemon>) 
 
}

class PokemonInteractorImplTest { 
 
 
lateinit var underTest: PokemonInteractor 
 
@Mock 
lateinit var jobManager: JobManager 
 
@Mock 
 
@Mock 
 
var jobCaptor: ArgumentCaptor<GetPokemonJob> =
ArgumentCaptor.forClass(GetPokemonJob::class.java) 
 
@Before 
fun setUp() { 
underTest = PokemonInteractorImpl(jobManager, repository, bus) 
} 
 
@Test 
fun `shouldLaunchGetPokemonJob`() { 
underTest.requestPokemon() 
 
verify(jobManager).addJobInBackground(jobCaptor.capture()) 
assertTrue(jobCaptor.value is GetPokemonJob) 
assertEquals(1, jobCaptor.value.params?.priority) 
assertTrue(jobCaptor.value.params?.isNetworkRequired!!) 
verifyNoMoreInteractions(jobManager) 
 
} 
}

interface PokemonInteractor { 
fun requestPokemon() 
}
class PokemonInteractorImpl(val jobManager: JobManager, 
val repository: PokemonRepository, 
val bus: EventBus) : PokemonInteractor { 
override fun requestPokemon() { 
val params = Params(1).requireNetwork() 
jobManager.addJobInBackground(GetPokemonJob(params, repository, bus)) 
} 
}

class PokemonPresenterImplTest { 
 
lateinit var underTest: PokemonPresenter 
 
@Mock 
lateinit var view: PokemonView 
 
@Mock 
lateinit var interactor: PokemonInteractor 
 
@Before 
fun setUp() { 
underTest = PokemonPresenterImpl(interactor) 
underTest.init(view) 
} 
 
@Test 
fun `shouldRequestPokemon`() { 
underTest.onStart() 
 
verify(interactor).requestPokemon() 
verify(view).showLoading() 
verifyNoMoreInteractions(interactor, view) 
} 
 
}

interface PokemonView{ 
fun showLoading() 
}
interface PokemonPresenter { 
fun init(view: PokemonView) 
 
fun onStart() 
}
class PokemonPresenterImpl(val interactor: PokemonInteractor,
val bus: EventBus) : PokemonPresenter { 
 
 
override fun init(view: PokemonView) { 
this.view = view 
} 
 
override fun onStart() { 
interactor.requestPokemon() 
view.showLoading() 
} 
}

 
 
@Mock 
 
@Mock 
lateinit var event: GetPokemonJob.FinishedEvent 
 
@Mock 
 
@Mock 
 
var list = arrayListOf(Pokemon("Squirtle"), Pokemon("Bulbasaur")) 
 
@Before 
fun setUp() { 
underTest = PokemonPresenterImpl(interactor, bus) 
} 
 
@Test 
fun `shouldShowPokemon_andRemoveEventFromBus`() { 
Mockito.`when`(event.pokemon).thenReturn(list) 
underTest.onPokemonRetrieved(event) 
 
verify(view).hideLoading() 
verify(view).pokemonLoaded(event.pokemon) 
verify(bus).removeStickyEvent(event)
verifyNoMoreInteractions(bus, view) 
} 
}

interface PokemonView{ 
fun showLoading() 
fun hideLoading() 
fun pokemonLoaded(pokemons: List<Pokemon>) 
}
interface PokemonPresenter { 
fun init(view: PokemonView) 
fun onStart() 
fun onPokemonRetrieved(event: GetPokemonJob.FinishedEvent) 
}
class PokemonPresenterImpl(val interactor: PokemonInteractor,
val bus: EventBus) : PokemonPresenter { 
 
 
override fun init(view: PokemonView) { 
this.view = view 
} 
 
interactor.requestPokemon() 
view.showLoading() 
} 
 
@Subscribe(threadMode = ThreadMode.MAIN, sticky = true) 
override fun onPokemonRetrieved(event: GetPokemonJob.FinishedEvent) { 
bus.removeStickyEvent(event) 
view.hideLoading() 
view.pokemonLoaded(event.pokemon) 
} 
}

 
 
 
@Mock 
 
@Mock 
lateinit var event: GetPokemonJob.FinishedEvent 
 
@Mock 
 
@Mock 
 
var list = arrayListOf(Pokemon("Squirtle"), Pokemon("Bulbasaur")) 
 
@Before 
fun setUp() { 
Mockito.`when`(event.pokemon).thenReturn(list) 
underTest = PokemonPresenterImpl(interactor, bus) 
} 
 
@Test 
fun `shouldRequestPokemon`() { 
underTest.onStart() 
 
verify(interactor).requestPokemon() 
verify(view).showLoading() 
verifyNoMoreInteractions(interactor, view) 
} 
 
@Test 
fun `shouldShowPokemon_andRemoveEventFromBus`() { 
underTest.onPokemonRetrieved(event) 
 
verify(view).hideLoading() 
verify(view).pokemonLoaded(event.pokemon) 
verify(bus).removeStickyEvent(event) 
verifyNoMoreInteractions(bus, view) 
} 
}

Is TDD with espresso
possible?

Is TDD with espresso
possible?
YES.

Do you want to do it?
No.
Slow Feedback
Device dependent
Too many uses cases at once
Requires an emulator or a device

UI
Do manual test and speciﬁc espresso
tests for core features.

Dagger
Dependency Injection
From Google
Avoid new keyword
Component in isolation

 
} 
}

 
} 
}
class PokemonRepositoryImpl : PokemonRepository { 
 
override fun getPokemon(): List<Pokemon> {
val client = PokemonRestClientImpl() 
} 
}

 
} 
}
 
val client = PokemonRestClientImpl() 
} 
}
class PokemonRestClientImpl(val pokemonService: PokemonService) : PokemonRestClient { 
override fun listPokemon(offset: String): ListPokemonResponse { 
return pokemonService.listPokemon(offset).execute().body() 
} 
}

 
} 
}
 
val service = PokemonService()
val client = PokemonRestClientImpl(service) 
} 
}

 
} 
}
 
val service = Retrofit.Builder() 
.client(client) 
.baseUrl("http://pokeapi.co/") 
.addConverterFactory(GsonConverterFactory.create()) 
.build()
} 
}

 
} 
}
 
val service = Retrofit.Builder() 
.client(client) 
.build()
} 
}
0 dependency
3 dependency:
- retroﬁt
- gson converted
- pokemon rest client imp

@Module 
class NetworkModule { 
 
@Provides 
@Singleton 
fun providesPokemonRestClient(service: PokemonService): PokemonRestClient { 
return PokemonRestClientImpl(service) 
} 
 
@Provides 
@Singleton 
fun providesPokemonService(client: OkHttpClient): PokemonService { 
val retrofit = Retrofit.Builder() 
.client(client) 
.build() 
 
return retrofit.create(PokemonService::class.java) 
} 
 
@Provides 
@Singleton 
internal fun providesOkHttpClient(): OkHttpClient { 
return OkHttpClient.Builder() 
.addInterceptor(HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY)) 
.build() 
} 
}

@Module 
class RepositoryModule { 
 
@Provides 
fun providesPokemonRepository(client: PokemonRestClient): PokemonRepository { 
return PokemonRepositoryImpl(client) 
} 
}
@Module 
class InteractorModule { 
 
@Provides 
@Singleton 
fun providesJobManager(context: Context): JobManager { 
val builder = Configuration.Builder(context) 
.customLogger(JobLogger()) 
return JobManager(builder.build()) 
} 
 
@Provides 
fun providesPokemonInteractor(bus: EventBus, jobManager: JobManager, repository: PokemonRepository):
PokemonInteractor { 
return PokemonInteractorImpl(jobManager, repository, bus) 
} 
}
@Module 
class PresenterModule{ 
 
@Provides 
fun providesPokemonPresenter(bus: EventBus, interactor: PokemonInteractor) : PokemonPresenter{ 
return PokemonPresenterImpl(interactor, bus) 
} 
}

class PokemonListActivity : AppCompatActivity(), PokemonView { 
 
@Inject 
lateinit var presenter: PokemonPresenter 
 
lateinit var loader: ProgressBar 
lateinit var grid: RecyclerView 
 
override fun onCreate(savedInstanceState: Bundle?) { 
super.onCreate(savedInstanceState) 
setContentView(R.layout.activity_main) 
loader = findViewById(R.id.loader) as ProgressBar 
grid = findViewById(R.id.grid) as RecyclerView
 
val uiComponent = DaggerUIComponent.builder()
.appComponent((application as PokemonApp).appComponent).build() 
uiComponent.inject(this) 
presenter.init(this) 
} 
 
super.onStart() 
presenter.onStart() 
} 
 
override fun showLoading() { 
loader.visibility = View.VISIBLE 
grid.visibility = View.INVISIBLE 
} 
 
override fun hideLoading() { 
loader.visibility = View.INVISIBLE 
grid.visibility = View.VISIBLE 
} 
 
override fun pokemonLoaded(pokemons: List<Pokemon>) { 
grid.adapter = PokemonAdapter(pokemons) 
} 
}

Outcome
Fully tested!
Half tested
Library
~80%

Repository
https://github.com/dbottillo/TDDAndroid

Thanks.
twitter.com/dbottillo
medium.com/@dbottillo

TDAD

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (8)

Similar to TDAD

Similar to TDAD (20)

Recently uploaded

Recently uploaded (20)

TDAD