Flatten packages

Remove modules prefix

persistance/test/users/BaseUserRepositoryImplTest.kt

@@ -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
+        }
+    }
+}

persistance/test/users/UserRepositoryImplTests.kt

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