Android De Base De Données SQLite Tests Unitaires

Je suis nouveau sur android app développement et la je viens de faire une note d'application. Je veux faire des tests unitaires pour le insertNote, readNote et updateNote méthodes pour la base de données. Comment puis-je aller à ce sujet? Voici le code de ma base de données.
Merci.

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

}

OriginalL'auteur Anderson | 2015-12-14

Une façon de mettre en œuvre SQLite tests avec un instrumentation de test unitaire, à l'aide de la InstrumentationRegistry dans l'Android package de test pour obtenir un Contexte.

Voici un exemple à partir d'un tutoriel et un exemple sur 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));
}
}

OriginalL'auteur Cabezas

Essayer de trouver des tutoriels, des articles sur les tests unitaires de la base de données SQLite en Java. Les Tests unitaires en Java et Android est certainement la même chose.

Bien que vous trouverez ces sujets, sur la Pile:

Comment tester Android sqlite avec junit?

Comment tester des méthodes qui traitent de la base de données SQLite sous android?

ou cet article:

Android Facile SQLite Avec Des Tests Unitaires

Selon les tests SQLite databese avec Junit, vérifiez ceci:

Android de test JUnit pour SQLiteOpenHelper

où vous pourriez trouver cette solution:

Pour un simple 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
}
}

J'ai créé un 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
}
}