From cb76a3253dc983fd52492488812ae6161fe837e4 Mon Sep 17 00:00:00 2001 From: Hubert Van De Walle Date: Wed, 21 Oct 2020 21:34:57 +0200 Subject: [PATCH] Use mapstruct --- persistance/pom.xml | 4 + .../src/main/kotlin/PersistanceModule.kt | 10 +- .../main/kotlin/converters/NoteConverter.kt | 80 +++++++++ .../main/kotlin/converters/UserConverter.kt | 17 ++ .../main/kotlin/notes/NoteRepositoryImpl.kt | 39 ++-- persistance/src/main/kotlin/notes/Notes.kt | 27 +-- .../main/kotlin/users/UserRepositoryImpl.kt | 12 +- persistance/src/main/kotlin/users/Users.kt | 14 +- .../kotlin/converters/NoteConverterTest.kt | 168 ++++++++++++++++++ .../kotlin/converters/UserConverterTest.kt | 48 +++++ .../kotlin/notes/NoteRepositoryImplTest.kt | 15 +- pom.xml | 23 +++ 12 files changed, 390 insertions(+), 67 deletions(-) create mode 100644 persistance/src/main/kotlin/converters/NoteConverter.kt create mode 100644 persistance/src/main/kotlin/converters/UserConverter.kt create mode 100644 persistance/src/test/kotlin/converters/NoteConverterTest.kt create mode 100644 persistance/src/test/kotlin/converters/UserConverterTest.kt diff --git a/persistance/pom.xml b/persistance/pom.xml index 4d7baa1..cd47ef7 100644 --- a/persistance/pom.xml +++ b/persistance/pom.xml @@ -11,6 +11,10 @@ persistance + + org.mapstruct + mapstruct + be.simplenotes domain diff --git a/persistance/src/main/kotlin/PersistanceModule.kt b/persistance/src/main/kotlin/PersistanceModule.kt index 1d6a334..0769295 100644 --- a/persistance/src/main/kotlin/PersistanceModule.kt +++ b/persistance/src/main/kotlin/PersistanceModule.kt @@ -2,6 +2,10 @@ package be.simplenotes.persistance import be.simplenotes.domain.usecases.repositories.NoteRepository import be.simplenotes.domain.usecases.repositories.UserRepository +import be.simplenotes.persistance.converters.NoteConverter +import be.simplenotes.persistance.converters.NoteConverterImpl +import be.simplenotes.persistance.converters.UserConverter +import be.simplenotes.persistance.converters.UserConverterImpl import be.simplenotes.persistance.notes.NoteRepositoryImpl import be.simplenotes.persistance.users.UserRepositoryImpl import be.simplenotes.shared.config.DataSourceConfig @@ -30,8 +34,10 @@ val migrationModule = module { } val persistanceModule = module { - single { UserRepositoryImpl(get()) } - single { NoteRepositoryImpl(get()) } + single { NoteConverterImpl() } + single { UserConverterImpl() } + single { UserRepositoryImpl(get(), get()) } + single { NoteRepositoryImpl(get(), get()) } single { hikariDataSource(get()) } bind DataSource::class onClose { it?.close() } single { get().migrate() diff --git a/persistance/src/main/kotlin/converters/NoteConverter.kt b/persistance/src/main/kotlin/converters/NoteConverter.kt new file mode 100644 index 0000000..1939a52 --- /dev/null +++ b/persistance/src/main/kotlin/converters/NoteConverter.kt @@ -0,0 +1,80 @@ +package be.simplenotes.persistance.converters + +import be.simplenotes.domain.model.* +import be.simplenotes.persistance.notes.NoteEntity +import me.liuwj.ktorm.entity.Entity +import org.mapstruct.Mapper +import org.mapstruct.Mapping +import org.mapstruct.Mappings +import java.time.LocalDateTime +import java.util.* + + +/** + * This is an abstract class because kotlin default methods in interface are not seen as default in kapt + * @see [KT-25960](https://youtrack.jetbrains.com/issue/KT-25960) + */ +@Mapper(uses = [NoteEntityFactory::class, UserEntityFactory::class]) +internal abstract class NoteConverter { + + fun toNote(entity: NoteEntity, tags: Tags) = + Note(NoteMetadata(title = entity.title, tags = tags), entity.markdown, entity.html) + + @Mappings( + Mapping(target = ".", source = "entity"), + Mapping(target = "tags", source = "tags"), + ) + abstract fun toNoteMetadata(entity: NoteEntity, tags: Tags): NoteMetadata + + @Mappings( + Mapping(target = ".", source = "entity"), + Mapping(target = "tags", source = "tags"), + ) + abstract fun toPersistedNoteMetadata(entity: NoteEntity, tags: Tags): PersistedNoteMetadata + + fun toPersistedNote(entity: NoteEntity, tags: Tags) = PersistedNote( + NoteMetadata(title = entity.title, tags = tags), + entity.markdown, entity.html, entity.updatedAt, entity.uuid, entity.public + ) + + @Mappings( + Mapping(target = ".", source = "entity"), + Mapping(target = "trash", source = "entity.deleted"), + Mapping(target = "tags", source = "tags"), + ) + abstract fun toExportedNote(entity: NoteEntity, tags: Tags): ExportedNote + + fun toEntity(note: Note, uuid: UUID, userId: Int, updatedAt: LocalDateTime) = NoteEntity { + this.title = note.meta.title + this.markdown = note.markdown + this.html = note.html + this.uuid = uuid + this.deleted = false + this.public = false + this.user.id = userId + this.updatedAt = updatedAt + } + + @Mappings( + Mapping(target = ".", source = "note"), + Mapping(target = "updatedAt", source = "updatedAt"), + Mapping(target = "uuid", source = "uuid"), + Mapping(target = "public", constant = "false"), + ) + abstract fun toPersistedNote(note: Note, updatedAt: LocalDateTime, uuid: UUID): PersistedNote + + abstract fun toEntity(persistedNoteMetadata: PersistedNoteMetadata): NoteEntity + + abstract fun toEntity(noteMetadata: NoteMetadata): NoteEntity + + @Mapping(target = "title", source = "meta.title") + abstract fun toEntity(persistedNote: PersistedNote): NoteEntity + + @Mapping(target = "deleted", source = "trash") + abstract fun toEntity(exportedNote: ExportedNote): NoteEntity + +} + +typealias Tags = List + +internal class NoteEntityFactory : Entity.Factory() diff --git a/persistance/src/main/kotlin/converters/UserConverter.kt b/persistance/src/main/kotlin/converters/UserConverter.kt new file mode 100644 index 0000000..6520003 --- /dev/null +++ b/persistance/src/main/kotlin/converters/UserConverter.kt @@ -0,0 +1,17 @@ +package be.simplenotes.persistance.converters + +import be.simplenotes.domain.model.PersistedUser +import be.simplenotes.domain.model.User +import be.simplenotes.persistance.users.UserEntity +import me.liuwj.ktorm.entity.Entity +import org.mapstruct.Mapper + +@Mapper(uses = [UserEntityFactory::class]) +internal interface UserConverter { + fun toUser(userEntity: UserEntity): User + fun toPersistedUser(userEntity: UserEntity): PersistedUser + fun toEntity(user: User): UserEntity + fun toEntity(user: PersistedUser): UserEntity +} + +internal class UserEntityFactory : Entity.Factory() diff --git a/persistance/src/main/kotlin/notes/NoteRepositoryImpl.kt b/persistance/src/main/kotlin/notes/NoteRepositoryImpl.kt index 8bfab7e..3b65189 100644 --- a/persistance/src/main/kotlin/notes/NoteRepositoryImpl.kt +++ b/persistance/src/main/kotlin/notes/NoteRepositoryImpl.kt @@ -5,6 +5,7 @@ import be.simplenotes.domain.model.Note import be.simplenotes.domain.model.PersistedNote import be.simplenotes.domain.model.PersistedNoteMetadata import be.simplenotes.domain.usecases.repositories.NoteRepository +import be.simplenotes.persistance.converters.NoteConverter import me.liuwj.ktorm.database.Database import me.liuwj.ktorm.dsl.* import me.liuwj.ktorm.entity.* @@ -12,7 +13,7 @@ import java.time.LocalDateTime import java.util.* import kotlin.collections.HashMap -internal class NoteRepositoryImpl(private val db: Database) : NoteRepository { +internal class NoteRepositoryImpl(private val db: Database, private val converter: NoteConverter) : NoteRepository { @Throws(IllegalArgumentException::class) override fun findAll( @@ -20,7 +21,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository { limit: Int, offset: Int, tag: String?, - deleted: Boolean + deleted: Boolean, ): List { require(limit > 0) { "limit should be positive" } require(offset >= 0) { "offset should not be negative" } @@ -49,7 +50,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository { return notes.map { note -> val tags = tagsByUuid[note.uuid] ?: emptyList() - note.toPersistedMetadata(tags) + converter.toPersistedNoteMetadata(note, tags) } } @@ -59,9 +60,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository { override fun create(userId: Int, note: Note): PersistedNote { val uuid = UUID.randomUUID() - val entity = note.toEntity(uuid, userId).apply { - this.updatedAt = LocalDateTime.now() - } + val entity = converter.toEntity(note, uuid, userId, LocalDateTime.now()) db.notes.add(entity) db.batchInsert(Tags) { note.meta.tags.forEach { tagName -> @@ -71,8 +70,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository { } } } - - return entity.toPersistedNote(note.meta.tags) + return converter.toPersistedNote(entity, note.meta.tags) } override fun find(userId: Int, uuid: UUID): PersistedNote? { @@ -87,7 +85,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository { .where { Tags.noteUuid eq uuid } .map { it[Tags.name]!! } - return note.toPersistedNote(tags) + return converter.toPersistedNote(note, tags) } override fun update(userId: Int, uuid: UUID, note: Note): PersistedNote? { @@ -115,14 +113,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository { } } - return PersistedNote( - meta = note.meta, - markdown = note.markdown, - html = note.html, - updatedAt = now, - uuid = uuid, - public = false, // TODO - ) + return converter.toPersistedNote(note, now, uuid) } override fun delete(userId: Int, uuid: UUID, permanent: Boolean): Boolean { @@ -168,14 +159,8 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository { val tagsByUuid = notes.tagsByUuid() return notes.map { note -> - ExportedNote( - title = note.title, - tags = tagsByUuid[note.uuid] ?: emptyList(), - markdown = note.markdown, - html = note.html, - updatedAt = note.updatedAt, - trash = note.deleted, - ) + val tags = tagsByUuid[note.uuid] ?: emptyList() + converter.toExportedNote(note, tags) } } @@ -189,7 +174,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository { return notes.map { note -> val tags = tagsByUuid[note.uuid] ?: emptyList() - note.toPersistedNote(tags) + converter.toPersistedNote(note, tags) } } @@ -216,7 +201,7 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository { .where { Tags.noteUuid eq uuid } .map { it[Tags.name]!! } - return note.toPersistedNote(tags) + return converter.toPersistedNote(note, tags) } private fun List.tagsByUuid(): Map> { diff --git a/persistance/src/main/kotlin/notes/Notes.kt b/persistance/src/main/kotlin/notes/Notes.kt index f943c8a..a7b5c60 100644 --- a/persistance/src/main/kotlin/notes/Notes.kt +++ b/persistance/src/main/kotlin/notes/Notes.kt @@ -2,15 +2,12 @@ package be.simplenotes.persistance.notes -import be.simplenotes.domain.model.Note -import be.simplenotes.domain.model.NoteMetadata -import be.simplenotes.domain.model.PersistedNote -import be.simplenotes.domain.model.PersistedNoteMetadata import be.simplenotes.persistance.extensions.uuidBinary import be.simplenotes.persistance.users.UserEntity import be.simplenotes.persistance.users.Users -import me.liuwj.ktorm.database.* -import me.liuwj.ktorm.entity.* +import me.liuwj.ktorm.database.Database +import me.liuwj.ktorm.entity.Entity +import me.liuwj.ktorm.entity.sequenceOf import me.liuwj.ktorm.schema.* import java.time.LocalDateTime import java.util.* @@ -46,21 +43,3 @@ internal interface NoteEntity : Entity { var user: UserEntity } - -internal fun NoteEntity.toPersistedMetadata(tags: List) = PersistedNoteMetadata(title, tags, updatedAt, uuid) - -internal fun NoteEntity.toPersistedNote(tags: List) = - PersistedNote(NoteMetadata(title, tags), markdown, html, updatedAt, uuid, public) - -internal fun Note.toEntity(uuid: UUID, userId: Int): NoteEntity { - val note = this - return NoteEntity { - this.title = note.meta.title - this.markdown = note.markdown - this.html = note.html - this.uuid = uuid - this.deleted = false - this.public = false - this.user["id"] = userId - } -} diff --git a/persistance/src/main/kotlin/users/UserRepositoryImpl.kt b/persistance/src/main/kotlin/users/UserRepositoryImpl.kt index d53f2ea..5e20ba0 100644 --- a/persistance/src/main/kotlin/users/UserRepositoryImpl.kt +++ b/persistance/src/main/kotlin/users/UserRepositoryImpl.kt @@ -3,13 +3,14 @@ package be.simplenotes.persistance.users import be.simplenotes.domain.model.PersistedUser import be.simplenotes.domain.model.User import be.simplenotes.domain.usecases.repositories.UserRepository +import be.simplenotes.persistance.converters.UserConverter import me.liuwj.ktorm.database.Database import me.liuwj.ktorm.dsl.* import me.liuwj.ktorm.entity.any import me.liuwj.ktorm.entity.find import java.sql.SQLIntegrityConstraintViolationException -internal class UserRepositoryImpl(private val db: Database) : UserRepository { +internal class UserRepositoryImpl(private val db: Database, private val converter: UserConverter) : UserRepository { override fun create(user: User): PersistedUser? { return try { val id = db.insertAndGenerateKey(Users) { @@ -22,8 +23,13 @@ internal class UserRepositoryImpl(private val db: Database) : UserRepository { } } - override fun find(username: String) = db.users.find { it.username eq username }?.toPersistedUser() - override fun find(id: Int) = db.users.find { it.id eq id }?.toPersistedUser() + override fun find(username: String) = db.users.find { it.username eq username } + ?.let { converter.toPersistedUser(it) } + + override fun find(id: Int) = db.users.find { it.id eq id }?.let { + converter.toPersistedUser(it) + } + override fun exists(username: String) = db.users.any { it.username eq username } override fun exists(id: Int) = db.users.any { it.id eq id } override fun delete(id: Int) = db.delete(Users) { it.id eq id } == 1 diff --git a/persistance/src/main/kotlin/users/Users.kt b/persistance/src/main/kotlin/users/Users.kt index de9d8ba..2ebb042 100644 --- a/persistance/src/main/kotlin/users/Users.kt +++ b/persistance/src/main/kotlin/users/Users.kt @@ -1,9 +1,11 @@ package be.simplenotes.persistance.users -import be.simplenotes.domain.model.PersistedUser -import me.liuwj.ktorm.database.* -import me.liuwj.ktorm.entity.* -import me.liuwj.ktorm.schema.* +import me.liuwj.ktorm.database.Database +import me.liuwj.ktorm.entity.Entity +import me.liuwj.ktorm.entity.sequenceOf +import me.liuwj.ktorm.schema.Table +import me.liuwj.ktorm.schema.int +import me.liuwj.ktorm.schema.varchar internal open class Users(alias: String?) : Table("Users", alias) { companion object : Users(null) @@ -18,11 +20,9 @@ internal open class Users(alias: String?) : Table("Users", alias) { internal interface UserEntity : Entity { companion object : Entity.Factory() - val id: Int + var id: Int var username: String var password: String } -internal fun UserEntity.toPersistedUser() = PersistedUser(username, password, id) - internal val Database.users get() = this.sequenceOf(Users, withReferences = false) diff --git a/persistance/src/test/kotlin/converters/NoteConverterTest.kt b/persistance/src/test/kotlin/converters/NoteConverterTest.kt new file mode 100644 index 0000000..2e2db90 --- /dev/null +++ b/persistance/src/test/kotlin/converters/NoteConverterTest.kt @@ -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) + } + + } + +} diff --git a/persistance/src/test/kotlin/converters/UserConverterTest.kt b/persistance/src/test/kotlin/converters/UserConverterTest.kt new file mode 100644 index 0000000..c8fd91f --- /dev/null +++ b/persistance/src/test/kotlin/converters/UserConverterTest.kt @@ -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") + } +} diff --git a/persistance/src/test/kotlin/notes/NoteRepositoryImplTest.kt b/persistance/src/test/kotlin/notes/NoteRepositoryImplTest.kt index fcd06a2..577ccb9 100644 --- a/persistance/src/test/kotlin/notes/NoteRepositoryImplTest.kt +++ b/persistance/src/test/kotlin/notes/NoteRepositoryImplTest.kt @@ -4,12 +4,16 @@ 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.* -import me.liuwj.ktorm.dsl.* -import me.liuwj.ktorm.entity.* +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 @@ -17,6 +21,7 @@ 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 @@ -186,10 +191,12 @@ internal class NoteRepositoryImplTest { 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 - entity.toPersistedNote(tags) + converter.toPersistedNote(entity, tags) } assertThat(noteRepo.find(user1.id, note.uuid)) diff --git a/pom.xml b/pom.xml index 9e66c3b..f2e9b0d 100644 --- a/pom.xml +++ b/pom.xml @@ -29,6 +29,8 @@ ${java.version} ${java.version} ${java.version} + + 1.4.1.Final @@ -99,6 +101,21 @@ org.jetbrains.kotlin ${kotlin.version} + + kapt + + kapt + + + + + org.mapstruct + mapstruct-processor + ${org.mapstruct.version} + + + + compile process-sources @@ -181,6 +198,12 @@ 3.0.0 + + org.mapstruct + mapstruct + ${org.mapstruct.version} + + org.junit.jupiter