DroidCon 2014 - Robotium vs espresso_droidcon

Robotiumvs Espresso
Get ready to rumble !

Thomas Guerin
Développeur Android

Thomas Guerin
Tests addict

Thomas Guerin
Tests addict
Niveau 15 à Destiny

Robotium vs Espresso : Get ready to rumble !

Pourquoi ne pas faire de tests ?
#Droidcon #Robotium #Espresso @Tom404_

“Mes tests durent des heures !”

“Tester ce n’est pas toujours simple !”
#Droidcon #Robotium #Espresso
@Tom404_

“Mes tests échouent aléatoirement !”
@Tom404_

“Mes tests échouent aléatoirement !”
“Je vais devoir corriger les tests alors que je
n’ai presque rien modifié”
@Tom404_

Un test doit être…

Simple
@Tom404_

Simple Rapide
@Tom404_

Simple Rapide Fiable
@Tom404_

Simple Rapide Fiable Durable
@Tom404_

Un mauvais exemple

Un mauvais exemple
// Start the main activity of the application under test
mActivity = getActivity();
!
// Get a handle to the Activity object's main UI widget, a Spinner
mSpinner = (Spinner)mActivity.findViewById(com.android.example.spinner.R.id.Spinner01);
!
// Set the Spinner to a known position
mActivity.setSpinnerPosition(TEST_STATE_DESTROY_POSITION);
!
// Stop the activity - The onDestroy() method should save the state of the Spinner
mActivity.finish();
!
// Re-start the Activity - the onResume() method should restore the state of the Spinner
mActivity = getActivity();
!
// Get the Spinner's current position
int currentPosition = mActivity.getSpinnerPosition();
!
// Assert that the current position is the same as the starting position
assertEquals(TEST_STATE_DESTROY_POSITION, currentPosition);
@Tom404_

Les combattants

Les combattants
Robotium
@Tom404_

Les combattants
VS
Robotium Espresso
@Tom404_

Dépendances Gradle

Dépendances Gradle
Robotium
dependencies {
androidTestCompile ‘com.jayway.android.robotium:robotium-solo:5.2.1'
androidTestCompile 'com.squareup.assertj:assertj-android:1.0.0'
}
@Tom404_

Dépendances Gradle
Espresso
dependencies {
/* Jars récupérés depuis https://code.google.com/p/android-test-kit */
androidTestCompile files(‘libs/espresso-1.1.jar’, ‘libs/espresso-contrib-1.1.jar',
‘libs/testrunner-1.1.jar', 'libs/testrunner-runtime-1.1.jar')
androidTestCompile 'com.google.guava:guava:14.0.1',
'com.squareup.dagger:dagger:1.1.0',
'org.hamcrest:hamcrest-core:1.1',
'org.hamcrest:hamcrest-integration:1.1',
'org.hamcrest:hamcrest-library:1.1'
}
android.packagingOptions {
exclude 'META-INF/LICENSE.txt'
exclude 'LICENSE.txt'
exclude 'META-INF/LICENSE'
exclude 'META-INF/NOTICE'
}
@Tom404_

Dépendances Gradle
Double Espresso
dependencies {
androidTestCompile ’com.jakewharton.espresso:espresso:1.1-r3’,
‘com.jakewharton.espresso:espresso-support-v4:1.1-r3'
}
android.packagingOptions {
exclude 'META-INF/LICENSE.txt'
exclude 'LICENSE.txt'
exclude 'META-INF/LICENSE'
exclude 'META-INF/NOTICE'
}
https://github.com/JakeWharton/double-espresso
@Tom404_

Test Runner

Test Runner
Robotium utilise le test runner du sdk
@Tom404_

Test Runner
Espresso nécessite un test runner spécifique
@Tom404_

Test Runner
Espresso nécessite un test runner spécifique
defaultConfig {
testInstrumentationRunner
"com.google.android.apps.common.testing.testrunner.GoogleInstrumentationTestRunner"
}
@Tom404_

GoogleInstrumentationTestRunner

onCreate de l'application finalisée avant le début des tests
@Tom404_

Instrumentation terminée == activités finies
@Tom404_

Monitoring des activités plus fiable
@Tom404_

Monitoring des activités plus fiable
Peut être utilisé avec d'autres librairies
@Tom404_

Initialisation

Initialisation
Robotium
public class SimpleActionsTest extends ActivityInstrumentationTestCase2<MainActivity> {
!
private Solo solo;
!
public void setUp() throws Exception {
super.setUp();
solo = new Solo(getInstrumentation(), getActivity());
}
!
public void tearDown() throws Exception {
solo.finishOpenedActivities();
super.tearDown();
}
}
@Tom404_

Initialisation
Espresso
public class SimpleActionsTest extends ActivityInstrumentationTestCase2<MainActivity> {
!
@Override
protected void setUp() throws Exception {
super.setUp();
// Espresso ne va pas lancer l'activité pour nous
getActivity();
}
}
@Tom404_

API overview
Robotium
@Tom404_

API overview
Solo
Robotium
@Tom404_

API overview
clickOnActionBarHome()
clickOnButton(int index)
searchText(String text)
pressSoftKeyboardNextButton()
clickOnImageButton(int index)
scrollDownList(int index)
clearEditText(int index)
scrollDown()
clickOnToggleButton(String text)
pressMenuItem(int index)
Solo
getView(int viewId)
drag(…)
clickInList(int line, int index)
goBack()
setNavigationDrawer(int status)
clickOnActionBarItem(int id)
getButton(int index)
scrollToBottom() searchEditText(String text)
pressSoftKeyboardSearchButton()
@Tom404_

Exemple

Exemple
// Récupération de la vue
Button myButton = (TextView) solo.getView(R.id.my_button);
!
// Assertions (AssertJ Android)
assertThat(myButton).hasText(“My button”).isVisible();
!
// Clic sur la vue
solo.clickOnView(myButton)
@Tom404_

Hamcrest

Hamcrest
Librairie de matchers
@Tom404_

Hamcrest
assertThat("Hello", equalTo("Hello"))
@Tom404_

Hamcrest
!
// Sucre syntaxique
assertThat(“Hello", is("Hello"))
@Tom404_

Hamcrest
!
// Sucre syntaxique
!
// De nombreux matchers disponibles
allOf not instanceOf hasProperty equalToIgnoringCase
@Tom404_

Hamcrest
!
// Sucre syntaxique
!
// De nombreux matchers disponibles
allOf not instanceOf hasProperty equalToIgnoringCase
Possibilité de composition
@Tom404_

Hamcrest custom matcher

Hamcrest custom matcher
public class IsNotANumber extends TypeSafeMatcher<Double> {
!
@Override
public boolean matchesSafely(Double number) {
return number.isNaN();
}
!
public void describeTo(Description description) {
description.appendText("not a number");
}
!
public static Matcher<Double> notANumber() {
return new IsNotANumber();
}
!
}
@Tom404_

API overview
Espresso
@Tom404_

API overview
Espresso
Espresso
onView(Matcher<View>)!
onData(Matcher<Object>
@Tom404_

API overview
ViewMatchers Espresso
Espresso withId()!
withText(text)!
hasSibling(Matcher<View>)
@Tom404_

API overview
Espresso
withId()!
withText(text)!
ViewActions
click()!
typeText(text)
@Tom404_

API overview
Espresso
withId()!
withText(text)!
ViewActions
click()!
typeText(text)
ViewAssertions
doesNotExist()!
matches(Matcher<View>)
@Tom404_

API overview
Espresso
ViewInteraction / DataInteraction
perform(ViewAction)!
check(ViewAssertion)
withId()!
withText(text)!
ViewActions
click()!
typeText(text)
ViewAssertions
doesNotExist()!
matches(Matcher<View>)
@Tom404_

Exemple
onView(allOf(withId(R.id.my_button), withText(“My Button”)))
.check(matches(isDisplayed()))
.perform(click());
@Tom404_

Exemple
.perform(click());
!
// Une simple extraction de méthode permet de simplifier
onView(withIdAndText(R.id.my_button, "My Button”))
.perform(click());
@Tom404_

Exemple
.perform(click());
!
.perform(click());
!
// Si le bouton n'est pas affiché le perform(click()) échouera
onView(withIdAndText(R.id.my_button, "My Button")).perform(click());
@Tom404_

Exemple
.perform(click());
!
.perform(click());
!
// Si le bouton n'est pas affiché le perform(click()) échouera
onView(withIdAndText(R.id.my_button, "My Button")).perform(click());
Manque de restrictions = AmbiguousViewMatcherException
@Tom404_

Listview

Listview
Robotium
// Clic sur item
solo.clickOnText("textToFind");
!
// Si jamais il y'en a plusieurs -> utilisation d'un index
solo.clickOnText("textToFind", 3);
!
// Ou choisir directement la ligne
solo.clickInList(2);
@Tom404_

Listview
Espresso
onData(allOf(is(instanceOf(String.class)), is("textToFind"))).perform(click());
!
// Ou directement à une position
onData(is(instanceOf(String.class))).atPosition(0).perform(click());
!
// Possibilité de préciser une listview, utile pour le view pager
onData(allOf(is(instanceOf(String.class)), is("textToFind")))
.inAdapterView(withId(R.id.my_list)).perform(click());
!
// Interaction avec une vue enfant de la ligne
onData(allOf(is(instanceOf(String.class)), is("textToFind")))
.onChildView(withId(R.id.my_child))
.perform(click());
@Tom404_

Listview
Espresso : cas plus complexe
// Type renvoyé par la méthode getItem de l'adapteur
public class Item {
public String name;
public String itemContent;
}
!
onData(allOf(is(instanceOf(Item.class)), hasProperty(“name", equalTo(“nameToFind"))))
.perform(click());
@Tom404_

Listview
Espresso : custom matcher
public static Matcher<Object> withItemName(final Matcher<String> itemTextMatcher){
return new BoundedMatcher<Object, Item>(Item.class) {
@Override
public boolean matchesSafely(Item item) {
return itemTextMatcher.matches(item.name);
}
!
@Override
public void describeTo(Description description) {
description.appendText("with item name: ");
itemTextMatcher.describeTo(description);
}
};
}
onData(withItemName(equalTo("nameToFind"))).perform(click());
@Tom404_

Webview
Robotium
@Tom404_

Webview
Robotium
Possibilité d’interagir avec les webviews
•solo.getWebElements(by)
•solo.clickOnWebElement(by)
@Tom404_

Webview
Robotium
Possibilité d’interagir avec les webviews
•solo.getWebElements(by)
•solo.clickOnWebElement(by)
Plusieurs types de recherches disponibles
•By.id(String id)
•By.className(String className)
•By.textContent(String textContent)
•By.name(String name)
@Tom404_

Webview
Espresso
@Tom404_

Navigation Drawer

Navigation Drawer
Robotium
// Attention l'id du frame layout du menu doit absolument être "left_drawer"
solo.setNavigationDrawer(Solo.OPENED);
!
solo.setNavigationDrawer(Solo.CLOSED);
@Tom404_

Navigation Drawer
Robotium
// Attention l'id du frame layout du menu doit absolument être "left_drawer"
solo.setNavigationDrawer(Solo.OPENED);
!
solo.setNavigationDrawer(Solo.CLOSED);
Espresso
DrawerActions.openDrawer(R.id.drawer_layout);
!
DrawerActions.closeDrawer(R.id.drawer_layout);
@Tom404_

Action bar

Action bar
Robotium
solo.clickOnActionBarItem(R.id.action_example);
!
// Cas de l'action bar overflow
solo.sendKey(KeyEvent.KEYCODE_MENU);
solo.clickOnText("action");
@Tom404_

Action bar
Robotium
solo.clickOnActionBarItem(R.id.action_example);
!
solo.sendKey(KeyEvent.KEYCODE_MENU);
solo.clickOnText("action");
Espresso
onView(withId(R.id_action_example)).perform(click());
!
openActionBarOverflowOrOptionsMenu(getInstrumentation().getTargetContext());
onView(withText("action")).perform(click());
@Tom404_

Back button & Keyboard

Robotium
solo.goBack();
// solo.goBack() est aussi utilisé pour fermer le clavier
@Tom404_

Robotium
solo.goBack();
// solo.goBack() est aussi utilisé pour fermer le clavier
Espresso
Espresso.pressBack();
Espresso.closeSoftKeyboard();
@Tom404_

Les messages d’erreur

Robotium
!
// Récupération d’une vue inexistante
solo.getView(1234);
!j
unit.framework.AssertionFailedError: View with id: '1234' is not found!
at com.robotium.solo.Solo.getView(Solo.java:2008)
at com.robotium.solo.Solo.getView(Solo.java:1988)
at
fr.droidcon.robotium.vs.espresso.samples.test.robotium.SimpleActionsTest.testClickButton(SimpleAct
ionsTest.java:28)

Espresso
!
// Récupération d’une vue inexistante
onView(withId(1234));
com.google.android.apps.common.testing.ui.espresso.NoMatchingViewException: No views in hierarchy
found matching: with id: is <1234>
If the target view is not part of the view hierarchy, you may need to use Espresso.onData to load it from
one of the following AdapterViews:android.widget.ListView{426f6f18 VFED.VC. ......ID 0,0-720,1557}
- android.widget.ListView{4269c598 V.ED.VC. ........ 48,393-1032,1509 #7f070042 app:id/my_list}
!
View Hierarchy:
+>DecorView{id=-1, visibility=VISIBLE, width=1080, height=1776, has-focus=true, has-focusable=true,
has-window-focus=true, is-clickable=false, is-enabled=true, is-focused=false, is-focusable=false, is-layout-
requested=false, is-selected=false, root-is-layout-requested=false, has-input-connection=false,
x=0.0, y=0.0, child-count=1}
|
+->ActionBarOverlayLayout{id=16909075, res-name=action_bar_overlay_layout, visibility=VISIBLE,
width=1080, height=1776, has-focus=true, has-focusable=true, has-window-focus=true, is-clickable=
false, is-enabled=true, is-focused=false, is-focusable=false, is-layout-requested=false, is-selected=
false, root-is-layout-requested=false, has-input-connection=false, x=0.0, y=0.0, child-count=
3}
|
+-->FrameLayout{id=16908290, res-name=content, visibility=VISIBLE, width=1080, height=1557,
has-focus=true, has-focusable=true, has-window-focus=true, is-clickable=false, is-enabled=true, is-

Wait and See

Wait and See
Robotium repose sur le principe de wait & see
•solo.waitForActivity(Class class, int timeout)
• solo.waitForCondition(Condition condition, int timeout)
• solo.waitForDialogToOpen()
@Tom404_

Wait and See
Robotium repose sur le principe de wait & see
•solo.waitForActivity(Class class, int timeout)
• solo.waitForCondition(Condition condition, int timeout)
• solo.waitForDialogToOpen()
solo.clickOnView(R.id.start_activity_button);
!
// On attend que la vue apparaisse avant d'agir
solo.waitForView(R.id.view_in_new_activity);
!
solo.clickOnView(R.id.view_in_new_activity);
@Tom404_

Finis de dormir !

Finis de dormir !
Entrée en jeu du GoogleInstrumentationTestRunner
@Tom404_

Finis de dormir !
Monitoring plus fin des activités et des ressources
@Tom404_

Finis de dormir !
Analyse du ThreadUI pour savoir quand agir
@Tom404_

Finis de dormir !
Pas de wait
@Tom404_

Finis de dormir !
Pas de wait
onView(withId(R.id.start_activity_button)).perform(click());
!
onView(withId(R.id.view_in_new_activity)).perform(click());
@Tom404_

Idle mais actif !

Idle mais actif !
Possibilité d'enregistrer des idlingResources
@Tom404_

class EspressoThreadPool extends ThreadPoolExecutor implements IdlingResource {
private int threadCount = 0;
private ResourceCallback resourceCallback;
...
@Override
public synchronized void execute(Runnable r) {
threadCount++;
super.execute(r);
}
@Override
public synchronized boolean isIdleNow() {
return threadCount == 0;
}
@Override
public void registerIdleTransitionCallback(ResourceCallback resourceCallback) {
this.resourceCallback = resourceCallback;
}
@Override
protected synchronized void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
threadCount--;
if (resourceCallback != null && isIdleNow()) {
resourceCallback.onTransitionToIdle();
}
}
}
@Tom404_

class EspressoThreadPool extends ThreadPoolExecutor implements IdlingResource {
private int threadCount = 0;
private ResourceCallback resourceCallback;
...
@Override
public synchronized void execute(Runnable r) {
threadCount++;
super.execute(r);
}
@Override
public synchronized boolean isIdleNow() {
return threadCount == 0;
}
@Override
public void registerIdleTransitionCallback(ResourceCallback resourceCallback) {
this.resourceCallback = resourceCallback;
}
@Override
protected synchronized void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
threadCount--;
if (resourceCallback != null && isIdleNow()) {
resourceCallback.onTransitionToIdle();
}
}
}
Espresso.registerIdlingResources(espressoThreadPool);
@Tom404_

DroidCon 2014 - Robotium vs espresso_droidcon

More Related Content

Viewers also liked (20)

Similar to DroidCon 2014 - Robotium vs espresso_droidcon (8)

More from Publicis Sapient Engineering (20)

Recently uploaded (20)

DroidCon 2014 - Robotium vs espresso_droidcon