SimpleNotes/persistance/test/converters/NoteConverterTest.kt

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