使用mockito和spy进行单元测试导致错误

Question

我正在使用Mockito和Spy对函数进行单元测试。

这是正在测试的类：

public class RecipeListModelImp
        implements RecipeListModelContract {

    private Subscription subscription;
    private RecipesAPI recipesAPI;

    @Inject
    public RecipeListModelImp(@NonNull RecipesAPI recipesAPI) {
        this.recipesAPI = Preconditions.checkNotNull(recipesAPI);
    }

    @Override
    public void getRecipesFromAPI(final RecipeGetAllListener recipeGetAllListener) {
        subscription = recipesAPI.getAllRecipes()
               .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<List<Recipe>>() {
                    @Override
                    public void onCompleted() {
                              }
                    @Override

                    public void onError(Throwable e) {
                                  recipeGetAllListener.onRecipeGetAllFailure(e.getMessage());

                    }


                    @Override

                    public void onNext(List<Recipe> recipe) {                       recipeGetAllListener.onRecipeGetAllSuccess(recipe);
                    }
                });
    }

    @Override
    public void shutdown() {
        if(subscription != null && !subscription.isUnsubscribed()) {
            subscription.unsubscribe();
        }
    }
}

我正在尝试使用Mockito和spy进行测试，因为我不想调用真正的函数recipesAPI。getAllRecipes（）只需验证一下即可。该测试称为testGetRecipesFromAPI（）

public class RecipeListModelImpTest {
    @Mock Subscription subscription;
    @Mock RecipesAPI recipesAPI;
    @Mock RecipeListModelContract.RecipeGetAllListener recipeGetAllListener;

    private RecipeListModelContract recipeListModel;

    @Before
    public void setup() {
        MockitoAnnotations.initMocks(RecipeListModelImpTest.this);
        recipeListModel = new RecipeListModelImp(recipesAPI);
    }

    @Test
    public void testGetRecipesFromAPI() {
        RecipeListModelContract recipeListModelSpy = spy(recipeListModel);
        RecipesAPI recipeApiSpy = spy(recipesAPI);
        doNothing().when(recipeApiSpy).getAllRecipes();

        recipeListModelSpy.getRecipesFromAPI(recipeGetAllListener);

        verify(recipesAPI, times(1)).getAllRecipes();

    }

    @Test
    public void testShouldShutdown() {
        recipeListModel.shutdown();
        verify(subscription, times(1)).unsubscribe();
    }
}

这是错误：

org.mockito.exceptions.base.MockitoException: 
Only void methods can doNothing()!
Example of correct use of doNothing():
    doNothing().
    doThrow(new RuntimeException())
    .when(mock).someVoidMethod();
Above means:
someVoidMethod() does nothing the 1st time but throws an exception the 2nd time is called

我也尝试过这样做，它会导致空指针：

  @Test
    public void testGetRecipesFromAPI() {
        RecipeListModelContract recipeListModelSpy = spy(recipeListModel);
        RecipesAPI recipeApiSpy = spy(recipesAPI);

        doReturn(Observable.just(Subscription.class)).when(recipeApiSpy).getAllRecipes();

        recipeListModelSpy.getRecipesFromAPI(recipeGetAllListener);

        verify(recipesAPI, times(1)).getAllRecipes();
    }

Answer 1

您正在混合间谍（部分模拟）和模拟（完全模拟）。这是不必要的-Spy允许混合模拟和实际方法调用，但不需要任何部分模拟。在你的情况下，你要么是完全嘲笑，要么不是嘲笑。Mockito的文档中有更多关于模拟和间谍活动的信息。

在第一个示例中，错误是您试图对返回某个内容的方法执行任何操作。莫基托不允许这样。你在第二个例子中所做的几乎是正确的。

对于第二个示例，问题是设置getAllRecipes（）以返回可观察的。只是（Subscription.class）但是您仍然拥有在测试单元中调用的整个方法链：subscriptbeon，observeOn，以及subscripte。您还需要模拟这些调用，以返回可以使用的模拟对象，或使用抛出NullPointerException的调用。

@Test
public void testGetRecipesFromAPI() { 
    //recipesAPI.getAllRecipes() needs to be mocked to return something (likely a mock)
    // so subscribeOn can be called.
    //That needs to be mocked to return something so observeOn can be called
    //etc.

    recipeListModel.getRecipesFromAPI(recipeGetAllListener);

    verify(recipesAPI, times(1)).getAllRecipes();
}

Answer 2

就像你写的

订阅=配方API。getAllRecipes（）。subscribeOn（Schedulers.io（））

然后方法getAllRecipes（）返回一些对象，你不能使用

多诺辛（）。当（收到）时。getAllRecipes（）；

doNothing（）-它用于返回void的方法。

变体正确：

doReturn（doReturn（Observable.just（Subscription.class））。当（收到）时。getAllRecipes（）

Answer 3

代码中的问题是这一部分：subscribeOn（Schedulers.io（））。如果我们能够消除这一点，那么我们就可以从recipesAPI返回测试数据，并测试该数据是否由recipeGetAllListener正确处理。

因此，我们必须以某种方式创建一个seam：如果这是一个生产代码，那么使用调度程序。io（）。mainThread（），如果这是一个测试代码，那么使用一些特定的调度程序。

让我们声明一个接口，它将提供Schedulers:

    interface SchedulersProvider {
        Scheduler getWorkerScheduler();
        Scheduler getUiScheduler();
    }

现在，让我们使RecipeListModelLimp依赖于SchedulerProvider：

    public class RecipeListModelImp implements RecipeListModelContract {

        ...
        private SchedulersProvider schedulersProvider;

        @Inject
        public RecipeListModelImp(@NonNull RecipesAPI recipesAPI, 
                                  @NonNull SchedulersProvider schedulerProvider) {
            ...
            this.schedulersProvider = schedulersProvider;
        }

        ...
    }

现在，我们将替换调度器：

    @Override
    public void getRecipesFromAPI(final RecipeGetAllListener recipeGetAllListener) {
        subscription = recipesAPI.getAllRecipes()
                                 .subscribeOn(schedulersProvider.getWorkerScheduler())
                                 .observeOn(schedulersProvider.getUiScheduler())
                                 ...
    }

现在是提供SchedulerProvider的时候了：

    @Module
    public class MyModule {
        ...
        @Provides public SchedulerProvider provideSchedulerProvider() {
            return new SchedulerProvider() {
                @Override
                Scheduler getWorkerScheduler() {
                    return Schedulers.io();
                }

                @Override
                Scheduler getUiScheduler() {
                    return AndroidSchedulers.mainThread();
                }
            }
        }
    }

现在让我们创建另一个模块-TestModule，它将为测试类提供依赖关系。TestModule将扩展MyModule并覆盖提供SchedulerProvider的方法：

    public class TestModule extends MyModule {
        @Override public SchedulerProvider provideSchedulerProvider() {
            return new SchedulerProvider() {
                @Override
                Scheduler getScheduler() {
                    return Schedulers.trampoline();
                }

                @Override
                Scheduler getUiScheduler() {
                    return Schedulers.trampoline();
                }
            }
        }
    }

调度程序。trampoline（）将在当前线程上执行任务。

现在是创建测试组件的时候了：

    @Component(modules = MyModule.class)
    public interface TestComponent extends MyComponent {
        void inject(RecipeListModelImpTest test);
    }

现在在测试课上：

    public class RecipeListModelImpTest {

        @Mock RecipesAPI recipesAPI;
        @Mock RecipeListModelContract.RecipeGetAllListener recipeGetAllListener;

        @Inject SchedulerProvider schedulerProvider;

        private RecipeListModelContract recipeListModel;

        @Before
        public void setup() {
            TestComponent component = DaggerTestComponent.builder()
                                                         .myModule(new TestModule())
                                                         .build();
            component.inject(this);

            MockitoAnnotations.initMocks(this);
            recipeListModel = new RecipeListModelImp(recipesAPI, schedulerProvider);
        }
        ...
    }

以及实际测试部分：

    private static final List<Recipe> TEST_RECIPES = new ArrayList<Recipe>() {
        {
            add(new Recipe(1)),
            add(new Recipe(2))
        }
    };

    @Test
    public void testGetRecipesFromAPI() {
        when(recipeAPI.getAllRecipes())
            .thenReturn(Observable.fromIterable(TEST_RECIPES));

        recipeListModel.getRecipesFromAPI(recipeGetAllListener);

        // verifying, that `recipeAPI.getAllRecipes()` has been called once
        verify(recipeAPI).getAllRecipes();

        // verifying, that we received correct result
        verify(recipeGetAllListener).onRecipeGetAllSuccess(TEST_RECIPES);
    }