以下内容为原创，欢迎转载，转载请注明 来自天天博客：
Android MVP&依赖注入&单元测试
注意：为了区分
MVP中的View与Android中控件的View，以下MVP中的View使用Viewer来表示。
这里暂时先只讨论 Viewer 和 Presenter，Model暂时不去涉及。
1.1 MVP 基础框架
1.1.1 前提
首先需要解决以下问题：
MVP中把Layout布局和Activity等组件作为Viewer层，增加了Presenter，Presenter层与Model层进行业务的交互，完成后再与Viewer层交互,进行回调来刷新UI。这样一来，业务逻辑的工作都交给了Presenter中进行，使得Viewer层与Model层的耦合度降低，Viewer中的工作也进行了简化。但是在实际项目中，随着逻辑的复杂度越来越大，Viewer（如Activity）臃肿的缺点仍然体现出来了，因为Activity中还是充满了大量与Viewer层无关的代码，比如各种事件的处理派发，就如MVC中的那样Viewer层和Controller代码耦合在一起无法自拔。
转自我之前的博客（）中第二阶段所引发的问题。
解决的方法之一在上述文章中也有提到 —— 加入Controller层来分担Viewer的职责。
1.1.2 Contract
根据以上的解决方案，首先考虑到Viewer直接交互的对象可能是Presenter（原来的方式），也有可能是Controller。
如果直接交互的对象是
Presenter，由于Presenter中可能会进行很多同步、异步操作来调用Model层的代码，并且会回调到UI来进行UI的更新，所以，我们需要在Viewer层对象销毁时能够停止Presenter中执行的任务，或者执行完成后拦截UI的相关回调。因此，Presenter中应该绑定Viewer对象的生命周期（至少Viewer销毁的生命周期是需要关心的）如果直接交互的对象是
Controller，由于Controller中会承担Viewer中的事件回调并派发的职责（比如，ListView item 的点击回调和点击之后对相应的逻辑进行派发、或者Viewer生命周期方法回调后的处理），所以Controller层也是需要绑定Viewer对象的生命周期的。
这里，使用Viewer生命周期回调进行抽象：
public interface OnViewerDestroyListener { void onViewerDestroy();}public interface OnViewerLifecycleListener extends OnViewerDestroyListener { void onViewerResume(); void onViewerPause();} OnViewerDestroyListener接口提供给需要关心Viewer层销毁时期的组件，如上，应该是Presenter所需要关心的。
OnViewerLifecycleListener接口提供给需要关心Viewer层生命周期回调的组件，可以根据项目需求增加更多的生命周期的方法，这里我们只关心Viewer的resume和pause。
1.1.3 Viewer层
1.1.3.1 Viewer 抽象
Viewer层，也就是表现层，当然有相关常用的UI操作，比如显示一个toast、显示/取消一个加载进度条等等。除此之外，由于Viewer层可能会直接与Presenter或者Controller层交互，所以应该还提供对这两者的绑定操作，所以如下：
public interface Viewer { Viewer bind(OnViewerLifecycleListener onViewerLifecycleListener); Viewer bind(OnViewerDestroyListener onViewerDestroyListener); Context context(); void showToast(String message); void showToast(int resStringId); void showLoadingDialog(String message); void showLoadingDialog(int resStringId); void cancelLoadingDialog();} 如上代码，两个bind()方法就是用于跟Presenter/Controller的绑定。
1.1.3.2 Viewer 委托实现
又因为，在Android中Viewer层对象可能是Activity、Fragment、View（包括ViewGroup），甚至还有自己实现的组件，当然实现的方式一般不外乎上面这几种。所以我们需要使用统一的Activity、Fragment、View，每个都需要实现Viewer接口。为了复用相关代码，这里提供默认的委托实现ViewerDelegate：
public class ViewerDelegate implements Viewer, OnViewerLifecycleListener { private Context mContext; public ViewerDelegate(Context context) { mContext = context; } private List mOnViewerDestroyListeners; private List mOnViewerLifecycleListeners; private Toast toast; private ProgressDialog loadingDialog; @Override public Viewer bind(OnViewerLifecycleListener onViewerLifecycleListener) { if (null == mOnViewerLifecycleListeners) { mOnViewerLifecycleListeners = new ArrayList<>(); mOnViewerLifecycleListeners.add(onViewerLifecycleListener); } else { if (!mOnViewerLifecycleListeners.contains(onViewerLifecycleListener)) { mOnViewerLifecycleListeners.add(onViewerLifecycleListener); } } return this; } @Override public Viewer bind(OnViewerDestroyListener onViewerDestroyListener) { if (null == mOnViewerDestroyListeners) { mOnViewerDestroyListeners = new ArrayList<>(); mOnViewerDestroyListeners.add(onViewerDestroyListener); } else { if (!mOnViewerDestroyListeners.contains(onViewerDestroyListener)) { mOnViewerDestroyListeners.add(onViewerDestroyListener); } } return this; } @Override public Context context() { return mContext; } @Override public void showToast(String message) { if (!checkViewer()) { return; } if (null == toast) { toast = Toast.makeText(mContext, "", Toast.LENGTH_SHORT); toast.setGravity(Gravity.CENTER, 0, 0); } toast.setText(message); toast.show(); } @Override public void showToast(int resStringId) { if (!checkViewer()) { return; } showToast(mContext.getString(resStringId)); } @Override public void showLoadingDialog(String message) { if (!checkViewer()) { return; } if (null == loadingDialog) { loadingDialog = new ProgressDialog(mContext); loadingDialog.setCanceledOnTouchOutside(false); } loadingDialog.setMessage(message); loadingDialog.show(); } @Override public void showLoadingDialog(int resStringId) { if (!checkViewer()) { return; } showLoadingDialog(mContext.getString(resStringId)); } @Override public void cancelLoadingDialog() { if (!checkViewer()) { return; } if (null != loadingDialog) { loadingDialog.cancel(); } } public boolean checkViewer() { return null != mContext; } @Override public void onViewerResume() { if (null != mOnViewerLifecycleListeners) { for (OnViewerLifecycleListener oll : mOnViewerLifecycleListeners) { oll.onViewerResume(); } } } @Override public void onViewerPause() { if (null != mOnViewerLifecycleListeners) { for (OnViewerLifecycleListener oll : mOnViewerLifecycleListeners) { oll.onViewerPause(); } } } @Override public void onViewerDestroy() { if (null != mOnViewerLifecycleListeners) { for (OnViewerLifecycleListener oll : mOnViewerLifecycleListeners) { oll.onViewerDestroy(); } } if (null != mOnViewerDestroyListeners) { for (OnViewerDestroyListener odl : mOnViewerDestroyListeners) { odl.onViewerDestroy(); } } mContext = null; mOnViewerDestroyListeners = null; mOnViewerLifecycleListeners = null; }} 如上代码：
它提供了默认基本的
toast、和显示/隐藏加载进度条的方法。它实现了两个重载
bind()方法，并把需要回调的OnViewerLifecycleListener和OnViewerDestroyListener对应保存在mOnViewerDestroyListeners和mOnViewerLifecycleListeners中。它实现了
OnViewerLifecycleListener接口，在回调方法中回调到每个mOnViewerDestroyListeners和mOnViewerLifecycleListeners。
mOnViewerDestroyListeners：Viewer destroy 时的回调，一般情况下只会有Presenter一个对象，但是由于一个Viewer是可以有多个Presenter的,所以可能会维护一个Presenter列表，还有可能是其他需要关心 Viewer destroy 的组件
mOnViewerLifecycleListeners：Viewer 简单的生命周期监听对象，一般情况下只有一个Controller一个对象，但是一个Viewer并不限制只有一个Controller对象,所以可能会维护一个Controller列表，还有可能是其他关心 Viewer 简单生命周期的组件
1.1.3.3 真实 Viewer 实现
然后在真实的Viewer中（这里以Activity为例，其他Fragment/View等也是一样），首先，应该实现Viewer接口，并且应该维护一个委托对象mViewerDelegate，在实现的Viewer方法中使用mViewerDelegate的具体实现。
public class BaseActivity extends AppCompatActivity implements Viewer{ private ViewerDelegate mViewerDelegate; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // ... mViewerDelegate = new ViewerDelegate(this); } @Override protected void onResume() { mViewerDelegate.onViewerResume(); super.onResume(); } @Override protected void onPause() { mViewerDelegate.onViewerPause(); super.onPause(); } @Override protected void onDestroy() { mViewerDelegate.onViewerDestroy(); super.onDestroy(); } @Override public Viewer bind(OnViewerDestroyListener onViewerDestroyListener) { mViewerDelegate.bind(onViewerDestroyListener); return this; } @Override public Viewer bind(OnViewerLifecycleListener onViewerLifecycleListener) { mViewerDelegate.bind(onViewerLifecycleListener); return this; } @Override public Context context() { return mViewerDelegate.context(); } @Override public void showToast(String message) { mViewerDelegate.showToast(message); } @Override public void showToast(int resStringId) { mViewerDelegate.showToast(resStringId); } @Override public void showLoadingDialog(String message) { mViewerDelegate.showLoadingDialog(message); } @Override public void showLoadingDialog(int resStringId) { mViewerDelegate.showLoadingDialog(resStringId); } @Override public void cancelLoadingDialog() { mViewerDelegate.cancelLoadingDialog(); }} 如上，BaseActivity构建完成。
在具体真实的Viewer实现中，包含的方法应该都是类似onXxxYyyZzz()的回调方法，并且这些回调方法应该只进行UI操作，比如onLoadMessage(List<Message> message)方法在加载完Message数据后回调该方法来进行UI的更新。
在项目中使用时，应该使用依赖注入来把Controller对象注入到Viewer中（这个后面会提到）。
@RInjectIBuyingRequestPostSucceedController controller;@Overrideprotected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // ... BuyingRequestPostSucceedView_Rapier .create() .inject(module, this); controller.bind(this);} 使用RInject通过BuyingRequestPostSucceedView_Rapier扩展类来进行注入Controller对象，然后调用Controller的bind方法进行生命周期的绑定。
1.1.4 Controller 层
1.1.4.1 Controller 抽象
前面讲过，Controller是需要关心Viewer生命周期的，所以需要实现OnViewerLifecycleListener接口。
public interface Controller extends OnViewerLifecycleListener { void bind(Viewer bindViewer);} 又提供一个bind()方法来进行对自身进行绑定到对应的Viewer上面。
1.1.4.2 Controller 实现
调用Viewer层的bind()方法来进行绑定，对生命周期进行空实现。
public class BaseController implements Controller { public void bind(Viewer bindViewer) { bindViewer.bind(this); } @Override public void onViewerResume() { // empty } @Override public void onViewerPause() { // empty } @Override public void onViewerDestroy() { // empty }} 该bind()方法除了用于绑定Viewer之外，还可以让子类重写用于做为Controller的初始化方法,但是注意重写的时候必须要调用super.bind()。
具体Controller实现中，应该只包含类似onXxxYyyZzz()的回调方法，并且这些回调方法应该都是各种事件回调，比如onClick()用于View点击事件的回调，onItemClick()表示AdapterView item点击事件的回调。
1.1.5 Presenter 层
1.1.5.1 Presenter 抽象
Presenter层，作为沟通View和Model的桥梁，它从Model层检索数据后，返回给View层，它也可以决定与View层的交互操作。
前面讲到过，View也是与Presenter直接交互的，Presenter中可能会进行很多同步、异步操作来调用Model层的代码，并且会回调到UI来进行UI的更新，所以，我们需要在Viewer层对象销毁时能够停止Presenter中执行的任务，或者执行完成后拦截UI的相关回调。
因此：
Presenter中应该也有bind()方法来进行与Viewer层的生命周期的绑定Presenter中应该提供一个方法closeAllTask()来终止或拦截掉UI相关的异步任务。
如下：
public interface Presenter extends OnViewerDestroyListener { void bind(Viewer bindViewer); void closeAllTask();} 1.1.5.2 Presenter RxJava 抽象
因为项目技术需求，需要实现对RxJava的支持，因此，这里对Presenter进行相关的扩展，提供两个方法以便于Presenter对任务的扩展。
public interface RxPresenter extends Presenter { void goSubscription(Subscription subscription); void removeSubscription(Subscription subscription);} goSubscription()方法主要用处是，订阅时缓存该订阅对象到Presenter中，便于管理（怎么管理，下面会讲到）。
removeSubscription()方法可以从Presenter中管理的订阅缓存中移除掉该订阅。
1.1.5.3 Presenter RxJava 实现
在Presenter RxJava 实现（RxBasePresenter）中，我们使用WeakHashMap来构建一个弱引用的Set，用它来缓存所有订阅。在调用goSubscription()方法中，把对应的Subscription加入到Set中，在removeSubscription()方法中，把对应的Subscription从Set中移除掉。
public class RxBasePresenter implements RxPresenter { private static final String TAG = RxBasePresenter.class.getSimpleName(); private final Set subscriptions = Collections.newSetFromMap(new WeakHashMap ()); @Override public void closeAllTask() { synchronized (subscriptions) { Iterator iter = this.subscriptions.iterator(); while (iter.hasNext()) { Subscription subscription = (Subscription) iter.next(); XLog.i(TAG, "closeAllTask[subscriptions]: " + subscription); if (null != subscription && !subscription.isUnsubscribed()) { subscription.unsubscribe(); } iter.remove(); } } } @Override public void goSubscription(Subscription subscription) { synchronized (subscriptions) { this.subscriptions.add(subscription); } } @Override public void removeSubscription(Subscription subscription) { synchronized (subscriptions) { XLog.i(TAG, "removeSubscription: " + subscription); if (null != subscription && !subscription.isUnsubscribed()) { subscription.unsubscribe(); } this.subscriptions.remove(subscription); } } @Override public void bind(Viewer bindViewer) { bindViewer.bind(this); } @Override public void onViewerDestroy() { closeAllTask(); }} 如上代码，在onViewerDestroy()回调时（因为跟Viewer生命周期进行了绑定），会调用closeAllTask把所有缓存中的Subscription取消订阅。
注意：因为缓存中使用了弱引用，所以上面的
removeSubscription不需要再去手动调用，在订阅completed后，gc自然会回收掉没有强引用指向的Subscription对象。
1.1.5.4 Presenter 具体实现
在Presenter具体的实现中，同样依赖注入各种来自Model层的Interactor/Api（网络、数据库、文件等等），然后订阅这些对象返回的Observable，然后进行订阅，并调用goSubscription()缓存Subscription：
public class BuyingRequestPostSucceedPresenter extends RxBasePresenter implements IBuyingRequestPostSucceedPresenter { private IBuyingRequestPostSucceedView viewer; @RInject ApiSearcher apiSearcher; public BuyingRequestPostSucceedPresenter(IBuyingRequestPostSucceedView viewer, BuyingRequestPostSucceedPresenterModule module) { this.viewer = viewer; // inject BuyingRequestPostSucceedPresenter_Rapier .create() .inject(module, this); } @Override public void loadSomeThing(final String foo, final String bar) { goSubscription( apiSearcher.searcherSomeThing(foo, bar) .compose(TransformerBridge. >subscribeOnNet()) .map(new Func1 , SomeThing>() { @Override public SomeThing call(OceanServerResponse response) { return response.getBody(); } }) .compose(TransformerBridge. observableOnMain()) .subscribe(new Subscriber () { @Override public void onError(Throwable e) { XLog.e(TAG, "", e); } @Override public void onNext(SomeThing someThing) { XLog.d(TAG, "XLog onNext..."); viewer.onLoadSomeThing(someThing); } @Override public void onCompleted() { } }) ); } // ... } 1.1.6 Model 层
暂不讨论。
1.2 针对 MVP 进行依赖注入
上面提到，Viewer、Controller和Presenter中都使用了RInject注解来进行依赖的注入。
这里并没有使用其他第三方实现的DI框架，比如Dagger/Dagger2等，而是自己实现的，它的原理与Dagger2类似，会在编译时期生成一些扩展扩展类来简化代码，比如前面的BuyingRequestPostSucceedView_Rapier、BuyingRequestPostSucceedPresenter_Rapier、BuyingRequestPostSucceedController_Rapier等。它也支持Named、Lazy等功能，但是它比Dagger2更加轻量，Module的使用方式更加简单，更加倾向于对Module的复用，更强的可控性，但是由于这次的重构主要是基于在兼容旧版本的情况下使用，暂时没有加上Scope的支持。
之后再针对这个Rapier库进行详细讨论。
1.3 针对 MVP 进行单元测试
这里主要还是讨论针对Viewer和Presenter的单元测试。
1.3.1 针对 Viewer 进行单元测试
针对Viewer进行单元测试，这里不涉及任何业务相关的逻辑，而且，Viewer层的测试都是UI相关，必须要Android环境，所以需要在手机或者模拟器安装一个test apk，然后进行测试。
为了不被Viewer中的Controller和Presenter的逻辑所干扰，我们必须要mock掉Viewer中的Controller和Presenter对象，又因为Controller对象是通过依赖注入的方式提供的，也就是来自Rapier中的Module，所以，我们只需要mock掉Viewer对应的module。
1.3.1.1 如果 Viewer 是 View
如果Viewer层是由View实现的，比如继承FrameLayout。这个时候，测试时，就必须要放在一个Activity中测试（Fragment也一样，也必须依赖于Activity），所以我们应该有一个专门用于测试View/Fragment的Activity —— TestContainerActivity，如下：
public class TestContainerActivity extends BaseActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); }} 记得在AndroidManifest.xml中注册。
前面说过，我们需要mock掉Module。
如果Viewer是View，mock掉Module就非常容易了，只要在View中提供一个传入mock的Module的构造方法即可，如下：
@VisibleForTestingpublic BuyingRequestPostSucceedView(Context context, BuyingRequestPostSucceedModule module) { super(context); // inject BuyingRequestPostSucceedView_Rapier .create() .inject(module, this);} 如上代码，这里为测试专门提供了一个构造方法来进行对Module的mock，之后的测试如下：
BuyingRequestPostSucceedView requestPostSucceedView;@Rulepublic ActivityTestRulemActivityTestRule = new ActivityTestRule (TestContainerActivity.class) { @Override protected void afterActivityLaunched() { super.afterActivityLaunched(); final TestContainerActivity activity = getActivity(); logger("afterActivityLaunched"); activity.runOnUiThread(new Runnable() { @Override public void run() { BuyingRequestPostSucceedModule module = mock(BuyingRequestPostSucceedModule.class); when(module.pickController()).thenReturn(mock(IBuyingRequestPostSucceedController.class)); requestPostSucceedView = new BuyingRequestPostSucceedView(activity, module); activity.setContentView(requestPostSucceedView); } }); } }; @Test public void testOnLoadSomeThings() { final SomeThings products = mock(SomeThings.class); ArrayList list = mock(ArrayList.class); SomeThing product = mock(SomeThing.class); when(list.get(anyInt())).thenReturn(product); products.productList = list; TestContainerActivity activity = mActivityTestRule.getActivity(); when(list.size()).thenReturn(1); when(list.isEmpty()).thenReturn(false); activity.runOnUiThread(new Runnable() { @Override public void run() { requestPostSucceedView.onLoadSomeThing(products); } }); onView(withId(R.id.id_tips_you_may_also_like_tv)).check(matches(isDisplayed())); // ... }
如上代码，在TestContainerActivity启动后，构造一个mock了Module的待测试View，并增加到Activity的content view中。
1.3.1.2 如果 Viewer 是 Activity
如果Viewer是Activity，由于它本来就是Activity，所以它不需要借助TestContainerActivity来测试；mock module时就不能使用构造方法的方式了，因为我们是不能直接对Activity进行实例化的，那应该怎么办呢？
一般情况下，我们会在调用onCreate方法的时候去进行对依赖的注入，也就是调用XxxYyyZzz_Rapier扩展类，而且，如果这个Activity需要在一启动就去进行一些数据请求，我们要拦截掉这个请求，因为这个请求返回的数据可能会对我们的UI测试造成干扰，所以我们需要在onCreate在被调用之前把module mock掉。
首先看test support 中的 ActivityTestRule这个类，它提供了以下几个方法：
getActivityIntent()：这个方法只能在Intent中增加携带的参数，我们要mock的是整个Module，无法序列化，所以也无法通过这个传入。beforeActivityLaunched()：这个方法回调时，Activity实例还没有生成，所以无法拿到Activity实例，并进行Module的替换。afterActivityFinished()：这个方法就更不可能了-.-afterActivityLaunched()：这个方法看它的源码（无关代码已省略）：
public T launchActivity(@Nullable Intent startIntent) { // ... beforeActivityLaunched(); // The following cast is correct because the activity we're creating is of the same type as // the one passed in mActivity = mActivityClass.cast(mInstrumentation.startActivitySync(startIntent)); mInstrumentation.waitForIdleSync(); afterActivityLaunched(); return mActivity; } 如上代码，afterActivityLaunched()方法是在真正启动Activity（mInstrumentation.startActivitySync(startIntent)）后调用的。但是显然这个方法是同步的，之后再进入源码，来查看启动的流程，整个流程有些复杂我就不赘述了，可以查看我以前写的分析启动流程的博客（），最后会调用mInstrumentation.callActivityOnCreate(...)。
但是因为测试时，启动Activity的过程也是同步的，所以显然这个方法是在onCreate()被调用后才会被回调的，所以，这个方法也不行。
既然貌似已经找到了mock的正确位置，那就继续分析下去：
这里的mInstrumentation是哪个Instrumentation实例呢？
我们回到ActivityTestRule中：
public ActivityTestRule(ClassactivityClass, boolean initialTouchMode, boolean launchActivity) { mActivityClass = activityClass; mInitialTouchMode = initialTouchMode; mLaunchActivity = launchActivity; mInstrumentation = InstrumentationRegistry.getInstrumentation(); }
继续进入InstrumentationRegistry.getInstrumentation()：
public static Instrumentation getInstrumentation() { Instrumentation instance = sInstrumentationRef.get(); if (null == instance) { throw new IllegalStateException("No instrumentation registered! " + "Must run under a registering instrumentation."); } return instance;} 继续查找sInstrumentationRef是在哪里set进去的：
public static void registerInstance(Instrumentation instrumentation, Bundle arguments) { sInstrumentationRef.set(instrumentation); sArguments.set(new Bundle(arguments));} 继续查找调用，终于在MonitoringInstrumentation中找到：
@Overridepublic void onCreate(Bundle arguments) { // ... InstrumentationRegistry.registerInstance(this, arguments); // ...} 所以，测试使用的MonitoringInstrumentation，然后进入MonitoringInstrumentation的callActivityOnCreate()方法：
@Overridepublic void callActivityOnCreate(Activity activity, Bundle bundle) { mLifecycleMonitor.signalLifecycleChange(Stage.PRE_ON_CREATE, activity); super.callActivityOnCreate(activity, bundle); mLifecycleMonitor.signalLifecycleChange(Stage.CREATED, activity); } 既然我们需要在Activity真正执行onCreate()方法时拦截掉，那如上代码，只要关心signalLifecycleChange()方法，发现了ActivityLifecycleCallback的回调：
public void signalLifecycleChange(Stage stage, Activity activity) { // ... Iterator > refIter = mCallbacks.iterator(); while (refIter.hasNext()) { ActivityLifecycleCallback callback = refIter.next().get(); if (null == callback) { refIter.remove(); } else { // ... callback.onActivityLifecycleChanged(activity, stage); // ... }} 所以，问题解决了，我们只要添加一个Activity生命周期回调就搞定了，代码如下：
ActivityLifecycleMonitorRegistry.getInstance().addLifecycleCallback(new ActivityLifecycleCallback() { @Override public void onActivityLifecycleChanged(Activity activity, Stage stage) { logger("onActivityLifecycleChanged, activity" + activity + ", stage: " + stage); if(activity instanceof SomethingActivity && Stage.PRE_ON_CREATE == stage){ logger("onActivityLifecycleChanged, got it!!!"); ((SomethingActivity)activity).setModule(mock(SomethingModule.class)); } }}); 至此，Activity的 mock module成功了。
1.3.2 针对 Presenter 进行单元测试
1.3.2.1 测试与 Android SDK 分离
Presenter 的单元测试与 Viewer 不一样，在Presenter中不应该有Android SDK相关存在，所有的Inteactor/Api等都是与Android解耦的。显然更加不能有TextView等存在。正是因为这个，使得它可以基于PC上的JVM来进行单元测试，也就是说，Presenter测试不需要Android环境，省去了安装到手机或者模拟器的步骤。
怎么去避免Anroid相关的SDK在Presenter中存在？
的确有极个别的SDK很难避免，比如Log。
1.3.2.1.1 使用 XLog 与 Log 分离
所以，我们需要一个XLog：
public class XLog { private static IXLog delegate; private static boolean DEBUG = true; public static void setDebug(boolean debug) { XLog.DEBUG = debug; } public static void setDelegate(IXLog delegate) { XLog.delegate = delegate; } public static void v(String tag, String msg) { if (DEBUG && null != delegate) { delegate.v(tag, msg); } } public static void v(String tag, String msg, Throwable tr) { if (DEBUG && null != delegate) { delegate.v(tag, msg, tr); } } public static void d(String tag, String msg) { if (DEBUG && null != delegate) { delegate.d(tag, msg); } } // ... 在Android环境中使用的策略：
XLog.setDelegate(new XLogDef());
其中XLogDef类中的实现为原生Androd SDK的Log实现。
在测试环境中使用的策略：
logDelegateSpy = Mockito.spy(new XLogJavaTest());XLog.setDelegate(logDelegateSpy);
其中XLogJavaTest使用的是纯Java的System.out.println()
1.3.2.2 异步操作同步化
因为Presenter中会有很多的异步任务存在，但是在细粒度的单元测试中，没有异步任务存在的必要性，相应反而增加了测试复杂度。所以，我们应该把所有异步任务切换成同步操作。
调度的切换使用的是RxJava，所以所有切换到主线程也是使用了Android SDK。这里也要采用策略进行处理。
首先定义了几种不同的ScheduleType：
public class SchedulerType { public static final int MAIN = 0x3783; public static final int NET = 0x8739; public static final int DB = 0x1385; // ...} 在Schedule选择器中根据ScheduleType进行对应类型的实现：
SchedulerSelector schedulerSelector = SchedulerSelector.get();schedulerSelector.putScheduler(SchedulerType.MAIN, new SchedulerSelector.SchedulerCreation() { @Override public Scheduler create() { return AndroidSchedulers.mainThread(); }});schedulerSelector.putScheduler(SchedulerType.NET, new SchedulerSelector.SchedulerCreation () { @Override public Scheduler create() { return Schedulers.from(THREAD_POOL_EXECUTOR_NETWORK); }});schedulerSelector.putScheduler(SchedulerType.DB, new SchedulerSelector.SchedulerCreation () { @Override public Scheduler create() { return Schedulers.from(THREAD_POOL_EXECUTOR_DATABASE); }});// ...
当测试时，对调度选择器中的不同类型的实现进行如下替换：
SchedulerSelector.get().putScheduler(SchedulerType.NET, new SchedulerSelector.SchedulerCreation() { @Override public Scheduler create() { return Schedulers.immediate(); }});SchedulerSelector.get().putScheduler(SchedulerType.MAIN, new SchedulerSelector.SchedulerCreation () { @Override public Scheduler create() { return Schedulers.immediate(); }});
把所有调度都改成当前线程执行即可。
最后Presenter测试几个范例：
@Mock AccountContract.IAccountViewer viewer; @Mock UserInteractor userInteractor; AccountPresenter presenter; @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); presenter = new AccountPresenter(viewer); presenter.userInteractor = userInteractor; } @Test public void requestEditUserInfo() throws Exception { // case 1, succeed reset(viewer); resetLog(); when(userInteractor.requestEditUserInfo(any(User.class))).thenReturn(Observable.just(anyBoolean())); presenter.requestEditUserInfo(new User()); verifyOnce(viewer).onRequestEditUserInfo(); // case 2, null reset(viewer); resetLog(); when(userInteractor.requestEditUserInfo(any(User.class))).thenReturn(Observable.just(null)); presenter.requestEditUserInfo(new User()); verifyOnce(viewer).onRequestEditUserInfo(); // case 3, error assertFailedAndError(() -> userInteractor.requestEditUserInfo(any(User.class)), () -> presenter.requestEditUserInfo(new User())); } public class SBuyingRequestPostSucceedViewPresenterTest extends BaseJavaTest { @Mock public IBuyingRequestPostSucceedView viewer; @Mock public BuyingRequestPostSucceedPresenterModule module; @Mock public ApiSearcher apiSearcher; public IBuyingRequestPostSucceedPresenter presenter; @Before public void setUp() { MockitoAnnotations.initMocks(this); when(module.pickApiSearcher()).thenReturn(apiSearcher); presenter = new BuyingRequestPostSucceedPresenter(viewer, module); } @Test public void testLoadSomethingSuccess() throws TimeoutException { // Mock success observable when(apiSearcher.searcherSomething(anyString(), anyString(), anyString())) .thenReturn(Observable.create(new Observable.OnSubscribe >() { @Override public void call(Subscriber > subscriber) { try { OceanServerResponse oceanServerResponse = mock(OceanServerResponse.class); when(oceanServerResponse.getBody(any(Class.class))).thenReturn(mock(Something.class)); subscriber.onNext(oceanServerResponse); subscriber.onCompleted(); } catch (Throwable throwable) { subscriber.onError(throwable); } }I })); final ExecuteStuff executeStuff = new ExecuteStuff(); Answer succeedAnswer = new Answer() { @Override public Object answer(InvocationOnMock invocationOnMock) throws Throwable { loggerMockAnswer(invocationOnMock); executeStuff.setSucceed(true); return null; } }; doAnswer(succeedAnswer).when(viewer).onLoadSomething(Matchers.any(Something.class)); presenter.loadSomething("whatever", "whatever"); logger("loadSomething result: " + executeStuff.isSucceed()); Assert.assertTrue("testLoadSomethingSuccess result true", executeStuff.isSucceed()); } @Test public void testLoadSomethingFailed() throws TimeoutException { // Mock error observable when(apiSearcher.searcherRFQInterestedProductsSuggestion(anyString(), anyString(), anyString())) .thenReturn(Observable. >error(new RuntimeException("mock error observable"))); final ExecuteStuff executeStuff = new ExecuteStuff(); Answer failedAnswer = new Answer() { @Override public Object answer(InvocationOnMock invocationOnMock) throws Throwable { loggerMockAnswer(invocationOnMock); executeStuff.setSucceed(false); return null; } }; doAnswerWhenLogError(failedAnswer); presenter.loadSomething("whatever", "whatever"); logger("testLoadSomethingFailed result: " + executeStuff.isSucceed()); Assert.assertFalse("testLoadSomethingFailed result false", executeStuff.isSucceed()); }}