55

我有一个使用 Dagger 2 进行依赖注入的 Android 应用程序。我还在使用最新的 gradle 构建工具，它允许构建变体用于单元测试和一个用于仪器测试。我java.util.Random在我的应用程序中使用，我想模拟它进行测试。我正在测试的类不使用任何 Android 的东西，所以它们只是普通的 java 类。

在我的主要代码中，我Component在扩展类的类中定义了 a Application，但在单元测试中我没有使用Application. 我尝试定义一个测试Moduleand Component，但 Dagger 不会生成Component. 我也尝试过使用Component我在我的应用程序中定义的并Module在构建它时交换它，但是应用程序Component没有inject我的测试类的方法。如何提供Random用于测试的模拟实现？

这是一些示例代码：

应用：

public class PipeGameApplication extends Application {

    private PipeGame pipeGame;

    @Singleton
    @Component(modules = PipeGameModule.class)
    public interface PipeGame {
        void inject(BoardFragment boardFragment);
        void inject(ConveyorFragment conveyorFragment);
    }

    @Override
    public void onCreate() {
        super.onCreate();
        pipeGame = DaggerPipeGameApplication_PipeGame.create();
    }

    public PipeGame component() {
        return pipeGame;
    }
}

模块：

@Module
public class PipeGameModule {

    @Provides
    @Singleton
    Random provideRandom() {
        return new Random();
    }
}

测试的基类：

public class BaseModelTest {

    PipeGameTest pipeGameTest;

    @Singleton
    @Component(modules = PipeGameTestModule.class)
    public interface PipeGameTest {
        void inject(BoardModelTest boardModelTest);
        void inject(ConveyorModelTest conveyorModelTest);
    }

    @Before
    public void setUp() {
        pipeGameTest = DaggerBaseModelTest_PipeGameTest.create(); // Doesn't work
    }

    public PipeGameTest component() {
        return pipeGameTest;
    }
}

或者：

public class BaseModelTest {

    PipeGameApplication.PipeGame pipeGameTest;

    // This works if I make the test module extend
    // the prod module, but it can't inject my test classes
    @Before
    public void setUp() {
        pipeGameTest = DaggerPipeGameApplication_PipeGame.builder().pipeGameModule(new PipeGameModuleTest()).build();
    }

    public PipeGameApplication.PipeGame component() {
        return pipeGameTest;
    }
}

测试模块：

@Module
public class PipeGameTestModule {

    @Provides
    @Singleton
    Random provideRandom() {
        return mock(Random.class);
    }
}
4

5 回答 5

30

如果没有一些变通方法，目前使用 Dagger 2（从 v2.0.0 开始）是不可能的。你可以在这里阅读。

有关可能的解决方法的更多信息：

于 2015-05-05T16:06:00.407 回答
7

您说：

应用程序的组件没有我的测试类的注入方法

因此，为了解决这个问题，我们可以为您的 Application 类制作一个测试版本。然后我们可以有你的模块的测试版本。为了让它在测试中运行，我们可以使用 Robolectric。

1）创建应用程序类的测试版本

public class TestPipeGameApp extends PipeGameApp {
    private PipeGameModule pipeGameModule;

    @Override protected PipeGameModule getPipeGameModule() {
        if (pipeGameModule == null) {
            return super.pipeGameModule();
        }
        return pipeGameModule;
    }

    public void setPipeGameModule(PipeGameModule pipeGameModule) {
        this.pipeGameModule = pipeGameModule;
        initComponent();
    }}

2) 你原来的 Application 类需要有initComponent()和pipeGameModule()方法

public class PipeGameApp extends Application {
    protected void initComponent() {
        DaggerPipeGameComponent.builder()
            .pipeGameModule(getPipeGameModule())
            .build();
    }

    protected PipeGameModule pipeGameModule() {
        return new PipeGameModule(this);
    }}

3) 您的 PipeGameTestModule 应该使用构造函数扩展生产模块：

public class PipeGameTestModule extends PipeGameModule {
    public PipeGameTestModule(Application app) {
        super(app);
    }}

4) 现在，在您的 junit 测试的setup()方法中，在您的测试应用程序上设置此测试模块：

@Before
public void setup() {
    TestPipeGameApp app = (TestPipeGameApp) RuntimeEnvironment.application;
    PipeGameTestModule module = new PipeGameTestModule(app);
    app.setPipeGameModule(module);
}

现在您可以按照您最初想要的方式自定义您的测试模块。

于 2016-04-04T00:45:30.403 回答
2

在我看来，您可以通过从不同的角度看待这个问题来解决这个问题。您将能够轻松地对您的类进行单元测试，而不是依赖 Dagger 来构建被测构造类，并将其模拟依赖项注入其中。

我的意思是，在测试设置中，您可以：

  • 模拟被测类的依赖关系
  • 使用模拟的依赖项手动构建被测类

我们不需要测试依赖项是否被正确注入，因为 Dagger 在编译期间会验证依赖关系图的正确性。因此，任何此类错误都会因编译失败而报告。这就是为什么在 setup 方法中手动创建被测类应该是可以接受的。

在被测类中使用构造函数注入依赖项的代码示例： 

public class BoardModelTest {

  private BoardModel boardModel;
  private Random random;

  @Before
  public void setUp() {
    random = mock(Random.class);
    boardModel = new BoardModel(random);
  }

  @Test
  ...
}

public class BoardModel {
  private Random random;

  @Inject
  public BoardModel(Random random) {
    this.random = random;
  }

  ...
}

使用被测类中的字段注入依赖项的代码示例（如果BoardModel由框架构造）： 

public class BoardModelTest {

  private BoardModel boardModel;
  private Random random;

  @Before
  public void setUp() {
    random = mock(Random.class);
    boardModel = new BoardModel();
    boardModel.random = random;
  }

  @Test
  ...
}

public class BoardModel {
  @Inject
  Random random;

  public BoardModel() {}

  ...
}
于 2015-05-05T17:37:47.590 回答
1

如果你在 Android 上使用 dagger2，你可以使用 app flavor 来提供模拟资源。

在此处查看模拟测试中的风味演示（不带匕首）： https ://www.youtube.com/watch?v=vdasFFfXKOY

这个代码库有一个例子： https ://github.com/googlecodelabs/android-testing

在您的/src/prod/com/yourcompany/Component.java 中 ，您提供生产组件。

在您的/src/mock/com/yourcompany/Component.java 中 ，您提供模拟组件。

这允许您创建带有或不带有模拟的应用程序的构建。它还允许并行开发（一个团队的后端，另一个团队的前端应用程序），您可以模拟直到 api 方法可用。

我的 gradle 命令看起来如何（它是一个 Makefile）：

install_mock:
    ./gradlew installMockDebug

install:
    ./gradlew installProdDebug

test_unit:
    ./gradlew testMockDebugUnitTest

test_integration_mock:
    ./gradlew connectedMockDebugAndroidTest

test_integration_prod:
    ./gradlew connectedProdDebugAndroidTest
于 2016-02-26T14:02:59.090 回答
0

我实际上遇到了同样的问题，并找到了一个非常简单的解决方案。我认为这不是最好的解决方案，但它会解决您的问题。

在您的应用模块中创建一个类似的类：

public class ActivityTest<T extends ViewModelBase> {

    @Inject
    public T vm;
}

然后，在您的 AppComponent 中添加：

void inject(ActivityTest<LoginFragmentVM> activityTest);

然后你就可以在你的测试类中注入它。

 public class HelloWorldEspressoTest extends ActivityTest<LoginFragmentVM> {

    @Rule
    public ActivityTestRule<MainActivity> mActivityRule = new ActivityTestRule(MainActivity.class);

    @Test
    public void listGoesOverTheFold() throws InterruptedException {
        App.getComponent().inject(this);
        vm.email.set("1234");
        closeSoftKeyboard();
    }
}
于 2017-07-30T15:15:45.607 回答