How do you override a module/dependency in a unit test with Dagger 2.0?

As @EpicPandaForce rightly says, you can't extend Modules. However, I came up with a sneaky workaround for this which I think avoids a lot of the boilerplate which the other examples suffer from.

The trick to 'extending' a Module is to create a partial mock, and mock out the provider methods which you want to override.

Using Mockito:

MyModule module = Mockito.spy(new MyModule()); Mockito.doReturn("mocked string").when(module).provideString(); MyComponent component = DaggerMyComponent.builder() .myModule(module) .build(); app.setComponent(component); 

I created this gist here to show a full example.

EDIT

It turns out you can do this even without a partial mock, like so:

MyComponent component = DaggerMyComponent.builder() .myModule(new MyModule() { @Override public String provideString() { return "mocked string"; } }) .build(); app.setComponent(component); 

The workaround proposed by @tomrozb is very good and put me on the right track, but my problem with it was that it exposed a setTestComponent() method in the PRODUCTION Application class. I was able to get this working slightly differently, such that my production application doesn't have to know anything at all about my testing environment.

TL;DR - Extend your Application class with a test application that uses your test component and module. Then create a custom test runner that runs on the test application instead of your production application.

EDIT: This method only works for global dependencies (typically marked with @Singleton). If your app has components with different scope (e.g. per activity) then you'll either need to create subclasses for each scope, or use @tomrozb's original answer. Thanks to @tomrozb for pointing this out!

This example uses the AndroidJUnitRunner test runner but this could probably be adapted to Robolectric and others.

First, my production application. It looks something like this:

public class MyApp extends Application { protected MyComponent component; public void setComponent() { component = DaggerMyComponent.builder() .myModule(new MyModule()) .build(); component.inject(this); } public MyComponent getComponent() { return component; } @Override public void onCreate() { super.onCreate(); setComponent(); } } 

This way, my activities and other class that use @Inject simply have to call something like getApp().getComponent().inject(this); to inject themselves into the dependency graph.

For completeness, here is my component:

@Singleton @Component(modules = {MyModule.class}) public interface MyComponent { void inject(MyApp app); // other injects and getters } 

And my module:

@Module public class MyModule { // EDIT: This solution only works for global dependencies @Provides @Singleton public MyClass provideMyClass() { ... } // ... other providers } 

For the testing environment, extend your test component from your production component. This is the same as in @tomrozb's answer.

@Singleton @Component(modules = {MyTestModule.class}) public interface MyTestComponent extends MyComponent { // more component methods if necessary } 

And the test module can be whatever you want. Presumably you'll handle your mocking and stuff in here (I use Mockito).

@Module public class MyTestModule { // EDIT: This solution only works for global dependencies @Provides @Singleton public MyClass provideMyClass() { ... } // Make sure to implement all the same methods here that are in MyModule, // even though it's not an override. } 

So now, the tricky part. Create a test application class that extends from your production application class, and override the setComponent() method to set the test component with the test module. Note that this can only work if MyTestComponent is a descendant of MyComponent.

public class MyTestApp extends MyApp { // Make sure to call this method during setup of your tests! @Override public void setComponent() { component = DaggerMyTestComponent.builder() .myTestModule(new MyTestModule()) .build(); component.inject(this) } } 

Make sure you call setComponent() on the app before you begin your tests to make sure the graph is set up correctly. Something like this:

@Before public void setUp() { MyTestApp app = (MyTestApp) getInstrumentation().getTargetContext().getApplicationContext(); app.setComponent() ((MyTestComponent) app.getComponent()).inject(this) } 

Finally, the last missing piece is to override your TestRunner with a custom test runner. In my project I was using the AndroidJUnitRunner but it looks like you can do the same with Robolectric.

public class TestRunner extends AndroidJUnitRunner { @Override public Application newApplication(@NonNull ClassLoader cl, String className, Context context) throws InstantiationException, IllegalAccessException, ClassNotFoundException { return super.newApplication(cl, MyTestApp.class.getName(), context); } } 

You'll also have to update your testInstrumentationRunner gradle, like so:

testInstrumentationRunner "com.mypackage.TestRunner" 

And if you're using Android Studio, you'll also have to click Edit Configuration from the run menu and enter the name of your test runner under "Specific instrumentation runner".

And that's it! Hopefully this information helps somebody :)

It seems I've found yet another way and it's working so far.

First, a component interface that is not a component itself:

MyComponent.java

interface MyComponent { Foo provideFoo(); } 

Then we have two different modules: actual one and testing one.

MyModule.java

@Module class MyModule { @Provides public Foo getFoo() { return new Foo(); } } 

TestModule.java

@Module class TestModule { private Foo foo; public void setFoo(Foo foo) { this.foo = foo; } @Provides public Foo getFoo() { return foo; } } 

And we have two components to use these two modules:

MyRealComponent.java

@Component(modules=MyModule.class) interface MyRealComponent extends MyComponent { Foo provideFoo(); // without this dagger will not do its magic } 

MyTestComponent.java

@Component(modules=TestModule.class) interface MyTestComponent extends MyComponent { Foo provideFoo(); } 

In application we do this:

MyComponent component = DaggerMyRealComponent.create(); <...> Foo foo = component.getFoo(); 

While in test code we use:

TestModule testModule = new TestModule(); testModule.setFoo(someMockFoo); MyComponent component = DaggerMyTestComponent.builder() .testModule(testModule).build(); <...> Foo foo = component.getFoo(); // will return someMockFoo 

The problem is that we have to copy all methods of MyModule into TestModule, but it can be done by having MyModule inside TestModule and use MyModule's methods unless they are directly set from outside. Like this:

TestModule.java

@Module class TestModule { MyModule myModule = new MyModule(); private Foo foo = myModule.getFoo(); public void setFoo(Foo foo) { this.foo = foo; } @Provides public Foo getFoo() { return foo; } } 

For me the following works best.

That's not a test-friendly solution but I use it a lot to mock some APIs while developing whenever backend is not ready yet but I need to implement UI in advance.

Dagger (2.29.1) won't allow to override providing methods in modules with:

Binding methods may not be overridden in modules 

However with some extra boilerplate you could cheat it:

@Module open class NetworkServicesModule { /** * Provide a mock instead */ protected open fun doProvideFlightService(context: Context, retrofit: Retrofit): FlightService { return retrofit.create(FlightService::class.java) } @Provides @Singleton fun provideFlightService(context: Context, retrofit: Retrofit): FlightService { return doProvideFlightService(context, retrofit) } } @Module class MockNetworkServiceModule() : NetworkServicesModule() { /** * Need this to be able to mock a service in a production app */ override fun doProvideFlightService(context: Context, retrofit: Retrofit): FlightService { return MockFlightService(context, super.doProvideFlightService(context, retrofit)) } 

Given you have a component defined like that:

@Component( modules = [ NetworkServicesModule::class, ] ) interface BaseComponent { fun provideFlightService(): FlightService @Component.Builder interface Builder { fun networkServicesModule(networkServicesModule: NetworkServicesModule): Builder fun build(): BaseComponent } } 

You could have some network module provider which you choose depending on your app variant/flavor or the way you like it better:

 /** * Provides mock networking services module */ interface NetworkServicesModuleProvider { /** * Provides networking service module */ fun get() : NetworkServicesModule = NetworkServiceModule() } /** * Provides mock networking services module */ object MockNetworkServicesModuleProvider : NetworkServicesModuleProvider { /** * Provides networking service module */ override fun get() : NetworkServicesModule = MockNetworkServiceModule() } 

Then when it's time to build your component call:

 val networkServicesProvider: NetworkServicesModuleProvider = ... DaggerBaseComponent.builder() .networkServicesModule(networkServicesProvider.get()) .build() 

THIS ANSWER IS OBSOLETE. READ BELOW IN EDIT.

Disappointingly enough, you cannot extend from a Module, or you'll get the following compilation error:

Error:(24, 21) error: @Provides methods may not override another method. Overrides: Provides retrofit.Endpoint hu.mycompany.injection.modules.application.domain.networking.EndpointModule.mySe‌​rverEndpoint() 

Meaning you can't just extend a "mock module" and replace your original module. Nope, it's not that easy. And considering you design your components in such a way that it directly binds the Modules by class, you can't really just make a "TestComponent" either, because that'd mean you have to reinvent everything from scratch, and you'd have to make a component for every variation! Clearly that is not an option.

So on the smaller scale, what I ended up doing is making a "provider" that I give to the module, which determines whether I select the mock or the production type.

public interface EndpointProvider { Endpoint serverEndpoint(); } public class ProdEndpointProvider implements EndpointProvider { @Override public Endpoint serverEndpoint() { return new ServerEndpoint(); } } public class TestEndpointProvider implements EndpointProvider { @Override public Endpoint serverEndpoint() { return new TestServerEndpoint(); } } @Module public class EndpointModule { private Endpoint serverEndpoint; private EndpointProvider endpointProvider; public EndpointModule(EndpointProvider endpointProvider) { this.endpointProvider = endpointProvider; } @Named("server") @Provides public Endpoint serverEndpoint() { return endpointProvider.serverEndpoint(); } } 

EDIT: Apparently as the error message says, you CAN'T override another method using a @Provides annotated method, but that doesn't mean you can't override an @Provides annotated method :(

All that magic was for naught! You can just extend a Module without putting @Provides on the method and it works... Refer to @vaughandroid 's answer.

Can you guys check out my solution, I have included subcomponent example: https://github.com/nongdenchet/android-mvvm-with-tests. Thank you @vaughandroid, I have borrowed your overriding methods. Here is the main point:

1. I create a class to create subcomponent. My custom application will also hold an instance of this class:

   // The builder class public class ComponentBuilder { private AppComponent appComponent; public ComponentBuilder(AppComponent appComponent) { this.appComponent = appComponent; } public PlacesComponent placesComponent() { return appComponent.plus(new PlacesModule()); } public PurchaseComponent purchaseComponent() { return appComponent.plus(new PurchaseModule()); } } // My custom application class public class MyApplication extends Application { protected AppComponent mAppComponent; protected ComponentBuilder mComponentBuilder; @Override public void onCreate() { super.onCreate(); // Create app component mAppComponent = DaggerAppComponent.builder() .appModule(new AppModule()) .build(); // Create component builder mComponentBuilder = new ComponentBuilder(mAppComponent); } public AppComponent component() { return mAppComponent; } public ComponentBuilder builder() { return mComponentBuilder; } } // Sample using builder class: public class PurchaseActivity extends BaseActivity { ... @Override protected void onCreate(Bundle savedInstanceState) { ... // Setup dependency ((MyApplication) getApplication()) .builder() .purchaseComponent() .inject(this); ... } } 

2. I have a custom TestApplication that extends the MyApplication class above. This class contains two methods to replace the root component and the builder:

   public class TestApplication extends MyApplication { public void setComponent(AppComponent appComponent) { this.mAppComponent = appComponent; } public void setComponentBuilder(ComponentBuilder componentBuilder) { this.mComponentBuilder = componentBuilder; } } 

3. Finally I will try to mock or stub the dependency of module and builder to provide fake dependency to the activity:

   @MediumTest @RunWith(AndroidJUnit4.class) public class PurchaseActivityTest { @Rule public ActivityTestRule<PurchaseActivity> activityTestRule = new ActivityTestRule<>(PurchaseActivity.class, true, false); @Before public void setUp() throws Exception { PurchaseModule stubModule = new PurchaseModule() { @Provides @ViewScope public IPurchaseViewModel providePurchaseViewModel(IPurchaseApi purchaseApi) { return new StubPurchaseViewModel(); } }; // Setup test component AppComponent component = ApplicationUtils.application().component(); ApplicationUtils.application().setComponentBuilder(new ComponentBuilder(component) { @Override public PurchaseComponent purchaseComponent() { return component.plus(stubModule); } }); // Run the activity activityTestRule.launchActivity(new Intent()); } 

I have solution for Roboletric 3.+.

I have MainActivity which i want to test without injection on create:

public class MainActivity extends BaseActivity{ @Inject public Configuration configuration; @Inject public AppStateService appStateService; @Inject public LoginService loginService; @Override protected void onCreate(Bundle savedInstanceState) { super.processIntent(getIntent()); // this is point where pass info from test super.onCreate(savedInstanceState) ... } ... } 

Next my BaseActivty:

public class BaseActivity extends AppCompatActivity { protected Logger mLog; protected boolean isTestingSession = false; //info about test session @Override protected void onCreate(@Nullable Bundle savedInstanceState) { if (!isTestingSession) { // check if it is in test session, if not enable injectig AndroidInjection.inject(this); } super.onCreate(savedInstanceState); } // method for receive intent from child and scaning if has item TESTING with true protected void processIntent(Intent intent) { if (intent != null && intent.getExtras() != null) { isTestingSession = intent.getExtras().getBoolean("TESTING", false); } } 

finally my testclass:

@Before public void setUp() throws Exception { ... // init mocks... loginServiceMock = mock(LoginService.class); locServiceMock = mock(LocationClientService.class); fakeConfiguration = new ConfigurationUtils(new ConfigurationXmlParser()); fakeConfiguration.save(FAKE_XML_CONFIGURATION); appStateService = new AppStateService(fakeConfiguration, locServiceMock, RuntimeEnvironment.application); // prepare activity Intent intent = new Intent(RuntimeEnvironment.application, MainActivity.class); intent.putExtra("TESTING", true); ActivityController<MainActivity> activityController = Robolectric.buildActivity(MainActivity.class, intent); // place to put bundle with extras // get the activity instance mainActivity = activityController.get(); // init fields which should be injected mainActivity.appStateService = appStateService; mainActivity.loginService = loginServiceMock; mainActivity.configuration = fakeConfiguration; // and whoala // now setup your activity after mock injection activityController.setup(); // get views etc.. actionButton = mainActivity.findViewById(R.id.mainButtonAction); NavigationView navigationView = mainActivity.findViewById(R.id.nav_view); .... }