En este artículo, vamos a probar Room Database en Android. Aquí estamos usando JUnit para probar nuestro código. JUnit es un marco de «Prueba unitaria» para aplicaciones Java que ya está incluido de forma predeterminada en Android Studio. Es un marco de automatización para pruebas unitarias y de interfaz de usuario. Contiene anotaciones como @Test , @Before , @After , etc. Aquí usaremos solo la anotación @Test para que el artículo sea fácil de entender. Tenga en cuenta que vamos a implementar este proyecto utilizando el lenguaje Kotlin .
Implementación paso a paso
Paso 1: Crear un nuevo proyecto
Para crear un nuevo proyecto en Android Studio, consulte Cómo crear/iniciar un nuevo proyecto en Android Studio . Tenga en cuenta que seleccione Kotlin como lenguaje de programación.
Paso 2: agregar dependencias
Dentro de build.gradle (proyecto) agregue el siguiente código en dependencias. Contiene dependencias de Room Db, Coroutiene , JUnit, Truth y otros.
implementación “org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.1”
implementación “androidx.room:room-runtime:2.2.6”
implementación “androidx.legacy:legacy-support-v4:1.0.0”
captó «androidx.room:room-compiler:2.2.6»
implementación “androidx.room:room-ktx:2.2.6”
pruebaImplementación «androidx.arch.core:core-testing:2.1.0»
pruebaImplementación «androidx.room:room-testing:2.2.6»
pruebaImplementación “junit:junit:4.13.2”
pruebaImplementación “com.google.truth:truth:1.1.2”
implementación de prueba «org.jetbrains.kotlinx:kotlinx-coroutines-test:1.3.4»
pruebaImplementación ‘org.robolectric:robolectric:4.5.1’
AndroidTestImplementación «androidx.test.ext:junit-ktx:1.1.2»
AndroidTestImplementation «androidx.test.espresso:espresso-core:3.3.0»
AndroidTestImplementation «com.google.truth:truth:1.1.2»
AndroidTestImplementation «androidx.arch.core:core-testing:2.1.0»
AndroidTestImplementation «androidx.test:reglas:1.3.0»
AndroidTestImplementation «androidx.test:runner:1.3.0»
AndroidTestImplementación «androidx.test:core-ktx:1.3.0»
Antes de escribir nuestra prueba, primero creemos Room Database
Paso 3: Cree una nueva clase modelo «Idioma.kt»
Cree una nueva clase » Language.kt » y anótela con @Entity y pase el nombre de la tabla.
Kotlin
import androidx.room.Entity
import androidx.room.PrimaryKey
@Entity(tableName = "language")
data class Language(
val languageName : String="",
val experience : String=""
) {
@PrimaryKey(autoGenerate = true)
var id : Long=0
}
Paso 4: Crear interfaz dao
Cree una nueva clase » LanguageDao.kt » y anótela con @Dao . Se agregan comentarios para una mejor comprensión del código.
Kotlin
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query
@Dao
interface LanguageDao {
// Write two functions one for adding language to the database
// and another for retrieving all the items present in room db.
@Insert
suspend fun addLanguage(language: Language)
@Query("SELECT * FROM language ORDER BY languageName DESC")
suspend fun getAllLanguages(): List<Language>
}
Paso 5: crea una clase de base de datos
Cree una nueva clase abstracta » LanguageDatabase.kt » y anótela con @Database . A continuación se muestra el código de la clase LanguageDatabase.kt , se agregan comentarios para una mejor comprensión.
Kotlin
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
@Database(entities = [Language::class] , version = 1)
abstract class LanguageDatabase : RoomDatabase() {
// get reference of the dao interface that we just created
abstract fun getLanguageDao() : LanguageDao
companion object{
private const val DB_NAME = "Language-Database.db"
// Get reference of the LanguageDatabase and assign it null value
@Volatile
private var instance : LanguageDatabase? = null
private val LOCK = Any()
// create an operator fun which has context as a parameter
// assign value to the instance variable
operator fun invoke(context: Context) = instance ?: synchronized(LOCK){
instance ?: buildDatabase(context).also{
instance = it
}
}
// create a buildDatabase function assign the required values
private fun buildDatabase(context: Context) = Room.databaseBuilder(
context.applicationContext,
LanguageDatabase::class.java,
DB_NAME
).fallbackToDestructiveMigration().build()
}
}
Paso 6: crea una clase de prueba
Para crear una clase de prueba de LanguageDatabase.kt , haga clic con el botón derecho en LanguageDatabase , luego haga clic en generar y luego seleccione la prueba. Se abrirá un cuadro de diálogo, desde el cuadro de diálogo, elija Biblioteca de prueba como JUnit4 y mantenga el nombre de la clase como predeterminado, que es LanguageDatabaseTest , y haga clic en Aceptar . Después de eso, se abrirá otro cuadro de diálogo para elegir el directorio de destino, elija el que tiene ..app\src\AndoidTest\. porque nuestra clase de prueba requiere contexto de la aplicación. A continuación se muestra la captura de pantalla para guiarlo en la creación de la clase de prueba.
Paso 7: trabajar con la clase LanguageDatabaseTest.kt
Vaya al archivo LanguageDatabaseTest.kt y escriba el siguiente código. Se agregan comentarios dentro del código para comprender el código con más detalle.
Kotlin
import android.content.Context
import androidx.room.Room
import androidx.test.core.app.ApplicationProvider
import androidx.test.ext.junit.runners.AndroidJUnit4
import com.google.common.truth.Truth.assertThat
import junit.framework.TestCase
import kotlinx.coroutines.runBlocking
import org.junit.*
import org.junit.runner.RunWith
@RunWith(AndroidJUnit4::class) // Annotate with @RunWith
class LanguageDatabaseTest : TestCase() {
// get reference to the LanguageDatabase and LanguageDao class
private lateinit var db: LanguageDatabase
private lateinit var dao: LanguageDao
// Override function setUp() and annotate it with @Before
// this function will be called at first when this test class is called
@Before
public override fun setUp() {
// get context -- since this is an instrumental test it requires
// context from the running application
val context = ApplicationProvider.getApplicationContext<Context>()
// initialize the db and dao variable
db = Room.inMemoryDatabaseBuilder(context, LanguageDatabase::class.java).build()
dao = db.getLanguageDao()
}
// Override function closeDb() and annotate it with @After
// this function will be called at last when this test class is called
@After
fun closeDb() {
db.close()
}
// create a test function and annotate it with @Test
// here we are first adding an item to the db and then checking if that item
// is present in the db -- if the item is present then our test cases pass
@Test
fun writeAndReadLanguage() = runBlocking {
val language = Language("Java", "2 Years")
dao.addLanguage(language)
val languages = dao.getAllLanguages()
assertThat(languages.contains(language)).isTrue()
}
}
Paso 8: Ejecutar pruebas
Para ejecutar el caso de prueba, haga clic en el pequeño ícono de ejecutar cerca del nombre de la clase y luego seleccione Run LanguageDatabaseTest. Si todos los casos de prueba pasan, obtendrá una marca verde en la consola Ejecutar. En nuestro caso, todas las pruebas han pasado.
Github Repo aquí .