Android plain Junit with Dagger 2

Question

I used to work in MVP and I usually test my presenters using a plain Junit (Not the Instrumentation !) , since Presenters only have the business logic and no references to Android internals whatsoever.

Now by switching to Dagger 2 , I understood that I have a problem setting up a "TestModule" for my app component.

1. Creating a component will not work from within a test class (probably because "apt" is not running there)
2. Didn't find any examples for using Dagger with a standard Junit testing. Every example I have found only relies on Instrumentation testing or Roboelectric (which basically mocks Activities and other Android related stuff) , but this is just a UI testing for me , and I don't need that.

Just to make things clear , I am talking about the tests that are located at app->src->test folder not the app->src->androidTest !

So do I do something wrong ? Or missing something ? Can anyone explain or give examples on how to use Dagger 2 in normal unit tests ?

Answer 1

I'm not sure if my solution will work for you but I see no reason it shouldn't. First I created testInjectionComponent

@Singleton
@Component(modules = {MockNetworkModule.class})
public interface MockInjectionComponent extends InjectionComponent {
void inject(DaggerUnitTest daggerUnitTest);
}

Then my Unit Tests I add injection in the before method. like so:

@Before
public void setUp() throws Exception {
    MockInjectionComponent mockInjectionComponent = DaggerMockInjectionComponent
            .builder()
            .mockNetworkModule(new MockNetworkModule())
            .build();
    mockInjectionComponent.inject(this);
}

Then I just Annotate my Injected Object.

EDIT : Do not forget to add testApt "com.google.dagger:dagger-compiler:$daggerVersion" at your app.gradle file .

Answer 2

As mentioned by the accepted answer. Do not forget to add :

For Java

Android Test

androidTestAnnotationProcessor 'com.google.dagger:dagger-compiler:$dagger_version'

JUnit test

testAnnotationProcessor 'com.google.dagger:dagger-compiler:$dagger_version'

For Kotlin

Android Test

kaptAndroidTest 'com.google.dagger:dagger-compiler:$dagger_version'

JUnit test

kaptTest 'com.google.dagger:dagger-compiler:$dagger_version'

Answer 3

You don't need any dagger to test your presenter. Dagger's job is it to fullfill the dependencies of your classes (dependency injection).

For example you have this Presenter:

public class MyPresenter {

    Database database;
    ApiService apiService;

    @Inject
    public MyPresenter(final Database database, final ApiService apiService) {
        this.database = database;
        this.apiService = apiService;
    }
}

Dagger will provide your Presenter with the database and apiService objects for your presenter to use them. When running the actual app (not a test) these will be real objects with real functionality.

When testing the presenter, you want to test only the presenter, everything else should be mocked.

So when you create the presenter in your PresenterTest, you create it with mocked versions of database and apiService.

You can then test how your presenter interacts with these object by

a. mocking the objects behaviour like

when(database.getSomething()).thenReturn(something)

b. verify your presenter does what you want it to do with these objects like

verify(database).saveSomething()

(pseudo code)

Standard way to mock would be Mockito.

Answer 4

You can swap out real modules with fake modules in two ways: do it at compile time using flavors as recommended by google architecture samples or at runtime by creating an abstract method which injects the real thing in production code and fake dependencies in test code. In the second case your test has to subclass the class that you want to mock and build the component from scrach