Testen der SQLite-Datenbankeinheit für Android

Eine Möglichkeit zum Implementieren von SQLite-Tests besteht in einem instrumentierten Unit-Test . Verwenden Sie InstrumentationRegistry im Android-Testpaket, um einen Kontext zu erhalten.

Hier ist ein Beispiel aus einem Tutorial und ein Beispiel zu GitHub :

import Android.support.test.InstrumentationRegistry;
import Android.support.test.runner.AndroidJUnit4;
import Android.test.suitebuilder.annotation.LargeTest;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import Java.util.List;

import static junit.framework.Assert.assertNotNull;
import static junit.framework.Assert.assertTrue;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;

@RunWith(AndroidJUnit4.class)
@LargeTest
public class SQLiteTest {

    private RateDataSource mDataSource;

    @Before
    public void setUp(){
        mDataSource = new RateDataSource(InstrumentationRegistry.getTargetContext());
        mDataSource.open();
    }

    @After
    public void finish() {
        mDataSource.close();
    }

    @Test
    public void testPreConditions() {
        assertNotNull(mDataSource);
    }

    @Test
    public void testShouldAddExpenseType() throws Exception {
        mDataSource.createRate("AUD", 1.2);
        List<Rate> rate = mDataSource.getAllRates();

        assertThat(rate.size(), is(1));
        assertTrue(rate.get(0).toString().equals("AUD"));
        assertTrue(rate.get(0).getValue().equals(1.2));
    }

    @Test
    public void testDeleteAll() {
        mDataSource.deleteAll();
        List<Rate> rate = mDataSource.getAllRates();

        assertThat(rate.size(), is(0));
    }

    @Test
    public void testDeleteOnlyOne() {
        mDataSource.createRate("AUD", 1.2);
        List<Rate> rate = mDataSource.getAllRates();

        assertThat(rate.size(), is(1));

        mDataSource.deleteRate(rate.get(0));
        rate = mDataSource.getAllRates();

        assertThat(rate.size(), is(0));
    }

    @Test
    public void testAddAndDelete() {
        mDataSource.deleteAll();
        mDataSource.createRate("AUD", 1.2);
        mDataSource.createRate("JPY", 1.993);
        mDataSource.createRate("BGN", 1.66);

        List<Rate> rate = mDataSource.getAllRates();
        assertThat(rate.size(), is(3));

        mDataSource.deleteRate(rate.get(0));
        mDataSource.deleteRate(rate.get(1));

        rate = mDataSource.getAllRates();
        assertThat(rate.size(), is(1));
    }
}

Versuchen Sie, einige Tutorials und Artikel über die SQLite-Datenbank für Komponententests in Java zu finden. Das Testen von Einheiten in Java und Android ist sicherlich dasselbe.

Obwohl Sie diese Themen auf Stack finden würden:

Wie teste ich Android sqlite mit junit?

Wie teste ich Methoden, die mit der SQLite-Datenbank in Android umgehen?

oder dieser Artikel: 

Android Easy SQLite mit Komponententests

Überprüfen Sie Folgendes beim Testen der SQLite-Datenbank mit Junit:

Android JUnit-Test für SQLiteOpenHelper

wo würden Sie diese Lösung finden:

Für einen einfachen DatabaseHandler:

<!-- language: Java -->

    public class MyDatabase extends SQLiteOpenHelper {
      private static final String DATABASE_NAME = "database.db";
      private static final int DATABASE_VERSION = 1;

      public MyDatabase(Context context){
          super(context, DATABASE_NAME, null, DATABASE_VERSION);
      }

      @Override
      public void onCreate(SQLiteDatabase db){
          // some code
      }

      @Override
      public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
          // some code
      }
    }

Ich habe ein AndroidTestCase erstellt:

<!-- language: Java -->

  public class DatabaseTest extends AndroidTestCase {
      private MyDatabase db;

        @Override
      public void setUp() throws Exception {
            super.setUp();
          RenamingDelegatingContext context = new RenamingDelegatingContext(getContext(), "test_");
          db = new MyDatabase(context);
      }

        @Override
      public void tearDown() throws Exception {
          db.close(); 
          super.tearDown();
      }

        //According to Zainodis annotation only for legacy and not valid with gradle>1.1:
        //@Test
      public void testAddEntry(){
          // Here i have my new database wich is not connected to the standard database of the App
      }
  }

Lesen Sie auch: 

Junit zum Testen von Schreiben und Lesen in SQLite verwenden

SQLiteOpenHelper-Unterklasse mit JUnit testen

Diese Antwort schlägt die Roboelectric-Bibliothek vor . Das hat bei mir funktioniert. Es ist schneller als ein instrumentierter Test, der in einem Emulator ausgeführt werden muss.