tutorial - Unit Testen Sie ein Android-Fragment




unit test android example (3)

Angenommen, Sie haben eine FragmentCtivity-Klasse namens "MyFragmentActivity", in der eine öffentliche Fragmentklasse namens "MyFragment" mit FragmentTransaction hinzugefügt wird. Erstellen Sie einfach eine "JUnit Test Case" -Klasse, die ActivityInstrumentationTestCase2 in Ihrem Testprojekt erweitert. Rufen Sie dann einfach getActivity () auf und greifen Sie auf das MyFragment-Objekt und seine öffentlichen Member zum Schreiben von Testfällen zu.

Sehen Sie sich das Code-Snippet an:

// TARGET CLASS
public class MyFragmentActivity extends FragmentActivity {
    public MyFragment myFragment;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        FragmentTransaction fragmentTransaction = getSupportFragmentManager().beginTransaction();
        myFragment = new MyFragment();
        fragmentTransaction.add(R.id.mainFragmentContainer, myFragment);
        fragmentTransaction.commit();
    }
}

// TEST CLASS
public class MyFragmentActivityTest extends android.test.ActivityInstrumentationTestCase2<MyFragmentActivity> {
    MyFragmentActivity myFragmentActivity;
    MyFragment myFragment;

    public MyFragmentActivityTest() {
        super(MyFragmentActivity.class);
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        myFragmentActivity = (MyFragmentActivity) getActivity();
        myFragment = myFragmentActivity.myFragment;
    }

    public void testPreConditions() {
        assertNotNull(myFragmentActivity);
        assertNotNull(myFragment);
    }

    public void testAnythingFromMyFragment() {
        // access any public members of myFragment to test
    }
}

Ich hoffe das hilft. Akzeptiere meine Antwort, wenn du das nützlich findest. Vielen Dank.

Ich möchte eine Android Fragment-Klasse testen.

Kann ich einen Test mit AndroidTestCase einrichten oder muss ich ApplicationTestCase verwenden?

Gibt es nützliche Beispiele dafür, wie diese beiden Testfälle verwendet werden können? Die Testbeispiele auf der Entwicklerseite sind minimal und scheinen sich nur auf das Testen von Aktivitäten zu konzentrieren.

Alles, was ich an anderer Stelle gefunden habe, sind Beispiele, in denen die AndroidTestCase-Klasse erweitert wird, aber dann werden nur zwei Zahlen addiert, oder wenn der Kontext verwendet wird, wird einfach gettet und getestet, dass etwas nicht null ist!

So wie ich es verstehe, muss ein Fragment in einer Aktivität leben. Könnte ich also eine Mock-Aktivität erstellen oder die Anwendung oder den Kontext dazu bringen, eine Aktivität bereitzustellen, in der ich mein Fragment testen kann?

Muss ich meine eigene Aktivität erstellen und dann ActivityUnitTestCase verwenden?

Danke für deine Hilfe.

Trev


Hinzufügen zu @ abhijit.mitkar's Antwort.

In einem Szenario, in dem Ihr Fragment kein öffentliches Mitglied in der zu testenden Aktivität ist.

protected void setUp() {
   mActivity = getActivity();
   mFragment = new TheTargetFragment();

   FragmentTransaction transaction = mActivity.getSupportFragmentManager().beginTransaction();
   transaction.add(R.id.fragment_container, mFragment, "FRAGMENT_TAG");
   transaction.commit();
}

Der obige Code dient dazu, das Fragment durch ein neues Fragmentobjekt zu ersetzen, auf das wir Zugriff haben.

Der folgende Code ermöglicht Ihnen den Zugriff auf die Benutzerelemente der Fragmente.

TextView randomTextView= (TextView) mFragment.getView().findViewById(R.id.textViewRandom);

Wenn Sie die Benutzeroberfläche von der Aktivität abrufen , erhalten Sie nicht das erwartete Ergebnis.

TextView randomTextView= (TextView) mActivity.findViewById(R.id.textViewRandom);

Schließlich, wenn Sie einige Änderungen in der Benutzeroberfläche vornehmen möchten. Wie ein guter Android-Entwickler mache es im Hauptthread.

mActivity.runOnUiThread(new Runnable() {
    @Override
    public void run() {
        // set text view's value
    }
});

Hinweis: Möglicherweise möchten Sie jedem Thread einen Thread.sleep () geben. Um eine Blockierung zu vermeiden, sollte die getInstrumentation (). WaitForIdleSync (); scheint nicht immer zu funktionieren.

Ich habe ActivityInstrumentationTestCase2 seit dem Funktionstest verwendet.


Ich hatte mit derselben Frage zu kämpfen. Vor allem, da die meisten Codebeispiele bereits veraltet sind und sich Android Studio / SDKs verbessern, sind alte Antworten manchmal nicht mehr relevant.

Also, das Wichtigste zuerst: Sie müssen feststellen, ob Sie Instrumental- oder einfache JUnit- Tests verwenden möchten.

Der Unterschied zwischen ihnen wird hier von SD schön beschrieben; Kurz gesagt: JUnit-Tests sind leichter und erfordern keinen Emulator, Instrumental - geben Sie die am ehesten dem tatsächlichen Gerät mögliche Erfahrung (Sensoren, GPS, Interaktion mit anderen Apps etc.). Lesen Sie auch mehr über Testen in Android .

1. JUnit-Testen von Fragmenten

Nehmen wir an, Sie brauchen keine schweren Instrumental-Tests und einfache Junit-Tests sind genug. Ich verwende dafür einen schönen Rahmen Robolectric .

In Großbuchstaben hinzufügen:

dependencies {
    .....
    testCompile 'junit:junit:4.12'
    testCompile 'org.robolectric:robolectric:3.0'
    testCompile "org.mockito:mockito-core:1.10.8"
    testCompile ('com.squareup.assertj:assertj-android:1.0.0') {
        exclude module: 'support-annotations'
    }
    .....
}

Mockito, AsserJ sind optional, aber ich fand sie sehr nützlich, daher empfehle ich sehr, sie auch aufzunehmen.

Dann in Build Variants Unit Tests als Testartefakt angeben:

Jetzt ist es an der Zeit, ein paar echte Tests zu schreiben :-) Als Beispiel nehmen wir das Beispielprojekt "Leere Aktivität mit Fragment".

Ich habe einige Zeilen Code hinzugefügt, um etwas zu testen:

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import java.util.ArrayList;
import java.util.List;

public class MainActivityFragment extends Fragment {

    private List<Cow> cows;
    public MainActivityFragment() {}

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {   
        cows = new ArrayList<>();
        cows.add(new Cow("Burka", 10));
        cows.add(new Cow("Zorka", 9));
        cows.add(new Cow("Kruzenshtern", 15));

        return inflater.inflate(R.layout.fragment_main, container, false);
    }

    int calculateYoungCows(int maxAge) {
        if (cows == null) {
            throw new IllegalStateException("onCreateView hasn't been called");
        }

        if (getActivity() == null) {
            throw new IllegalStateException("Activity is null");
        }

        if (getView() == null) {
            throw new IllegalStateException("View is null");
        }

        int result = 0;
        for (Cow cow : cows) {
            if (cow.age <= maxAge) {
                result++;
            }
        }

        return result;
    }
}

Und Klasse Kuh:

public class Cow {
    public String name;
    public int age;

    public Cow(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Das Testset des Robolectic würde ungefähr so ​​aussehen:

import android.app.Application;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.test.ApplicationTestCase;

import junit.framework.Assert;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.Robolectric;
import org.robolectric.RobolectricGradleTestRunner;
import org.robolectric.annotation.Config;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

@RunWith(RobolectricGradleTestRunner.class)
@Config(constants = BuildConfig.class, sdk=21)
public class MainActivityFragmentTest extends ApplicationTestCase<Application> {

    public MainActivityFragmentTest() {
        super(Application.class);
    }

    MainActivity mainActivity;
    MainActivityFragment mainActivityFragment;

    @Before
    public void setUp() {
        mainActivity = Robolectric.setupActivity(MainActivity.class);
        mainActivityFragment = new MainActivityFragment();
        startFragment(mainActivityFragment);
    }

    @Test
    public void testMainActivity() {
        Assert.assertNotNull(mainActivity);
    }

    @Test
    public void testCowsCounter() {
        assertThat(mainActivityFragment.calculateYoungCows(10)).isEqualTo(2);
        assertThat(mainActivityFragment.calculateYoungCows(99)).isEqualTo(3);
    }

    private void startFragment( Fragment fragment ) {
        FragmentManager fragmentManager = mainActivity.getSupportFragmentManager();
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        fragmentTransaction.add(fragment, null );
        fragmentTransaction.commit();
    }
}

Dh wir erstellen Aktivität über Robolectric.setupActivity , neues Fragment im setUp () der Testklassen. Optional können Sie das Fragment sofort aus dem setUp () starten oder direkt aus dem Test heraus.

Achtung! Ich habe nicht zu viel Zeit darauf verwendet, aber es sieht so aus, als wäre es fast unmöglich, es mit Dagger zu verbinden (ich weiß nicht, ob es mit Dagger2 einfacher ist), da Sie keine benutzerdefinierte Testanwendung mit verspotteten Injektionen einstellen können.

2. Instrumentelles Testen von Fragmenten

Die Komplexität dieses Ansatzes hängt stark davon ab, ob Sie die Dagger / Dependency-Injektion in der App verwenden, die Sie testen möchten.

In Build-Varianten geben Sie Android-Instrumententests als Testartefakt an :

In Gradle füge ich diese Abhängigkeiten hinzu:

dependencies {
    .....
    androidTestCompile "com.google.dexmaker:dexmaker:1.1"
    androidTestCompile "com.google.dexmaker:dexmaker-mockito:1.1"
    androidTestCompile 'com.squareup.assertj:assertj-android:1.0.0'
    androidTestCompile "org.mockito:mockito-core:1.10.8"
    }
    .....
}

(wieder, so ziemlich alle von ihnen sind optional, aber sie können Ihr Leben so viel einfacher machen)

- Wenn du keinen Dolch hast

Das ist ein glücklicher Weg. Der Unterschied zu Robolectric von oben wäre nur in kleinen Details.

Pre-Step 1 : Wenn Sie Mockito verwenden wollen, müssen Sie es aktivieren, um auf den Geräten und Emulatoren mit diesem Hack zu laufen:

public class TestUtils {
    private static final String CACHE_DIRECTORY = "/data/data/" + BuildConfig.APPLICATION_ID + "/cache";
    public static final String DEXMAKER_CACHE_PROPERTY = "dexmaker.dexcache";

    public static void enableMockitoOnDevicesAndEmulators() {
        if (System.getProperty(DEXMAKER_CACHE_PROPERTY) == null || System.getProperty(DEXMAKER_CACHE_PROPERTY).isEmpty()) {
            File file = new File(CACHE_DIRECTORY);
            if (!file.exists()) {
                final boolean success = file.mkdirs();
                if (!success) {
                    fail("Unable to create cache directory required for Mockito");
                }
            }

            System.setProperty(DEXMAKER_CACHE_PROPERTY, file.getPath());
        }
    }
}

Das MainActivityFragment bleibt wie oben gleich. Also würde das Test-Set wie folgt aussehen:

package com.klogi.myapplication;

import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.test.ActivityInstrumentationTestCase2;

import junit.framework.Assert;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

public class MainActivityFragmentTest extends ActivityInstrumentationTestCase2<MainActivity> {

    public MainActivityFragmentTest() {
        super(MainActivity.class);
    }

    MainActivity mainActivity;
    MainActivityFragment mainActivityFragment;

    @Override
    protected void setUp() throws Exception {
        TestUtils.enableMockitoOnDevicesAndEmulators();
        mainActivity = getActivity();
        mainActivityFragment = new MainActivityFragment();
    }

    public void testMainActivity() {
        Assert.assertNotNull(mainActivity);
    }

    public void testCowsCounter() {
        startFragment(mainActivityFragment);
        assertThat(mainActivityFragment.calculateYoungCows(10)).isEqualTo(2);
        assertThat(mainActivityFragment.calculateYoungCows(99)).isEqualTo(3);
    }

    private void startFragment( Fragment fragment ) {
        FragmentManager fragmentManager = mainActivity.getSupportFragmentManager();
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        fragmentTransaction.add(fragment, null);
        fragmentTransaction.commit();

        getActivity().runOnUiThread(new Runnable() {
            @Override
            public void run() {
                getActivity().getSupportFragmentManager().executePendingTransactions();
            }
        });

        getInstrumentation().waitForIdleSync();
    }

}

Wie Sie sehen können, ist die Test-Klasse eine Erweiterung der ActivityInstrumentationTestCase2- Klasse. Außerdem ist es sehr wichtig, auf die startFragment- Methode zu achten , die sich im Vergleich zum Beispiel von JUnit geändert hat: Standardmäßig werden Tests nicht im UI-Thread ausgeführt, und wir müssen explizit die Ausführung der Transaktionen von FragmentManager anfordern.

- Wenn du Dolch hast

Hier wird es ernst :-)

Zuerst werden wir ActivityInstrumentationTestCase2 zugunsten der ActivityUnitTestCase- Klasse als Basisklasse für alle Testklassen des Fragments los.

Wie immer ist es nicht so einfach und es gibt mehrere Fallstricke ( this ist eines der Beispiele). Also müssen wir ActivityUnitTestCase zu ActivityUnitTestCaseOverride pimpen

Es ist ein bisschen zu lang, es hier vollständig zu posten, also github ich die Vollversion davon auf github ;

public abstract class ActivityUnitTestCaseOverride<T extends Activity>
        extends ActivityUnitTestCase<T> {

    ........
    private Class<T> mActivityClass;

    private Context mActivityContext;
    private Application mApplication;
    private MockParent mMockParent;

    private boolean mAttached = false;
    private boolean mCreated = false;

    public ActivityUnitTestCaseOverride(Class<T> activityClass) {
        super(activityClass);
        mActivityClass = activityClass;
    }

    @Override
    public T getActivity() {
        return (T) super.getActivity();
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();

        // default value for target context, as a default
        mActivityContext = getInstrumentation().getTargetContext();
    }

    /**
     * Start the activity under test, in the same way as if it was started by
     * {@link android.content.Context#startActivity Context.startActivity()}, providing the
     * arguments it supplied.  When you use this method to start the activity, it will automatically
     * be stopped by {@link #tearDown}.
     * <p/>
     * <p>This method will call onCreate(), but if you wish to further exercise Activity life
     * cycle methods, you must call them yourself from your test case.
     * <p/>
     * <p><i>Do not call from your setUp() method.  You must call this method from each of your
     * test methods.</i>
     *
     * @param intent                       The Intent as if supplied to {@link android.content.Context#startActivity}.
     * @param savedInstanceState           The instance state, if you are simulating this part of the life
     *                                     cycle.  Typically null.
     * @param lastNonConfigurationInstance This Object will be available to the
     *                                     Activity if it calls {@link android.app.Activity#getLastNonConfigurationInstance()}.
     *                                     Typically null.
     * @return Returns the Activity that was created
     */
    protected T startActivity(Intent intent, Bundle savedInstanceState,
                              Object lastNonConfigurationInstance) {
        assertFalse("Activity already created", mCreated);

        if (!mAttached) {
            assertNotNull(mActivityClass);
            setActivity(null);
            T newActivity = null;
            try {
                IBinder token = null;
                if (mApplication == null) {
                    setApplication(new MockApplication());
                }
                ComponentName cn = new ComponentName(getInstrumentation().getTargetContext(), mActivityClass.getName());
                intent.setComponent(cn);
                ActivityInfo info = new ActivityInfo();
                CharSequence title = mActivityClass.getName();
                mMockParent = new MockParent();
                String id = null;

                newActivity = (T) getInstrumentation().newActivity(mActivityClass, mActivityContext,
                        token, mApplication, intent, info, title, mMockParent, id,
                        lastNonConfigurationInstance);
            } catch (Exception e) {
                assertNotNull(newActivity);
            }

            assertNotNull(newActivity);
            setActivity(newActivity);

            mAttached = true;
        }

        T result = getActivity();
        if (result != null) {
            getInstrumentation().callActivityOnCreate(getActivity(), savedInstanceState);
            mCreated = true;
        }
        return result;
    }

    protected Class<T> getActivityClass() {
        return mActivityClass;
    }

    @Override
    protected void tearDown() throws Exception {

        setActivity(null);

        // Scrub out members - protects against memory leaks in the case where someone
        // creates a non-static inner class (thus referencing the test case) and gives it to
        // someone else to hold onto
        scrubClass(ActivityInstrumentationTestCase.class);

        super.tearDown();
    }

    /**
     * Set the application for use during the test.  You must call this function before calling
     * {@link #startActivity}.  If your test does not call this method,
     *
     * @param application The Application object that will be injected into the Activity under test.
     */
    public void setApplication(Application application) {
        mApplication = application;
    }
    .......
}

Erstellen Sie einen abstrakten AbstractFragmentTest für alle Ihre Fragmenttests:

import android.app.Activity;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.res.Configuration;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;

/**
 * Common base class for {@link Fragment} tests.
 */
public abstract class AbstractFragmentTest<TFragment extends Fragment, TActivity extends FragmentActivity> extends ActivityUnitTestCaseOverride<TActivity> {

    private TFragment fragment;
    protected MockInjectionRegistration mocks;

    protected AbstractFragmentTest(TFragment fragment, Class<TActivity> activityType) {
        super(activityType);
        this.fragment = parameterIsNotNull(fragment);
    }

    @Override
    protected void setActivity(Activity testActivity) {
        if (testActivity != null) {
            testActivity.setTheme(R.style.AppCompatTheme);
        }

        super.setActivity(testActivity);
    }

    /**
     * Get the {@link Fragment} under test.
     */
    protected TFragment getFragment() {
        return fragment;
    }

    protected void setUpActivityAndFragment() {
        createMockApplication();

        final Intent intent = new Intent(getInstrumentation().getTargetContext(),
                getActivityClass());
        startActivity(intent, null, null);
        startFragment(getFragment());

        getInstrumentation().callActivityOnStart(getActivity());
        getInstrumentation().callActivityOnResume(getActivity());
    }

    private void createMockApplication() {
        TestUtils.enableMockitoOnDevicesAndEmulators();

        mocks = new MockInjectionRegistration();
        TestApplication testApplication = new TestApplication(getInstrumentation().getTargetContext());
        testApplication.setModules(mocks);
        testApplication.onCreate();
        setApplication(testApplication);
    }

    private void startFragment(Fragment fragment) {
        FragmentManager fragmentManager = getActivity().getSupportFragmentManager();
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        fragmentTransaction.add(fragment, null);
        fragmentTransaction.commit();
    }
}

Es gibt einige wichtige Dinge hier.

1) Wir überschreiben die Methode setActivity () , um das AppCompact-Thema auf die Aktivität zu setzen. Ohne dies wird der Testanzug abstürzen.

2) setUpActivityAndFragment () Methode:

I. erstellt Aktivität (=> getActivity () beginnt, in Tests und in der App, die gerade getestet wird, einen Wert ungleich Null zurückzugeben) 1) onCreate () der aufgerufenen Aktivität;

2) onStart () der Aktivität genannt;

3) onResume () der Aktivität genannt;

II. Anhängen und startet Fragment zur Aktivität

1) onAttach () des Fragments genannt;

2) onCreateView () des Fragments genannt;

3) onStart () des aufgerufenen Fragments;

4) onResume () des Fragments genannt;

3) createMockApplication () -Methode: Wie in der Nicht-Dolch-Version, in Pre-Step 1, aktivieren wir das Mocking auf den Geräten und auf den Emulatoren.

Dann ersetzen wir die normale Anwendung mit ihren Injektionen durch unsere benutzerdefinierte TestApplication!

MockInjectionRegistration sieht folgendermaßen aus:

....
import javax.inject.Singleton;

import dagger.Module;
import dagger.Provides;
import de.greenrobot.event.EventBus;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

@Module(
        injects = {

                ....
                MainActivity.class,
                MyWorkFragment.class,
                HomeFragment.class,
                ProfileFragment.class,
                ....
        },
        addsTo = DelveMobileInjectionRegistration.class,
        overrides = true
)
public final class MockInjectionRegistration {

    .....
    public DataSource dataSource;
    public EventBus eventBus;
    public MixpanelAPI mixpanel;
    .....

    public MockInjectionRegistration() {
        .....
        dataSource = mock(DataSource.class);
        eventBus = mock(EventBus.class);
        mixpanel = mock(MixpanelAPI.class);
        MixpanelAPI.People mixpanelPeople = mock(MixpanelAPI.People.class);
        when(mixpanel.getPeople()).thenReturn(mixpanelPeople);
        .....
    }
...........
    @Provides
    @Singleton
    @SuppressWarnings("unused")
        // invoked by Dagger
    DataSource provideDataSource() {
        Guard.valueIsNotNull(dataSource);
        return dataSource;
    }

    @Provides
    @Singleton
    @SuppressWarnings("unused")
        // invoked by Dagger
    EventBus provideEventBus() {
        Guard.valueIsNotNull(eventBus);
        return eventBus;
    }

    @Provides
    @Singleton
    @SuppressWarnings("unused")
        // invoked by Dagger
    MixpanelAPI provideMixpanelAPI() {
        Guard.valueIsNotNull(mixpanel);
        return mixpanel;
    }
.........
}

Dh statt echter Klassen stellen wir den Fragmenten ihre verspotteten Versionen zur Verfügung. (Die sind leicht nachvollziehbar, ermöglicht es, Ergebnisse von Methodenaufrufen zu konfigurieren, etc.).

Und die TestApplication ist nur Ihre benutzerdefinierte Erweiterung der Anwendung, die Setting-Module unterstützen und den ObjectGraph initialisieren soll.

Dies waren Vorstufen für den Start der Tests :) Jetzt der einfache Teil, die echten Tests:

public class SearchFragmentTest extends AbstractFragmentTest<SearchFragment, MainActivity> {

    public SearchFragmentTest() {
        super(new SearchFragment(), MainActivity.class);
    }

    @UiThreadTest
    public void testOnCreateView() throws Exception {
        setUpActivityAndFragment();

        SearchFragment searchFragment = getFragment();
        assertNotNull(searchFragment.adapter);
        assertNotNull(SearchFragment.getSearchAdapter());
        assertNotNull(SearchFragment.getSearchSignalLogger());
    }

    @UiThreadTest
    public void testOnPause() throws Exception {
        setUpActivityAndFragment();

        SearchFragment searchFragment = getFragment();
        assertTrue(Strings.isNullOrEmpty(SharedPreferencesTools.getString(getActivity(), SearchFragment.SEARCH_STATE_BUNDLE_ARGUMENT)));

        searchFragment.searchBoxRef.setCurrentConstraint("abs");
        searchFragment.onPause();

        assertEquals(searchFragment.searchBoxRef.getCurrentConstraint(), SharedPreferencesTools.getString(getActivity(), SearchFragment.SEARCH_STATE_BUNDLE_ARGUMENT));
    }

    @UiThreadTest
    public void testOnQueryTextChange() throws Exception {
        setUpActivityAndFragment();
        reset(mocks.eventBus);

        getFragment().onQueryTextChange("Donald");
        Thread.sleep(300);

        // Should be one cached, one uncached event
        verify(mocks.eventBus, times(2)).post(isA(SearchRequest.class));
        verify(mocks.eventBus).post(isA(SearchLoadingIndicatorEvent.class));
    }

    @UiThreadTest
    public void testOnQueryUpdateEventWithDifferentConstraint() throws Exception {
        setUpActivityAndFragment();

        reset(mocks.eventBus);

        getFragment().onEventMainThread(new SearchResponse(new ArrayList<>(), "Donald", false));

        verifyNoMoreInteractions(mocks.eventBus);
    }
    ....
}

Das ist es! Jetzt haben Sie Instrumental- / JUnit-Tests für Ihre Fragmente aktiviert.

Ich hoffe aufrichtig, dass dieser Beitrag jemandem hilft.





activityunittestcase