Add test case for BasePresenter

[russhwolf]

No description provided.

[ghost]

[gdaniels]

I like this better with Mockito.spy() -

package io.intrepid.skeleton.base;

import android.support.annotation.NonNull;

import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;

import io.intrepid.skeleton.testutils.PresenterTestBase;
import io.reactivex.Observable;
import io.reactivex.disposables.Disposable;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

public class BasePresenterTest extends PresenterTestBase<BasePresenter<BaseContract.View>> {
    @Mock
    private BaseContract.View view;

    private TestPresenter spyPresenter;

    private Disposable disposable;

    @Before
    public void setUp() {
        spyPresenter = Mockito.spy(new TestPresenter(view, testConfiguration));
        presenter = spyPresenter;
    }

    @Test
    public void bind_onlyOnce() throws Exception {
        presenter.bindView(view);
        presenter.bindView(view);
        assertEquals(view, presenter.view);
        verify(spyPresenter, times(1)).onViewBound();
    }

    @Test
    public void unbind_onlyOnce() throws Exception {
        presenter.unbindView();
        verify(spyPresenter, never()).onViewUnbound();

        presenter.bindView(view);
        presenter.unbindView();
        presenter.unbindView();
        verify(spyPresenter, times(1)).onViewUnbound();
    }

    @Test
    public void unbind_clearsDisposables() {
        presenter.bindView(view);
        assertFalse(disposable.isDisposed());

        presenter.unbindView();
        assertTrue(disposable.isDisposed());
    }

    private class TestPresenter extends BasePresenter<BaseContract.View> {

        TestPresenter(@NonNull BaseContract.View view,
                      @NonNull PresenterConfiguration configuration) {
            super(view, configuration);
        }

        @Override
        protected void onViewBound() {
            disposable = Observable.never().subscribe();
            disposables.add(disposable);
        }
    }

}

WDYT?

[gdaniels]

No real comment here, but that is quite a line of source code there. :)

[russhwolf]

Naming is hard 😄

[gdaniels]

Looking at this again, I'd actually split this into two tests, presenterWithoutViewDoesNotCallOnViewUnbound() (or whatever) and unbind_onlyOnce().

[russhwolf]

Yeah that's a good call. I was bouncing around a bit in how I split these up since there's a bit of duplication due to lifecycle necessity, but this can definitely be split in two.

[russhwolf]

To recap some in-person conversation RE Glen's point above, I recently had some issues on Motiv (cc @streetsofboston) where we were having issues with breakpoints in our tests when using spy(), so I've been wary of it recently (it's also somewhat discouraged in the Mockito documentation). Looking back at it, it seems that was specifically due to spying on anonymous classes which isn't what's happening here, so I'll do that refactor.

[ghost]

[russhwolf]

Heh, using spy() upped the coverage by one line, since we call into the real BasePresenter.onViewUnbound() instead of overriding it in TestPresenter. Should I increase it further by adding no-op tests that call into the rest of the empty default BasePresenter methods? They're all empty so there's nothing to test except that it doesn't crash.

[russhwolf]

@gdaniels This has been sitting for a while. Any more thoughts?