Prefix maven modules
This commit is contained in:
@@ -0,0 +1 @@
|
||||
package be.simplenotes.persistance
|
||||
@@ -0,0 +1,168 @@
|
||||
package be.simplenotes.persistance.converters
|
||||
|
||||
import be.simplenotes.domain.model.*
|
||||
import be.simplenotes.persistance.notes.NoteEntity
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.junit.jupiter.api.DisplayName
|
||||
import org.junit.jupiter.api.Nested
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.mapstruct.factory.Mappers
|
||||
import java.time.LocalDateTime
|
||||
import java.util.*
|
||||
|
||||
internal class NoteConverterTest {
|
||||
|
||||
@Nested
|
||||
@DisplayName("Entity -> Models")
|
||||
inner class EntityToModels {
|
||||
|
||||
@Test
|
||||
fun `convert NoteEntity to Note`() {
|
||||
val converter = Mappers.getMapper(NoteConverter::class.java)
|
||||
val entity = NoteEntity {
|
||||
title = "title"
|
||||
markdown = "md"
|
||||
html = "html"
|
||||
}
|
||||
val tags = listOf("a", "b")
|
||||
val note = converter.toNote(entity, tags)
|
||||
val expectedNote = Note(NoteMetadata(
|
||||
title = "title",
|
||||
tags = tags,
|
||||
), markdown = "md", html = "html")
|
||||
assertThat(note).isEqualTo(expectedNote)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `convert NoteEntity to ExportedNote`() {
|
||||
val converter = Mappers.getMapper(NoteConverter::class.java)
|
||||
val entity = NoteEntity {
|
||||
title = "title"
|
||||
markdown = "md"
|
||||
html = "html"
|
||||
updatedAt = LocalDateTime.MIN
|
||||
deleted = true
|
||||
}
|
||||
val tags = listOf("a", "b")
|
||||
val note = converter.toExportedNote(entity, tags)
|
||||
val expectedNote = ExportedNote(
|
||||
title = "title",
|
||||
tags = tags,
|
||||
markdown = "md",
|
||||
html = "html",
|
||||
updatedAt = LocalDateTime.MIN,
|
||||
trash = true
|
||||
)
|
||||
assertThat(note).isEqualTo(expectedNote)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `convert NoteEntity to PersistedNoteMetadata`() {
|
||||
val converter = Mappers.getMapper(NoteConverter::class.java)
|
||||
val entity = NoteEntity {
|
||||
uuid = UUID.randomUUID()
|
||||
title = "title"
|
||||
markdown = "md"
|
||||
html = "html"
|
||||
updatedAt = LocalDateTime.MIN
|
||||
deleted = true
|
||||
}
|
||||
val tags = listOf("a", "b")
|
||||
val note = converter.toPersistedNoteMetadata(entity, tags)
|
||||
val expectedNote = PersistedNoteMetadata(
|
||||
title = "title",
|
||||
tags = tags,
|
||||
updatedAt = LocalDateTime.MIN,
|
||||
uuid = entity.uuid
|
||||
)
|
||||
assertThat(note).isEqualTo(expectedNote)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@Nested
|
||||
@DisplayName("Models -> Entity")
|
||||
inner class ModelsToEntity {
|
||||
|
||||
@Test
|
||||
fun `convert Note to NoteEntity`() {
|
||||
val converter = Mappers.getMapper(NoteConverter::class.java)
|
||||
val note = Note(NoteMetadata("title", emptyList()), "md", "html")
|
||||
val entity = converter.toEntity(note, UUID.randomUUID(), 2, LocalDateTime.MIN)
|
||||
|
||||
assertThat(entity)
|
||||
.hasFieldOrPropertyWithValue("markdown", "md")
|
||||
.hasFieldOrPropertyWithValue("html", "html")
|
||||
.hasFieldOrPropertyWithValue("title", "title")
|
||||
.hasFieldOrPropertyWithValue("uuid", entity.uuid)
|
||||
.hasFieldOrPropertyWithValue("updatedAt", LocalDateTime.MIN)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `convert PersistedNoteMetadata to NoteEntity`() {
|
||||
val converter = Mappers.getMapper(NoteConverter::class.java)
|
||||
val persistedNoteMetadata =
|
||||
PersistedNoteMetadata("title", emptyList(), LocalDateTime.MIN, UUID.randomUUID())
|
||||
val entity = converter.toEntity(persistedNoteMetadata)
|
||||
|
||||
assertThat(entity)
|
||||
.hasFieldOrPropertyWithValue("uuid", persistedNoteMetadata.uuid)
|
||||
.hasFieldOrPropertyWithValue("updatedAt", persistedNoteMetadata.updatedAt)
|
||||
.hasFieldOrPropertyWithValue("title", "title")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `convert NoteMetadata to NoteEntity`() {
|
||||
val converter = Mappers.getMapper(NoteConverter::class.java)
|
||||
val noteMetadata = NoteMetadata("title", emptyList())
|
||||
val entity = converter.toEntity(noteMetadata)
|
||||
|
||||
assertThat(entity)
|
||||
.hasFieldOrPropertyWithValue("title", "title")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `convert PersistedNote to NoteEntity`() {
|
||||
val converter = Mappers.getMapper(NoteConverter::class.java)
|
||||
val persistedNote = PersistedNote(
|
||||
NoteMetadata("title", emptyList()),
|
||||
markdown = "md",
|
||||
html = "html",
|
||||
updatedAt = LocalDateTime.MIN,
|
||||
uuid = UUID.randomUUID(),
|
||||
public = true
|
||||
)
|
||||
val entity = converter.toEntity(persistedNote)
|
||||
|
||||
assertThat(entity)
|
||||
.hasFieldOrPropertyWithValue("title", "title")
|
||||
.hasFieldOrPropertyWithValue("markdown", "md")
|
||||
.hasFieldOrPropertyWithValue("uuid", persistedNote.uuid)
|
||||
.hasFieldOrPropertyWithValue("updatedAt", persistedNote.updatedAt)
|
||||
.hasFieldOrPropertyWithValue("deleted", false)
|
||||
.hasFieldOrPropertyWithValue("public", true)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `convert ExportedNote to NoteEntity`() {
|
||||
val converter = Mappers.getMapper(NoteConverter::class.java)
|
||||
val exportedNote = ExportedNote(
|
||||
"title",
|
||||
emptyList(),
|
||||
markdown = "md",
|
||||
html = "html",
|
||||
updatedAt = LocalDateTime.MIN,
|
||||
trash = true
|
||||
)
|
||||
val entity = converter.toEntity(exportedNote)
|
||||
|
||||
assertThat(entity)
|
||||
.hasFieldOrPropertyWithValue("title", "title")
|
||||
.hasFieldOrPropertyWithValue("markdown", "md")
|
||||
.hasFieldOrPropertyWithValue("updatedAt", exportedNote.updatedAt)
|
||||
.hasFieldOrPropertyWithValue("deleted", true)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
package be.simplenotes.persistance.converters
|
||||
|
||||
import be.simplenotes.domain.model.PersistedUser
|
||||
import be.simplenotes.domain.model.User
|
||||
import be.simplenotes.persistance.users.UserEntity
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.mapstruct.factory.Mappers
|
||||
|
||||
internal class UserConverterTest {
|
||||
|
||||
@Test
|
||||
fun `convert UserEntity to User`() {
|
||||
val converter = Mappers.getMapper(UserConverter::class.java)
|
||||
val entity = UserEntity {
|
||||
username = "test"
|
||||
password = "test2"
|
||||
}.apply {
|
||||
this["id"] = 2
|
||||
}
|
||||
val user = converter.toUser(entity)
|
||||
assertThat(user).isEqualTo(User("test", "test2"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `convert UserEntity to PersistedUser`() {
|
||||
val converter = Mappers.getMapper(UserConverter::class.java)
|
||||
val entity = UserEntity {
|
||||
username = "test"
|
||||
password = "test2"
|
||||
}.apply {
|
||||
this["id"] = 2
|
||||
}
|
||||
val user = converter.toPersistedUser(entity)
|
||||
assertThat(user).isEqualTo(PersistedUser("test", "test2", 2))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `convert User to UserEntity`() {
|
||||
val converter = Mappers.getMapper(UserConverter::class.java)
|
||||
val user = User("test", "test2")
|
||||
val entity = converter.toEntity(user)
|
||||
|
||||
assertThat(entity)
|
||||
.hasFieldOrPropertyWithValue("username", "test")
|
||||
.hasFieldOrPropertyWithValue("password", "test2")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,331 @@
|
||||
package be.simplenotes.persistance.notes
|
||||
|
||||
import be.simplenotes.domain.model.*
|
||||
import be.simplenotes.domain.usecases.repositories.NoteRepository
|
||||
import be.simplenotes.domain.usecases.repositories.UserRepository
|
||||
import be.simplenotes.persistance.DbMigrations
|
||||
import be.simplenotes.persistance.converters.NoteConverter
|
||||
import be.simplenotes.persistance.migrationModule
|
||||
import be.simplenotes.persistance.persistanceModule
|
||||
import be.simplenotes.shared.config.DataSourceConfig
|
||||
import me.liuwj.ktorm.database.Database
|
||||
import me.liuwj.ktorm.dsl.eq
|
||||
import me.liuwj.ktorm.entity.filter
|
||||
import me.liuwj.ktorm.entity.find
|
||||
import me.liuwj.ktorm.entity.mapColumns
|
||||
import me.liuwj.ktorm.entity.toList
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.assertj.core.api.Assertions.assertThatThrownBy
|
||||
import org.flywaydb.core.Flyway
|
||||
import org.junit.jupiter.api.*
|
||||
import org.junit.jupiter.api.parallel.ResourceLock
|
||||
import org.koin.dsl.koinApplication
|
||||
import org.koin.dsl.module
|
||||
import org.mapstruct.factory.Mappers
|
||||
import java.sql.SQLIntegrityConstraintViolationException
|
||||
import java.util.*
|
||||
import javax.sql.DataSource
|
||||
|
||||
@ResourceLock("h2")
|
||||
internal class NoteRepositoryImplTest {
|
||||
private val testModule = module {
|
||||
single { dataSourceConfig() }
|
||||
}
|
||||
|
||||
private val koinApp = koinApplication {
|
||||
modules(persistanceModule, migrationModule, testModule)
|
||||
}
|
||||
|
||||
private fun dataSourceConfig() = DataSourceConfig(
|
||||
jdbcUrl = "jdbc:h2:mem:regular;DB_CLOSE_DELAY=-1;",
|
||||
driverClassName = "org.h2.Driver",
|
||||
username = "h2",
|
||||
password = "",
|
||||
maximumPoolSize = 2,
|
||||
connectionTimeout = 3000
|
||||
)
|
||||
|
||||
private val koin = koinApp.koin
|
||||
|
||||
@AfterAll
|
||||
fun afterAll() = koinApp.close()
|
||||
|
||||
private val migration = koin.get<DbMigrations>()
|
||||
private val dataSource = koin.get<DataSource>()
|
||||
private val noteRepo = koin.get<NoteRepository>()
|
||||
private val userRepo = koin.get<UserRepository>()
|
||||
private val db = koin.get<Database>()
|
||||
|
||||
private lateinit var user1: PersistedUser
|
||||
private lateinit var user2: PersistedUser
|
||||
|
||||
@BeforeEach
|
||||
fun beforeEach() {
|
||||
Flyway.configure()
|
||||
.dataSource(dataSource)
|
||||
.load()
|
||||
.clean()
|
||||
|
||||
migration.migrate()
|
||||
|
||||
user1 = userRepo.create(User("1", "1"))!!
|
||||
user2 = userRepo.create(User("2", "2"))!!
|
||||
}
|
||||
|
||||
private fun createNote(
|
||||
userId: Int,
|
||||
title: String,
|
||||
tags: List<String> = emptyList(),
|
||||
md: String = "md",
|
||||
html: String = "html",
|
||||
): PersistedNote = noteRepo.create(userId, Note(NoteMetadata(title, tags), md, html))
|
||||
|
||||
private fun PersistedNote.toPersistedMeta() = PersistedNoteMetadata(meta.title, meta.tags, updatedAt, uuid)
|
||||
|
||||
@Nested
|
||||
@DisplayName("create()")
|
||||
inner class Create {
|
||||
|
||||
@Test
|
||||
fun `create note for non existing user`() {
|
||||
val note = Note(NoteMetadata("title", emptyList()), "md", "html")
|
||||
|
||||
assertThatThrownBy {
|
||||
noteRepo.create(1000, note)
|
||||
}.isInstanceOf(SQLIntegrityConstraintViolationException::class.java)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `create note for existing user`() {
|
||||
val note = Note(NoteMetadata("title", emptyList()), "md", "html")
|
||||
|
||||
assertThat(noteRepo.create(user1.id, note))
|
||||
.isEqualToIgnoringGivenFields(note, "uuid", "updatedAt", "public")
|
||||
.hasNoNullFieldsOrProperties()
|
||||
|
||||
assertThat(db.notes.toList())
|
||||
.hasSize(1)
|
||||
.first()
|
||||
.isEqualToIgnoringGivenFields(note, "uuid", "updatedAt", "public")
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@DisplayName("findAll()")
|
||||
inner class FindAll {
|
||||
|
||||
@Test
|
||||
fun `find all notes`() {
|
||||
val notes1 = listOf(
|
||||
createNote(user1.id, "1", listOf("a", "b")),
|
||||
createNote(user1.id, "2"),
|
||||
createNote(user1.id, "3", listOf("c"))
|
||||
)
|
||||
|
||||
val notes2 = listOf(
|
||||
createNote(user2.id, "4")
|
||||
)
|
||||
|
||||
assertThat(noteRepo.findAll(user1.id))
|
||||
.hasSize(3)
|
||||
.usingElementComparatorIgnoringFields("updatedAt")
|
||||
.containsExactlyInAnyOrderElementsOf(
|
||||
notes1.map { it.toPersistedMeta() }
|
||||
)
|
||||
|
||||
assertThat(noteRepo.findAll(user2.id))
|
||||
.hasSize(1)
|
||||
.usingElementComparatorIgnoringFields("updatedAt")
|
||||
.containsExactlyInAnyOrderElementsOf(
|
||||
notes2.map { it.toPersistedMeta() }
|
||||
)
|
||||
|
||||
assertThat(noteRepo.findAll(1000)).isEmpty()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun pagination() {
|
||||
(50 downTo 1).forEach {
|
||||
createNote(user1.id, "$it")
|
||||
}
|
||||
|
||||
assertThat(noteRepo.findAll(user1.id, limit = 20, offset = 0))
|
||||
.hasSize(20)
|
||||
.allMatch { it.title.toInt() in 1..20 }
|
||||
|
||||
assertThat(noteRepo.findAll(user1.id, limit = 20, offset = 20))
|
||||
.hasSize(20)
|
||||
.allMatch { it.title.toInt() in 21..40 }
|
||||
|
||||
assertThat(noteRepo.findAll(user1.id, limit = 20, offset = 40))
|
||||
.hasSize(10)
|
||||
.allMatch { it.title.toInt() in 41..50 }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `find all notes with tag`() {
|
||||
createNote(user1.id, "1", listOf("a", "b"))
|
||||
createNote(user1.id, "2")
|
||||
createNote(user1.id, "3", listOf("c"))
|
||||
createNote(user1.id, "4", listOf("c"))
|
||||
createNote(user2.id, "5", listOf("c"))
|
||||
|
||||
assertThat(noteRepo.findAll(user1.id, tag = "a"))
|
||||
.hasSize(1)
|
||||
.first()
|
||||
.hasFieldOrPropertyWithValue("title", "1")
|
||||
|
||||
assertThat(noteRepo.findAll(user1.id, tag = "c"))
|
||||
.hasSize(2)
|
||||
|
||||
assertThat(noteRepo.findAll(user2.id, tag = "c"))
|
||||
.hasSize(1)
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@DisplayName("find() | exists()")
|
||||
inner class FindExists {
|
||||
@Test
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
fun `find an existing note`() {
|
||||
createNote(user1.id, "1", listOf("a", "b"))
|
||||
|
||||
val converter = Mappers.getMapper(NoteConverter::class.java)
|
||||
|
||||
val note = db.notes.find { it.title eq "1" }!!
|
||||
.let { entity ->
|
||||
val tags = db.tags.filter { it.noteUuid eq entity.uuid }.mapColumns { it.name } as List<String>
|
||||
converter.toPersistedNote(entity, tags)
|
||||
}
|
||||
|
||||
assertThat(noteRepo.find(user1.id, note.uuid))
|
||||
.isEqualTo(note)
|
||||
|
||||
assertThat(noteRepo.exists(user1.id, note.uuid))
|
||||
.isTrue
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `find an existing note from the wrong user`() {
|
||||
val note = createNote(user1.id, "1", listOf("a", "b"))
|
||||
assertThat(noteRepo.find(user2.id, note.uuid)).isNull()
|
||||
assertThat(noteRepo.exists(user2.id, note.uuid)).isFalse
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `find a non existing note`() {
|
||||
createNote(user1.id, "1", listOf("a", "b"))
|
||||
val uuid = UUID.randomUUID()
|
||||
assertThat(noteRepo.find(user1.id, uuid)).isNull()
|
||||
assertThat(noteRepo.exists(user2.id, uuid)).isFalse
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@DisplayName("delete()")
|
||||
inner class Delete {
|
||||
|
||||
@Test
|
||||
fun `delete an existing note for a user should succeed and then fail`() {
|
||||
val note = createNote(user1.id, "1", listOf("a", "b"))
|
||||
assertThat(noteRepo.delete(user1.id, note.uuid))
|
||||
.isTrue
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `delete an existing note for the wrong user`() {
|
||||
val note = createNote(user1.id, "1", listOf("a", "b"))
|
||||
assertThat(noteRepo.delete(1000, note.uuid))
|
||||
.isFalse
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@DisplayName("getTags()")
|
||||
inner class Tags {
|
||||
|
||||
@Test
|
||||
fun getTags() {
|
||||
val notes1 = listOf(
|
||||
createNote(user1.id, "1", listOf("a", "b")),
|
||||
createNote(user1.id, "2"),
|
||||
createNote(user1.id, "3", listOf("c", "a"))
|
||||
)
|
||||
|
||||
val notes2 = listOf(
|
||||
createNote(user2.id, "4", listOf("a"))
|
||||
)
|
||||
|
||||
val user1Tags = notes1.flatMap { it.meta.tags }.toSet()
|
||||
assertThat(noteRepo.getTags(user1.id))
|
||||
.containsExactlyInAnyOrderElementsOf(user1Tags)
|
||||
|
||||
val user2Tags = notes2.flatMap { it.meta.tags }.toSet()
|
||||
assertThat(noteRepo.getTags(user2.id))
|
||||
.containsExactlyInAnyOrderElementsOf(user2Tags)
|
||||
|
||||
assertThat(noteRepo.getTags(1000))
|
||||
.isEmpty()
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@DisplayName("update()")
|
||||
inner class Update {
|
||||
|
||||
@Test
|
||||
fun getTags() {
|
||||
val note1 = createNote(user1.id, "1", listOf("a", "b"))
|
||||
val newNote1 = Note(meta = note1.meta, markdown = "new", "new")
|
||||
assertThat(noteRepo.update(user1.id, note1.uuid, newNote1))
|
||||
.isNotNull
|
||||
|
||||
assertThat(noteRepo.find(user1.id, note1.uuid))
|
||||
.isEqualToComparingOnlyGivenFields(newNote1, "meta", "markdown", "html")
|
||||
|
||||
val note2 = createNote(user1.id, "2")
|
||||
val newNote2 = Note(meta = note1.meta.copy(tags = listOf("a")), markdown = "new", "new")
|
||||
assertThat(noteRepo.update(user1.id, note2.uuid, newNote2))
|
||||
.isNotNull
|
||||
|
||||
assertThat(noteRepo.find(user1.id, note2.uuid))
|
||||
.isEqualToComparingOnlyGivenFields(newNote2, "meta", "markdown", "html")
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
inner class Trash {
|
||||
|
||||
@Test
|
||||
fun `trashed noted should be restored`() {
|
||||
val note1 = createNote(user1.id, "1", listOf("a", "b"))
|
||||
|
||||
assertThat(noteRepo.delete(user1.id, note1.uuid, permanent = false))
|
||||
.isTrue
|
||||
|
||||
val isDeleted = db.notes
|
||||
.find { it.uuid eq note1.uuid }
|
||||
?.deleted
|
||||
|
||||
assertThat(isDeleted).`as`("Check that Notes.deleted is true").isTrue
|
||||
|
||||
assertThat(noteRepo.restore(user1.id, note1.uuid)).isTrue
|
||||
|
||||
val isDeleted2 = db.notes
|
||||
.find { it.uuid eq note1.uuid }
|
||||
?.deleted
|
||||
|
||||
assertThat(isDeleted2).`as`("Check that Notes.deleted is false after restore()").isFalse
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `permanent delete`() {
|
||||
val note1 = createNote(user1.id, "1", listOf("a", "b"))
|
||||
assertThat(noteRepo.delete(user1.id, note1.uuid, permanent = true))
|
||||
.isTrue
|
||||
|
||||
assertThat(noteRepo.restore(user1.id, note1.uuid)).isFalse
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
package be.simplenotes.persistance.users
|
||||
|
||||
import be.simplenotes.domain.model.User
|
||||
import be.simplenotes.domain.usecases.repositories.UserRepository
|
||||
import be.simplenotes.persistance.DbMigrations
|
||||
import be.simplenotes.persistance.migrationModule
|
||||
import be.simplenotes.persistance.persistanceModule
|
||||
import be.simplenotes.shared.config.DataSourceConfig
|
||||
import me.liuwj.ktorm.database.*
|
||||
import me.liuwj.ktorm.dsl.*
|
||||
import me.liuwj.ktorm.entity.*
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.flywaydb.core.Flyway
|
||||
import org.junit.jupiter.api.AfterAll
|
||||
import org.junit.jupiter.api.BeforeEach
|
||||
import org.junit.jupiter.api.Nested
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.junit.jupiter.api.parallel.ResourceLock
|
||||
import org.koin.dsl.koinApplication
|
||||
import org.koin.dsl.module
|
||||
import javax.sql.DataSource
|
||||
|
||||
@ResourceLock("h2")
|
||||
internal class UserRepositoryImplTest {
|
||||
|
||||
// region setup
|
||||
private val testModule = module {
|
||||
single { dataSourceConfig() }
|
||||
}
|
||||
|
||||
private val koinApp = koinApplication {
|
||||
modules(persistanceModule, migrationModule, testModule)
|
||||
}
|
||||
|
||||
private fun dataSourceConfig() = DataSourceConfig(
|
||||
jdbcUrl = "jdbc:h2:mem:regular;DB_CLOSE_DELAY=-1;",
|
||||
driverClassName = "org.h2.Driver",
|
||||
username = "h2",
|
||||
password = "",
|
||||
maximumPoolSize = 2,
|
||||
connectionTimeout = 3000
|
||||
)
|
||||
|
||||
private val koin = koinApp.koin
|
||||
|
||||
@AfterAll
|
||||
fun afterAll() = koinApp.close()
|
||||
|
||||
private val migration = koin.get<DbMigrations>()
|
||||
private val dataSource = koin.get<DataSource>()
|
||||
private val userRepo = koin.get<UserRepository>()
|
||||
private val db = koin.get<Database>()
|
||||
|
||||
@BeforeEach
|
||||
fun beforeEach() {
|
||||
Flyway.configure()
|
||||
.dataSource(dataSource)
|
||||
.load()
|
||||
.clean()
|
||||
migration.migrate()
|
||||
}
|
||||
// endregion setup
|
||||
|
||||
@Test
|
||||
fun `insert user`() {
|
||||
val user = User("username", "test")
|
||||
assertThat(userRepo.create(user))
|
||||
.isNotNull
|
||||
.hasFieldOrPropertyWithValue("username", user.username)
|
||||
.hasFieldOrPropertyWithValue("password", user.password)
|
||||
|
||||
assertThat(db.users.find { it.username eq user.username }).isNotNull
|
||||
assertThat(db.users.toList()).hasSize(1)
|
||||
assertThat(userRepo.create(user)).isNull()
|
||||
}
|
||||
|
||||
@Nested
|
||||
inner class Query {
|
||||
|
||||
@Test
|
||||
fun `query existing user`() {
|
||||
val user = User("username", "test")
|
||||
userRepo.create(user)
|
||||
|
||||
val foundUserMaybe = userRepo.find(user.username)
|
||||
assertThat(foundUserMaybe).isNotNull
|
||||
val foundUser = foundUserMaybe!!
|
||||
assertThat(foundUser).isEqualToIgnoringGivenFields(user, "id")
|
||||
assertThat(userRepo.exists(user.username)).isTrue
|
||||
assertThat(userRepo.find(foundUser.id)).isEqualTo(foundUser)
|
||||
assertThat(userRepo.exists(foundUser.id)).isTrue
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `query non existing user`() {
|
||||
assertThat(userRepo.find("I don't exist")).isNull()
|
||||
assertThat(userRepo.find(1)).isNull()
|
||||
assertThat(userRepo.exists(1)).isFalse
|
||||
assertThat(userRepo.exists("I don't exist")).isFalse
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
inner class Delete {
|
||||
|
||||
@Test
|
||||
fun `delete existing user`() {
|
||||
val user = User("username", "test")
|
||||
userRepo.create(user)
|
||||
|
||||
val foundUser = userRepo.find(user.username)!!
|
||||
assertThat(userRepo.delete(foundUser.id)).isTrue
|
||||
assertThat(db.users.toList()).isEmpty()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `delete non existing user`() {
|
||||
assertThat(userRepo.delete(1)).isFalse
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user