android retrofit2, dagger2 unit test

Personally I'd make the presenter not depend on the Retrofit class but rather on the services created by Retrofit - These are mockable.

It's hard to say from the code you posted which services your presenter actually uses, but for the sake of simplicity let's say it uses only one and let's say it's AddsService - This is an interface ready to work with Retrofit. Something like this for example

public interface AddsService { @GET(...) Call<List<Adds>> getAllAdds(); } 

Now you can make your presenter depend on this rather than Retrofit

@Inject public AddScreenPresenter(AddsService addsService, AddScreenContact.View view, ContactDatabaseHelper contactDatabaseHelper){ this.addsService = addsService; this.view = view; this.contactDatabaseHelper = contactDatabaseHelper; } 

You now need to provide this dependency. I'm guessing you have also a NetModule since you have a NetComponent, so I assume you can just do:

@Module public class NetModule { // Methods providing Retrofit @Provides @Singleton public AddsService providesAddsService(Retrofit retrofit) { return retrofit.create(AddsService.class); } } 

Notice how the providesAddsService depends on retrofit? This should be already provided since your presenter is depending on it. You shouldn't need to change anything for that. Dagger is able to figure out how to provide Retrofit to the method providesAddsService.

Please notice also that I'm assuming you can provide these in a Singleton scope. I assume this because in your code you retrieve the component from the application, which should handle the singleton scope.

Now in your tests you can simply mock AddsService and test your presenter.

If your presenter depends on more services, I'd also pass them in the constructor and provide the implementations with Dagger.

As a bonus, let me also say that the retrofit instance and the retrofit services should only be created once (or at least as less times as possible). This is because they're usually expensive operations and you usually always query the same endpoints with different parameters.

EDIT

To answer some of the questions in the comments. First the easy one: How to create the presenter in the test classes? Like you I too try to get away from Dagger during tests, that's why I prefer constructor dependency injection just like you show you're using. So in my test class I'd have something very similar like you:

@RunWith(MockitoJUnitRunner.class) public class AddScreenPresenterTest { private AddScreenPresenter mAddPresenter; @Mock private AddsService addsService; // ... @Before public void setUp() throws Exception { mAddPresenter = new AddScreenPresenter(addsService, mView, mContactDatabaseHelper); // ... } } 

So basically the only difference is that I would pass the mock to the service.

Now the second question: How to call the presenter constructor from the activity? Well you don't... that's the whole idea of dependency injection. You should use dagger to provide your presenter. I think this is already what you do and I guess this is what it's in your activity:

@Inject AddScreenPresenter addScreenPresenter; 

So all you need to do is have a provider method in your module that provides this and is able to inject it.

You can also make the component return the presenter provided by the module:

@Component(...) public interface AddScreenComponent { AddScreenPresenter getPresenter(); } 

And then in your activity you'd do something like:

addScreenPresenter = component.getPresenter(); 

I don't really have any preference here. The key point is to understand that you should not build the objects yourself (unless inside @Modules). As a rule of thumb any time you see new being used that means you have a tight dependency on that object and you should extract it to be injected. So this is why you should avoid creating the presenter inside your activity. It will couple the presenter to the activity.