Flatten packages
Remove modules prefix
This commit is contained in:
@@ -0,0 +1,24 @@
|
||||
package be.simplenotes.persistance
|
||||
|
||||
import be.simplenotes.config.DataSourceConfig
|
||||
import org.testcontainers.containers.MariaDBContainer
|
||||
|
||||
class KMariadbContainer : MariaDBContainer<KMariadbContainer>("mariadb:10.5.5")
|
||||
|
||||
fun h2dataSourceConfig() = DataSourceConfig(
|
||||
jdbcUrl = "jdbc:h2:mem:regular;DB_CLOSE_DELAY=-1;",
|
||||
driverClassName = "org.h2.Driver",
|
||||
username = "h2",
|
||||
password = "",
|
||||
maximumPoolSize = 2,
|
||||
connectionTimeout = 3000
|
||||
)
|
||||
|
||||
fun mariadbDataSourceConfig(jdbcUrl: String) = DataSourceConfig(
|
||||
jdbcUrl = jdbcUrl,
|
||||
driverClassName = "org.mariadb.jdbc.Driver",
|
||||
username = "test",
|
||||
password = "test",
|
||||
maximumPoolSize = 2,
|
||||
connectionTimeout = 3000
|
||||
)
|
||||
@@ -0,0 +1,35 @@
|
||||
package be.simplenotes.persistance
|
||||
|
||||
import be.simplenotes.config.DataSourceConfig
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.junit.jupiter.api.parallel.ResourceLock
|
||||
|
||||
@ResourceLock("h2")
|
||||
class H2DbHealthCheckImplTest : DbTest() {
|
||||
override fun dataSourceConfig() = h2dataSourceConfig()
|
||||
|
||||
@Test
|
||||
fun healthCheck() {
|
||||
assertThat(beanContext.getBean<DbHealthCheck>().isOk()).isTrue
|
||||
}
|
||||
}
|
||||
|
||||
@ResourceLock("mariadb")
|
||||
class MariaDbHealthCheckImplTest : DbTest() {
|
||||
lateinit var mariaDB: KMariadbContainer
|
||||
|
||||
override fun dataSourceConfig(): DataSourceConfig {
|
||||
mariaDB = KMariadbContainer()
|
||||
mariaDB.start()
|
||||
return mariadbDataSourceConfig(mariaDB.jdbcUrl)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun healthCheck() {
|
||||
val healthCheck = beanContext.getBean<DbHealthCheck>()
|
||||
assertThat(healthCheck.isOk()).isTrue
|
||||
mariaDB.stop()
|
||||
assertThat(healthCheck.isOk()).isFalse
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
package be.simplenotes.persistance
|
||||
|
||||
import be.simplenotes.config.DataSourceConfig
|
||||
import io.micronaut.context.BeanContext
|
||||
import org.flywaydb.core.Flyway
|
||||
import org.junit.jupiter.api.AfterAll
|
||||
import org.junit.jupiter.api.BeforeAll
|
||||
import org.junit.jupiter.api.BeforeEach
|
||||
import javax.sql.DataSource
|
||||
|
||||
abstract class DbTest {
|
||||
|
||||
abstract fun dataSourceConfig(): DataSourceConfig
|
||||
|
||||
val beanContext = BeanContext
|
||||
.build()
|
||||
|
||||
inline fun <reified T> BeanContext.getBean(): T = getBean(T::class.java)
|
||||
|
||||
@BeforeAll
|
||||
fun setComponent() {
|
||||
beanContext
|
||||
.registerSingleton(dataSourceConfig())
|
||||
.start()
|
||||
}
|
||||
|
||||
@BeforeEach
|
||||
fun beforeEach() {
|
||||
val migration = beanContext.getBean<DbMigrations>()
|
||||
val dataSource = beanContext.getBean<DataSource>()
|
||||
|
||||
Flyway.configure()
|
||||
.dataSource(dataSource)
|
||||
.load()
|
||||
.clean()
|
||||
|
||||
migration.migrate()
|
||||
}
|
||||
|
||||
@AfterAll
|
||||
fun closeCtx() {
|
||||
beanContext.close()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,164 @@
|
||||
package be.simplenotes.persistance.converters
|
||||
|
||||
import be.simplenotes.persistance.notes.NoteEntity
|
||||
import be.simplenotes.types.*
|
||||
import io.micronaut.context.BeanContext
|
||||
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 java.time.LocalDateTime
|
||||
import java.util.*
|
||||
|
||||
internal class NoteConverterTest {
|
||||
|
||||
private val ctx = BeanContext.run()
|
||||
val converter = ctx.getBean(NoteConverter::class.java)
|
||||
|
||||
@Nested
|
||||
@DisplayName("Entity -> Models")
|
||||
inner class EntityToModels {
|
||||
|
||||
@Test
|
||||
fun `convert NoteEntity to Note`() {
|
||||
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 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 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 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 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 noteMetadata = NoteMetadata("title", emptyList())
|
||||
val entity = converter.toEntity(noteMetadata)
|
||||
|
||||
assertThat(entity)
|
||||
.hasFieldOrPropertyWithValue("title", "title")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `convert PersistedNote to NoteEntity`() {
|
||||
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 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.persistance.users.UserEntity
|
||||
import be.simplenotes.types.PersistedUser
|
||||
import be.simplenotes.types.User
|
||||
import io.micronaut.context.BeanContext
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
internal class UserConverterTest {
|
||||
|
||||
private val ctx = BeanContext.run()
|
||||
private val converter = ctx.getBean(UserConverter::class.java)
|
||||
|
||||
@Test
|
||||
fun `convert UserEntity to User`() {
|
||||
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 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 user = User("test", "test2")
|
||||
val entity = converter.toEntity(user)
|
||||
|
||||
assertThat(entity)
|
||||
.hasFieldOrPropertyWithValue("username", "test")
|
||||
.hasFieldOrPropertyWithValue("password", "test2")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,329 @@
|
||||
package be.simplenotes.persistance.notes
|
||||
|
||||
import be.simplenotes.persistance.DbTest
|
||||
import be.simplenotes.persistance.converters.NoteConverter
|
||||
import be.simplenotes.persistance.repositories.NoteRepository
|
||||
import be.simplenotes.persistance.repositories.UserRepository
|
||||
import be.simplenotes.persistance.users.createFakeUser
|
||||
import be.simplenotes.types.ExportedNote
|
||||
import be.simplenotes.types.PersistedUser
|
||||
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.junit.jupiter.api.*
|
||||
import java.sql.SQLIntegrityConstraintViolationException
|
||||
|
||||
internal abstract class BaseNoteRepositoryImplTest : DbTest() {
|
||||
|
||||
private lateinit var noteRepo: NoteRepository
|
||||
private lateinit var userRepo: UserRepository
|
||||
private lateinit var db: Database
|
||||
|
||||
private lateinit var user1: PersistedUser
|
||||
private lateinit var user2: PersistedUser
|
||||
|
||||
@BeforeEach
|
||||
fun insertUsers() {
|
||||
noteRepo = beanContext.getBean()
|
||||
userRepo = beanContext.getBean()
|
||||
db = beanContext.getBean()
|
||||
user1 = userRepo.createFakeUser()!!
|
||||
user2 = userRepo.createFakeUser()!!
|
||||
}
|
||||
|
||||
@Nested
|
||||
@DisplayName("create()")
|
||||
inner class Create {
|
||||
|
||||
@Test
|
||||
fun `create note for non existing user`() {
|
||||
val note = fakeNote()
|
||||
|
||||
assertThatThrownBy {
|
||||
noteRepo.create(1000, note)
|
||||
}.isInstanceOf(SQLIntegrityConstraintViolationException::class.java)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `create note for existing user`() {
|
||||
val note = fakeNote()
|
||||
|
||||
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 = noteRepo.insertFakeNotes(user1, count = 3)
|
||||
val notes2 = listOf(noteRepo.insertFakeNote(user2))
|
||||
|
||||
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()
|
||||
}
|
||||
|
||||
// TODO: datetime -> timestamp migration
|
||||
@Disabled("Not working with mariadb, inserts are too fast so the updated_at is the same")
|
||||
@Test
|
||||
fun pagination() {
|
||||
(50 downTo 1).forEach { i ->
|
||||
noteRepo.insertFakeNote(user1, "$i")
|
||||
}
|
||||
|
||||
assertThat(noteRepo.findAll(user1.id, limit = 20, offset = 0).onEach { println(it) })
|
||||
.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`() {
|
||||
with(noteRepo) {
|
||||
insertFakeNote(user1, "1", listOf("a", "b"))
|
||||
insertFakeNote(user1, "2", tags = emptyList())
|
||||
insertFakeNote(user1, "3", listOf("c"))
|
||||
insertFakeNote(user1, "4", listOf("c"))
|
||||
insertFakeNote(user2, "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`() {
|
||||
val fakeNote = noteRepo.insertFakeNote(user1)
|
||||
|
||||
val converter = beanContext.getBean(NoteConverter::class.java)
|
||||
|
||||
val note = db.notes.find { it.title eq fakeNote.meta.title }!!
|
||||
.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 = noteRepo.insertFakeNote(user1)
|
||||
assertThat(noteRepo.find(user2.id, note.uuid)).isNull()
|
||||
assertThat(noteRepo.exists(user2.id, note.uuid)).isFalse
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `find a non existing note`() {
|
||||
noteRepo.insertFakeNote(user1)
|
||||
val uuid = fakeUuid()
|
||||
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 = noteRepo.insertFakeNote(user1)
|
||||
assertThat(noteRepo.delete(user1.id, note.uuid)).isTrue
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `delete an existing note for the wrong user`() {
|
||||
val note = noteRepo.insertFakeNote(user1)
|
||||
assertThat(noteRepo.delete(1000, note.uuid)).isFalse
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@DisplayName("getTags()")
|
||||
inner class Tags {
|
||||
|
||||
@Test
|
||||
fun getTags() {
|
||||
val notes1 = noteRepo.insertFakeNotes(user1, count = 3)
|
||||
val notes2 = noteRepo.insertFakeNotes(user2, count = 1)
|
||||
|
||||
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 = noteRepo.insertFakeNote(user1)
|
||||
val newNote1 = fakeNote()
|
||||
|
||||
assertThat(noteRepo.update(user1.id, note1.uuid, newNote1)).isNotNull
|
||||
|
||||
assertThat(noteRepo.find(user1.id, note1.uuid))
|
||||
.isEqualToComparingOnlyGivenFields(newNote1, "meta", "markdown", "html")
|
||||
|
||||
val note2 = noteRepo.insertFakeNote(user1)
|
||||
val newNote2 = fakeNote().let {
|
||||
it.copy(meta = it.meta.copy(tags = tagGenerator().take(3).toList()))
|
||||
}
|
||||
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 = noteRepo.insertFakeNote(user1, "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 note = noteRepo.insertFakeNote(user1)
|
||||
assertThat(noteRepo.delete(user1.id, note.uuid, permanent = true)).isTrue
|
||||
assertThat(noteRepo.restore(user1.id, note.uuid)).isFalse
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun count() {
|
||||
assertThat(noteRepo.count(user1.id)).isEqualTo(0)
|
||||
|
||||
noteRepo.insertFakeNotes(user1, count = 10)
|
||||
assertThat(noteRepo.count(user1.id)).isEqualTo(10)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun countWithTag() {
|
||||
noteRepo.insertFakeNote(user1, tags = listOf("a", "b"))
|
||||
noteRepo.insertFakeNote(user1, tags = emptyList())
|
||||
noteRepo.insertFakeNote(user1, tags = listOf("a"))
|
||||
noteRepo.insertFakeNote(user1, tags = emptyList())
|
||||
|
||||
assertThat(noteRepo.count(user1.id, tag = "a")).isEqualTo(2)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun export() {
|
||||
val notes = noteRepo.insertFakeNotes(user1, count = 4)
|
||||
noteRepo.delete(user1.id, notes.first().uuid, permanent = false)
|
||||
|
||||
val export = noteRepo.export(user1.id)
|
||||
|
||||
val expected = notes.mapIndexed { i, n ->
|
||||
ExportedNote(
|
||||
title = n.meta.title,
|
||||
tags = n.meta.tags,
|
||||
markdown = n.markdown,
|
||||
html = n.html,
|
||||
updatedAt = n.updatedAt,
|
||||
trash = i == 0,
|
||||
)
|
||||
}
|
||||
assertThat(export)
|
||||
.usingElementComparatorIgnoringFields("updatedAt")
|
||||
.containsExactlyInAnyOrderElementsOf(expected)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun findAllDetails() {
|
||||
val notes = noteRepo.insertFakeNotes(user1, count = 10)
|
||||
val res = noteRepo.findAllDetails(user1.id)
|
||||
assertThat(res)
|
||||
.usingElementComparatorIgnoringFields("updatedAt")
|
||||
.containsExactlyInAnyOrderElementsOf(notes)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun access() {
|
||||
val n = noteRepo.insertFakeNote(user1)
|
||||
noteRepo.makePublic(user1.id, n.uuid)
|
||||
assertThat(noteRepo.findPublic(n.uuid))
|
||||
.isEqualToIgnoringGivenFields(n.copy(public = true), "updatedAt")
|
||||
|
||||
noteRepo.makePrivate(user1.id, n.uuid)
|
||||
assertThat(noteRepo.findPublic(n.uuid)).isNull()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
package be.simplenotes.persistance.notes
|
||||
|
||||
import be.simplenotes.config.DataSourceConfig
|
||||
import be.simplenotes.persistance.KMariadbContainer
|
||||
import be.simplenotes.persistance.h2dataSourceConfig
|
||||
import be.simplenotes.persistance.mariadbDataSourceConfig
|
||||
import org.junit.jupiter.api.AfterAll
|
||||
import org.junit.jupiter.api.parallel.ResourceLock
|
||||
|
||||
@ResourceLock("h2")
|
||||
internal class H2NoteRepositoryImplTests : BaseNoteRepositoryImplTest() {
|
||||
override fun dataSourceConfig() = h2dataSourceConfig()
|
||||
}
|
||||
|
||||
@ResourceLock("mariadb")
|
||||
internal class MariaDbNoteRepositoryImplTests : BaseNoteRepositoryImplTest() {
|
||||
lateinit var mariaDB: KMariadbContainer
|
||||
|
||||
@AfterAll
|
||||
fun stopMariaDB() {
|
||||
mariaDB.stop()
|
||||
}
|
||||
|
||||
override fun dataSourceConfig(): DataSourceConfig {
|
||||
mariaDB = KMariadbContainer()
|
||||
mariaDB.start()
|
||||
return mariadbDataSourceConfig(mariaDB.jdbcUrl)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
package be.simplenotes.persistance.users
|
||||
|
||||
import be.simplenotes.persistance.DbTest
|
||||
import be.simplenotes.persistance.repositories.UserRepository
|
||||
import me.liuwj.ktorm.database.Database
|
||||
import me.liuwj.ktorm.dsl.eq
|
||||
import me.liuwj.ktorm.entity.find
|
||||
import me.liuwj.ktorm.entity.toList
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.junit.jupiter.api.BeforeEach
|
||||
import org.junit.jupiter.api.Nested
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
internal abstract class BaseUserRepositoryImplTest : DbTest() {
|
||||
|
||||
private lateinit var userRepo: UserRepository
|
||||
private lateinit var db: Database
|
||||
|
||||
@BeforeEach
|
||||
fun setup() {
|
||||
userRepo = beanContext.getBean()
|
||||
db = beanContext.getBean()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `insert user`() {
|
||||
val user = fakeUser()
|
||||
assertThat(userRepo.create(user))
|
||||
.isNotNull
|
||||
.extracting("username", "password")
|
||||
.contains(user.username, 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 = fakeUser()
|
||||
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 = fakeUser()
|
||||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
package be.simplenotes.persistance.users
|
||||
|
||||
import be.simplenotes.config.DataSourceConfig
|
||||
import be.simplenotes.persistance.KMariadbContainer
|
||||
import be.simplenotes.persistance.h2dataSourceConfig
|
||||
import be.simplenotes.persistance.mariadbDataSourceConfig
|
||||
import org.junit.jupiter.api.AfterAll
|
||||
import org.junit.jupiter.api.parallel.ResourceLock
|
||||
|
||||
@ResourceLock("h2")
|
||||
internal class UserRepositoryImplTest : BaseUserRepositoryImplTest() {
|
||||
override fun dataSourceConfig() = h2dataSourceConfig()
|
||||
}
|
||||
|
||||
@ResourceLock("mariadb")
|
||||
internal class MariaDbUserRepositoryImplTest : BaseUserRepositoryImplTest() {
|
||||
lateinit var mariaDB: KMariadbContainer
|
||||
|
||||
@AfterAll
|
||||
fun stopMariaDB() {
|
||||
mariaDB.stop()
|
||||
}
|
||||
|
||||
override fun dataSourceConfig(): DataSourceConfig {
|
||||
mariaDB = KMariadbContainer()
|
||||
mariaDB.start()
|
||||
return mariadbDataSourceConfig(mariaDB.jdbcUrl)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user