Dagger Field Injection Testing

Question

I am using Dagger 2 and have a few issues with generate singleton providers in the module when implementing tests for my class.

class SomeContentProvider extends ContentProvider {

    // this should be normal foo if run by application, 
    // or mocked foo if run by tests
    @Inject Foo foo;

    public Provider() {
        Component.getComponent().inject(this);
    }
}

@Module
class ProviderModule {
    @Singleton
    @Provides
    Foo providesFoo() {
        returns new Foo();
    }
}

@Module
class ProviderTestModule {
    @Singleton
    @Provides
    Foo providesFoo() {
        returns Mockito.mock(Foo.class);
    }
}


public class SomeContentProviderTests extends InstrumentationTestCase {

    @Inject Foo foo; // this should be mocked Foo

    @Override
    public void setUp() throws Exception {
        super.setUp();

        MockitoAnnotations.initMocks(this);

        Component.getTestComponent().inject(this);
    }

    public void test1() {
        // needs new instance of Foo when test1 is run from SomeContentProvider
    }

    public void test2() {
        // needs another new instance of Foo when test2 is run from SomeContentProvider
    }
}

So I have 2 questions.

I cannot use constructor injection as ContentProvider has a default constructor. How does SomeContentProvider get the Foo from the the test module?
In test1 and test2, how do I ensure that a new instance of Foo is created when each test is being run?

Thanks!

So right now my intent is to create another field of `Foo` and another constructor of `SomeContentProvider` that takes in a `Foo` just for testing purpose, after inject, if that field does exist, replace the injected `Foo` — Dillon, Dec 14 '17 at 22:04

score 1 · Accepted Answer · answered Dec 15 '17 at 23:29

1

I found this post especially useful for me. Though the particular problem I am have is much more convoluted - but I had used the same idea to mock the module's provider.

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

answered Dec 15 '17 at 23:29

Dillon

364
5
18

score 0 · Answer 2 · answered Dec 14 '17 at 18:51

0

You should use the @Named annotation for identify which dependency you want to inject if you have more than one dependency of same type.

See docs for more details: https://google.github.io/dagger/users-guide#qualifiers

answered Dec 14 '17 at 18:51

Wellington Costa

143
4

Im not sure if you understood my question correctly. Names qualifier would not be needed in my case. – Dillon Dec 14 '17 at 18:58

Dagger Field Injection Testing

2 Answers2