単体テストとAndroid Fragment
Android Fragment class。
AndroidTestCaseを使用してテストをセットアップできますか、またはApplicationTestCaseを使用する必要がありますか？
これら2つのTestCaseを使用する方法の有用な例はありますか？開発者サイトのテスト例は最小限であり、アクティビティのテストに焦点を当てているようです。
私が見つけたのは、AndroidTestCaseクラスが拡張されている例ですが、テストされるのは2つの数字を加算するか、コンテキストが使用される場合、単純な取得を行い、何かがnullでないことをテストするだけです！
私が理解しているように、フラグメントはアクティビティ内に存在する必要があります。それでは、模擬アクティビティを作成するか、アプリケーションまたはコンテキストを取得して、フラグメントをテストできるアクティビティを提供できますか？
独自のアクティビティを作成してから、ActivityUnitTestCaseを使用する必要がありますか？
ご協力ありがとうございます。
トレブ
私は同じ質問に苦労していました。特に、ほとんどのコードサンプルは既に古くなっているため、+ Android Studio/SDKは改善されているため、古い回答はもはや関係ないことがあります。
そのため、まず最初に：Instrumentalを使用するか、単純なJUnitを使用するかを決定する必要があります。
それらの違いは、S.D。 ここ ;つまり、JUnitテストはより軽量で、エミュレータの実行を必要としません。インストルメンタル-実際のデバイスに最も近いエクスペリエンス（センサー、gps、他のアプリとの対話など）を提供します。 Androidでのテスト の詳細もお読みください。
1。フラグメントのJUnitテスト
重いインストルメンタルテストは必要なく、単純なjunitテストで十分です。この目的のために、Nice framework Robolectric を使用しています。
Gradleで追加：
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はオプションですが、非常に便利であることがわかったので、含めることを強くお勧めします。
次に、Build Variantsでnit Tests asTest Artifact： 
次に、実際のテストを作成します:-)例として、標準の「フラグメントを使用したブランクアクティビティ」サンプルプロジェクトを見てみましょう。
実際にテストするために、いくつかのコード行を追加しました。
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;
}
}
クラス牛：
public class Cow {
public String name;
public int age;
public Cow(String name, int age) {
this.name = name;
this.age = age;
}
}
Robolecticのテストセットは次のようになります。
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();
}
}
つまりRobolectric.setupActivity、テストクラスのsetUp（）の新しいフラグメントを介してアクティビティを作成します。オプションで、フラグメントをsetUp（）からすぐに開始することも、テストから直接開始することもできます。
NB！あまり時間を費やしていません、あまり時間をかけていませんが、ダガーと結びつけることはほとんど不可能に見えます（私はしません模擬注入を使用してカスタムテストアプリケーションを設定できないため、Dagger2の方が簡単かどうかを確認してください。
2。フラグメントの機器テスト
このアプローチの複雑さは、テストするアプリでDagger/Dependency Injectionを使用しているかどうかに大きく依存します。
Build VariantsでAndroid Instrumental Tests asTest Artifact： 
Gradleでは、これらの依存関係を追加します。
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"
}
.....
}
（再び、それらのほとんどすべてがオプションですが、それらはあなたの人生をとても簡単にすることができます）
-ダガーがない場合
これは幸せな道です。上記とのロボエレクトリックとの違いは、ほんの少しだけです。
前ステップ1：Mockitoを使用する場合は、このハックを使用してデバイスおよびエミュレーターで実行できるようにする必要があります。
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());
}
}
}
MainActivityFragmentは上記と同じままです。したがって、テストセットは次のようになります。
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();
}
}
ご覧のとおり、TestクラスはActivityInstrumentationTestCase2クラスの拡張です。また、JUnitの例と比較して変更されたstartFragmentメソッドに注意することが非常に重要です：デフォルトでは、テストはUIスレッドで実行されていないため、明示的に呼び出す必要がありますFragmentManagerのトランザクションを保留中の実行。
-ダガーがある場合
事態は深刻になりつつあります:-)
まず、すべてのフラグメントのテストクラスの基本クラスとして、ActivityInstrumentationTestCase2を削除してActivityUnitTestCaseクラスを使用します。
いつものように、それはそれほど単純ではなく、いくつかの落とし穴があります（ this は例の1つです）。したがって、AcitivityUnitTestCaseをActivityUnitTestCaseOverrideに変更する必要があります。
ここに完全に投稿するには長すぎるので、完全版を 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;
}
.......
}
すべてのフラグメントテストに対して抽象AbstractFragmentTestを作成します。
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();
}
}
ここにはいくつかの重要なことがあります。
1）setActivity（）メソッドをオーバーライドして、AppCompactテーマをアクティビティに設定します。それがなければ、テストスーツがクラッシュします。
2） setUpActivityAndFragment（）メソッド：
I。アクティビティを作成します（=> getActivity（）は、テストおよびテスト中のアプリでnull以外の値を返し始めます）1）呼び出されたアクティビティのonCreate（）;
2）呼び出されたアクティビティのonStart（）;
3）呼び出されたアクティビティのonResume（）;
II。アクティビティにフラグメントを添付して開始します
1）呼び出されたフラグメントのonAttach（）;
2）呼び出されたフラグメントのonCreateView（）;
3）呼び出されたフラグメントのonStart（）;
4）呼び出されたフラグメントのonResume（）;
） createMockApplication（）メソッド：非短剣バージョンと同様に、前手順1で、デバイスとエミュレーターでモックを有効にします。
次に、通常のアプリケーションをそのインジェクションでカスタムのTestApplicationに置き換えます！
MockInjectionRegistrationは次のようになります。
....
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;
}
.........
}
つまり実際のクラスの代わりに、モックされたバージョンをフラグメントに提供しています。 （これは簡単に追跡可能で、メソッド呼び出しの結果などを構成できます）。
TestApplicationは、アプリケーションのカスタム拡張であり、モジュールの設定をサポートし、ObjectGraphを初期化する必要があります。
これらはテストの記述を開始するための前段階でした：）単純な部分、実際のテスト：
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);
}
....
}
That's it！これで、フラグメントに対してInstrumental/JUnitテストが有効になりました。
この投稿が誰かの助けになることを心から願っています。
FragmentTransactionを使用して「MyFragment」というパブリックFragmentクラスが追加される「MyFragmentActivity」というFragmentActivityクラスがあるとします。テストプロジェクトでActivityInstrumentationTestCase2を拡張する「JUnitテストケース」クラスを作成するだけです。次に、単にgetActivity（）を呼び出し、テストケースを作成するためにMyFragmentオブジェクトとそのパブリックメンバーにアクセスします。
以下のコードスニペットを参照してください。
// 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
}
}
これがお役に立てば幸いです。これが役に立つと思うなら、私の答えを受け入れてください。ありがとう。
あなたが言っていることを実行し、模擬アクティビティを作成し、そこからフラグメントをテストできると確信しています。メインプロジェクトで互換性ライブラリをエクスポートする必要があり、テストプロジェクトからフラグメントにアクセスできるようになります。サンプルプロジェクトを作成し、ここでコードをテストし、見つけた内容に基づいて回答を更新します。
互換性ライブラリのエクスポート方法の詳細については、 here を確認してください。
@ abhijit.mitkarの回答に追加します。
フラグメントがテスト対象のアクティビティのパブリックメンバーではないというシナリオを考えます。
protected void setUp() {
mActivity = getActivity();
mFragment = new TheTargetFragment();
FragmentTransaction transaction = mActivity.getSupportFragmentManager().beginTransaction();
transaction.add(R.id.fragment_container, mFragment, "FRAGMENT_TAG");
transaction.commit();
}
上記のコードの目的は、フラグメントを、アクセス可能な新しいフラグメントオブジェクトに置き換えることです。
以下のコードを使用すると、フラグメントUIメンバーにアクセスできます。
TextView randomTextView= (TextView) mFragment.getView().findViewById(R.id.textViewRandom);
アクティビティからUIを取得しません期待される結果が得られます。
TextView randomTextView= (TextView) mActivity.findViewById(R.id.textViewRandom);
最後に、UIでいくつかの変更を行う場合。良いAndroid開発者がメインスレッドでそれを行うように。
mActivity.runOnUiThread(new Runnable() {
@Override
public void run() {
// set text view's value
}
});
注：テストが終了するたびにThread.sleep（）を与えることができます。ロックアップを回避するには、getInstrumentation（）。waitForIdleSync（）;常に機能するとは限りません。
機能テストを行っていたのでActivityInstrumentationTestCase2を使用しました。