Testowanie bazy danych SQLite Android

Question

Jestem nowy w rozwoju aplikacji na Androida i właśnie stworzyłem aplikację do notatek. Chcę wykonać testy jednostkowe dla metod insertNote, readNote i updateNote dla bazy danych. Jak mam to zrobić? To jest kod dla mojej bazy danych. Dzięki.

public class DatabaseManager extends SQLiteOpenHelper { 


public static final String Database_Name = "Notes Database"; 
public static final String Table_Name = "notes"; 

public static final String Column_id = "textId"; 
public static final String Column_title = "textTitle"; 
public static final String Column_body = "textBody"; 

public DatabaseManager(Context context){ 
    super(context, Database_Name, null, 1); 
} 

@Override 
public void onCreate(SQLiteDatabase db){ 
    db.execSQL("CREATE TABLE " + Table_Name + " (" + Column_id + 
      " INTEGER PRIMARY KEY AUTOINCREMENT, " + Column_title + 
      " TEXT, " + Column_body + " TEXT)"); 
} 

@Override 
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion){ 
    db.execSQL("DROP TABLE IF EXISTS" + Table_Name); 
    onCreate(db); 
} 

public void insertNote(Note note){ 
    SQLiteDatabase db = this.getWritableDatabase(); 

    ContentValues values = new ContentValues(); 
    values.put(Column_title, note.getTextTitle()); 
    values.put(Column_body, note.getTextBody()); 

    boolean result = db.insert(Table_Name, null, values) > 0; 
    if (result == true) 
     Log.d("Create", "Data Has Been Saved"); 
    db.close(); 
} 

public Cursor readNote(int id){ 
    SQLiteDatabase db = this.getReadableDatabase(); 

    Cursor cursor = db.rawQuery("SELECT * FROM " + Table_Name + " WHERE _ROWID_ = " + id, null); 

    if (cursor != null){ 
     cursor.moveToFirst(); 
    } 

    Note myNote = new Note(); 
    myNote.textId = cursor.getInt(cursor.getColumnIndex(Column_id)); 
    myNote.textTitle = cursor.getString(cursor.getColumnIndex(Column_title)); 

    return cursor; 
} 

public ArrayList<String> getNoteList(){ 
    ArrayList<String> noteList = new ArrayList<>(); 
    SQLiteDatabase db = this.getReadableDatabase(); 
    Cursor cursor = db.rawQuery("SELECT * FROM " + Table_Name, null); 
    cursor.moveToFirst(); 

    if (cursor.moveToFirst()){ 
     do{ 
      //noteList.add(cursor.getInt(cursor.getColumnIndex(Column_id))); 
      noteList.add(cursor.getString(cursor.getColumnIndex(Column_title))); 
     } 
     while (cursor.moveToNext()); 
    } 

    return noteList; 
} 

public int updateNote(Note note){ 
    SQLiteDatabase db = this.getWritableDatabase(); 

    ContentValues values = new ContentValues(); 
    values.put("textTitle", note.getTextTitle()); 
    values.put("textBody", note.getTextBody()); 

    int update = db.update(Table_Name, values, Column_id + " = ?", new String[]{Integer.toString(note.getTextId())}); 
    return update; 
} 

public Integer deleteNote(int id){ 
    SQLiteDatabase db = this.getWritableDatabase(); 
    return db.delete(Table_Name, Column_id + " = ?", new String[]{Integer.toString(id)}); 
} 

public int getCount(){ 
    SQLiteDatabase db = this.getReadableDatabase(); 
    Cursor cursor = db.rawQuery("SELECT * FROM " + Table_Name, null); 
    cursor.close(); 

    return cursor.getCount(); 
} 

}

Answer 1

Spróbuj znaleźć kilka tutoriali, artykułów o testów jednostkowych bazy danych SQLite w Javie. Testowanie jednostek w Javie i Androidzie jest z pewnością takie samo.

Chociaż można znaleźć te tematy na stos:

How to test Android sqlite with junit?

How to test methods that deal with SQLite database in android?

czy ten artykuł:

Android Easy SQLite With Unit Tests

Według badania SQLite databese z JUnit, to sprawdzić :

Android JUnit test for SQLiteOpenHelper

gdzie będzie można znaleźć takie rozwiązanie:

na prosty 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 
     } 
    } 

I stworzył AndroidTestCase:

<!-- 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 
     } 
    } 

Czytaj także:

Using Junit to test writing and reading to SQLite

Testing SQLiteOpenHelper subclass with JUnit

Answer 2

Większość tajemnicy realizacji SQLite test z testów jednostkowych JUnit, to w stosowaniu metod dochodzić w org.junit.Assert klasy. W tym tekście przyjrzę się bliżej, jakie metody zapewniania są dostępne w tej klasie.

Najprostszym sposobem jest użycie InstrumentationRegistry w pakiecie testów android.

Jeden przykład:

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)); 
    } 
} 

• Jest tutorial i przykładem w GitHub