Make Realm class to implement an interface

[mvrbensky]

Please could you make the Realm class to implement an interface with standard methods? It is impossible to mock final singleton. So it is almost impossible to unit test anything using Realm.

Thank you
M.

[kneth]

Can you explain your use case? And which interface with which standard methods are to thinking of?

[mvrbensky]

Small example how I would like to use JUnit tests with Mockito. In example an Activity is tested. But I use the Realm in some helper methods in separate backend library. So I would invite the JUnit test a lot.

Class to test:

public class AnActivity extends Activity {

    Realm mRealm;

    @Override
    protected void onResume() {
        super.onResume();
        mRealm = getRealm();
    }

    protected Realm getRealm() {
        return Realm.getInstance(this);
    }

    public void save(RealmObject x) {
        mRealm.beginTransaction();
        mRealm.copyToRealmOrUpdate(x);
        mRealm.commitTransaction();
    }

    @Override
    protected void onPause() {
        super.onPause();
        mRealm.close();
    }
}

JUnit test:

public class AnActivityTest {

    AnActivity instance;

   // @Mock
    Realm realmMock;

    @Before
    public void setUp() {

        // Init mocks.
        MockitoAnnotations.initMocks(this);

        // Inject mock to the tested activity.
        instance= new AnActivity() {
            @Override
            protected Realm getRealm() {
                return realmMock;
            }
        };
    }

    @Test
    public void testOnPause() {

        // Run on pause.
        instance.onPause();

        // Verify Realm is closed.
        verify(realmMock, times(1)).close();
    }

    @Test
    public void testSave() {
        RealmObject x = new RealmObject() {

        };

        // Run save.
        instance.save(x);

        // Verify object has been stored.
        verify(realmMock, times(1)).beginTransaction();
        verify(realmMock, times(1)).copyToRealmOrUpdate(x);
        verify(realmMock, times(1)).beginTransaction();
    }
}

[mvrbensky]

And include all public, non static methods in the interface. So it is possible to emulate and verify the real work with Realm in mock object.

Something like this:

interface RealmInterface {
    void close();

    boolean isAutoRefresh();

    void setAutoRefresh(boolean autoRefresh);

    Table getTable(Class<? extends RealmObject> clazz);

    <E extends RealmObject> void createAllFromJson(Class<E> clazz, JSONArray json);

    <E extends RealmObject> void createOrUpdateAllFromJson(Class<E> clazz, JSONArray json);

    <E extends RealmObject> void createAllFromJson(Class<E> clazz, String json);

    <E extends RealmObject> void createOrUpdateAllFromJson(Class<E> clazz, String json);

    <E extends RealmObject> void createAllFromJson(Class<E> clazz, InputStream inputStream) throws IOException;

    <E extends RealmObject> void createOrUpdateAllFromJson(Class<E> clazz, InputStream in) throws IOException;

    <E extends RealmObject> E createObjectFromJson(Class<E> clazz, JSONObject json);

    <E extends RealmObject> E createOrUpdateObjectFromJson(Class<E> clazz, JSONObject json);

    <E extends RealmObject> E createObjectFromJson(Class<E> clazz, String json);

    <E extends RealmObject> E createOrUpdateObjectFromJson(Class<E> clazz, String json);

    <E extends RealmObject> E createObjectFromJson(Class<E> clazz, InputStream inputStream) throws IOException;

    <E extends RealmObject> E createOrUpdateObjectFromJson(Class<E> clazz, InputStream in) throws IOException;

    void writeCopyTo(File destination) throws IOException;

    void writeEncryptedCopyTo(File destination, byte[] key) throws IOException;

    <E extends RealmObject> E createObject(Class<E> clazz);

    <E extends RealmObject> E copyToRealm(E object);

    <E extends RealmObject> E copyToRealmOrUpdate(E object);

    <E extends RealmObject> List<E> copyToRealm(Iterable<E> objects);

    <E extends RealmObject> List<E> copyToRealmOrUpdate(Iterable<E> objects);

    <E extends RealmObject> RealmQuery<E> where(Class<E> clazz);

    <E extends RealmObject> RealmResults<E> allObjects(Class<E> clazz);

    <E extends RealmObject> RealmResults<E> allObjectsSorted(Class<E> clazz, String fieldName,
                                                             boolean sortAscending);

    <E extends RealmObject> RealmResults<E> allObjectsSorted(Class<E> clazz, String fieldName1,
                                                             boolean sortAscending1,
                                                             String fieldName2, boolean sortAscending2,
                                                             String fieldName3, boolean sortAscending3);

    <E extends RealmObject> RealmResults<E> allObjectsSorted(Class<E> clazz, String fieldNames[],
                                                             boolean sortAscending[]);

    void addChangeListener(RealmChangeListener listener);

    void removeChangeListener(RealmChangeListener listener);

    void removeAllChangeListeners();

    void refresh();

    void beginTransaction();

    void commitTransaction();

    void cancelTransaction();

    void executeTransaction(Realm.Transaction transaction);

    void clear(Class<? extends RealmObject> clazz);

    String getPath();

    RealmConfiguration getConfiguration();
}

[bmunkholm]

Thanks a lot for the feedback. I'm just wondering about the amount of effort needed to emulate the full database functionality?

[cmelchior]

Note that you don't need an interface to use Mockito, us removing the final classifier on the Realm class would also be enough. This will most likely happen as part of #1369.

[mvrbensky]

Hallo.
Yes. It will be possible to use mockito on non final singleton. It would solve my problem.

Thank you.
M.

[nhachicha]

Hi @mvrbensky

Minimising the accessibility of classes and members is a good practice when it comes to API design ( Effective Java Items: 13, 15 & 16) this also favour composition over inheritance.

The ideal scenario is to have a Realm interface so you can mock, test (or provide a different implementation using Dependency injection in our case).

We're considering this option, but in the mean time you can try powermock that allows mocking final classes

Cheers,

[mvrbensky]

Hi @nhachicha

I know power mock. A I use it a lot. But I have not been able to set Android studio to use it. Do you use it in android projects? Shoul I just dig deeper? :-)

Thank you
M.