Remove Boilerplate Use-case thingy

domain/test/Index.kt

@@ -1 +0,0 @@
-package be.simplenotes.domain

domain/test/UserServiceTest.kt

@@ -0,0 +1,101 @@
+@file:Suppress("MemberVisibilityCanBePrivate")
+
+package be.simplenotes.domain
+
+import be.simplenotes.config.JwtConfig
+import be.simplenotes.domain.security.BcryptPasswordHash
+import be.simplenotes.domain.security.SimpleJwt
+import be.simplenotes.domain.security.UserJwtMapper
+import be.simplenotes.domain.testutils.isLeftOfType
+import be.simplenotes.domain.testutils.isRight
+import be.simplenotes.persistence.repositories.UserRepository
+import be.simplenotes.persistence.transactions.TransactionService
+import be.simplenotes.types.PersistedUser
+import com.natpryce.hamkrest.assertion.assertThat
+import com.natpryce.hamkrest.equalTo
+import io.mockk.*
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import java.util.concurrent.TimeUnit
+
+internal class UserServiceTest {
+    val userRepository = mockk<UserRepository>()
+    val passwordHash = BcryptPasswordHash(test = true)
+    val jwtConfig = JwtConfig("a secret", 1, TimeUnit.HOURS)
+    val simpleJwt = SimpleJwt(jwtConfig, UserJwtMapper())
+    val noopTransactionService = object : TransactionService {
+        override fun <T> use(block: () -> T) = block()
+    }
+
+    val userService = UserServiceImpl(
+        userRepository = userRepository,
+        passwordHash = passwordHash,
+        jwt = simpleJwt,
+        searcher = mockk(),
+        transactionService = noopTransactionService
+    )
+
+    @BeforeEach
+    fun resetMocks() {
+        clearMocks(userRepository)
+    }
+
+    @Test
+    fun `register should fail with invalid form`() {
+        val form = RegisterForm("", "a".repeat(10))
+        assertThat(userService.register(form), isLeftOfType<RegisterError.InvalidRegisterForm>())
+        verify { userRepository wasNot called }
+    }
+
+    @Test
+    fun `Register should fail with existing username`() {
+        val form = RegisterForm("someuser", "somepassword")
+        every { userRepository.exists(form.username!!) } returns true
+        assertThat(userService.register(form), isLeftOfType<RegisterError.UserExists>())
+    }
+
+    @Test
+    fun `Register should succeed with new user`() {
+        val form = RegisterForm("someuser", "somepassword")
+        every { userRepository.exists(form.username!!) } returns false
+        every { userRepository.create(any()) } returns PersistedUser(form.username!!, form.password!!, 1)
+        val res = userService.register(form)
+        assertThat(res, isRight())
+        res.map { assertThat(it.username, equalTo(form.username)) }
+    }
+
+    @Test
+    fun `Login should fail with invalid form`() {
+        val form = LoginForm("", "a")
+        assertThat(userService.login(form), isLeftOfType<LoginError.InvalidLoginForm>())
+        verify { userRepository wasNot called }
+    }
+
+    @Test
+    fun `Login should fail with non existing user`() {
+        val form = LoginForm("someusername", "somepassword")
+        every { userRepository.find(form.username!!) } returns null
+        assertThat(userService.login(form), isLeftOfType<LoginError.Unregistered>())
+    }
+
+    @Test
+    fun `Login should fail with wrong password`() {
+        val form = LoginForm("someusername", "wrongpassword")
+
+        every { userRepository.find(form.username!!) } returns
+            PersistedUser(form.username!!, passwordHash.crypt("right password"), 1)
+
+        assertThat(userService.login(form), isLeftOfType<LoginError.WrongPassword>())
+    }
+
+    @Test
+    fun `Login should succeed with existing user and correct password`() {
+        val loginForm = LoginForm("someusername", "somepassword")
+
+        every { userRepository.find(loginForm.username!!) } returns
+            PersistedUser(loginForm.username!!, passwordHash.crypt(loginForm.password!!), 1)
+
+        val res = userService.login(loginForm)
+        assertThat(res, isRight())
+    }
+}

domain/test/security/LoggedInUserExtractorTest.kt

@@ -1,7 +1,7 @@
 package be.simplenotes.domain.security
 
 import be.simplenotes.config.JwtConfig
-import be.simplenotes.domain.usecases.users.login.Token
+import be.simplenotes.domain.Token
 import be.simplenotes.types.LoggedInUser
 import com.auth0.jwt.JWT
 import com.auth0.jwt.algorithms.Algorithm

domain/test/usecases/users/login/LoginUseCaseImplTest.kt

@@ -1,65 +0,0 @@
-package be.simplenotes.domain.usecases.users.login
-
-import be.simplenotes.config.JwtConfig
-import be.simplenotes.domain.security.BcryptPasswordHash
-import be.simplenotes.domain.security.SimpleJwt
-import be.simplenotes.domain.security.UserJwtMapper
-import be.simplenotes.domain.testutils.isLeftOfType
-import be.simplenotes.domain.testutils.isRight
-import be.simplenotes.persistence.repositories.UserRepository
-import be.simplenotes.types.PersistedUser
-import com.natpryce.hamkrest.assertion.assertThat
-import io.mockk.*
-import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.Test
-import java.util.concurrent.TimeUnit
-
-internal class LoginUseCaseImplTest {
-    // region setup
-    private val mockUserRepository = mockk<UserRepository>()
-    private val passwordHash = BcryptPasswordHash(test = true)
-    private val jwtConfig = JwtConfig("a secret", 1, TimeUnit.HOURS)
-    private val simpleJwt = SimpleJwt(jwtConfig, UserJwtMapper())
-    private val loginUseCase = LoginUseCaseImpl(mockUserRepository, passwordHash, simpleJwt)
-
-    @BeforeEach
-    fun resetMocks() {
-        clearMocks(mockUserRepository)
-    }
-    // endregion
-
-    @Test
-    fun `Login should fail with invalid form`() {
-        val form = LoginForm("", "a")
-        assertThat(loginUseCase.login(form), isLeftOfType<InvalidLoginForm>())
-        verify { mockUserRepository wasNot called }
-    }
-
-    @Test
-    fun `Login should fail with non existing user`() {
-        val form = LoginForm("someusername", "somepassword")
-        every { mockUserRepository.find(form.username!!) } returns null
-        assertThat(loginUseCase.login(form), isLeftOfType<Unregistered>())
-    }
-
-    @Test
-    fun `Login should fail with wrong password`() {
-        val form = LoginForm("someusername", "wrongpassword")
-
-        every { mockUserRepository.find(form.username!!) } returns
-            PersistedUser(form.username!!, passwordHash.crypt("right password"), 1)
-
-        assertThat(loginUseCase.login(form), isLeftOfType<WrongPassword>())
-    }
-
-    @Test
-    fun `Login should succeed with existing user and correct password`() {
-        val loginForm = LoginForm("someusername", "somepassword")
-
-        every { mockUserRepository.find(loginForm.username!!) } returns
-            PersistedUser(loginForm.username!!, passwordHash.crypt(loginForm.password!!), 1)
-
-        val res = loginUseCase.login(loginForm)
-        assertThat(res, isRight())
-    }
-}

domain/test/usecases/users/register/RegisterUseCaseImplTest.kt

@@ -1,54 +0,0 @@
-package be.simplenotes.domain.usecases.users.register
-
-import be.simplenotes.domain.security.BcryptPasswordHash
-import be.simplenotes.domain.testutils.isLeftOfType
-import be.simplenotes.domain.testutils.isRight
-import be.simplenotes.persistence.repositories.UserRepository
-import be.simplenotes.persistence.transactions.TransactionService
-import be.simplenotes.types.PersistedUser
-import com.natpryce.hamkrest.assertion.assertThat
-import com.natpryce.hamkrest.equalTo
-import io.mockk.*
-import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.Test
-
-internal class RegisterUseCaseImplTest {
-
-    // region setup
-    private val mockUserRepository = mockk<UserRepository>()
-    private val passwordHash = BcryptPasswordHash(test = true)
-    private val noopTransactionService = object : TransactionService {
-        override fun <T> use(block: () -> T) = block()
-    }
-    private val registerUseCase = RegisterUseCaseImpl(mockUserRepository, passwordHash, noopTransactionService)
-
-    @BeforeEach
-    fun resetMocks() {
-        clearMocks(mockUserRepository)
-    }
-    // endregion
-
-    @Test
-    fun `register should fail with invalid form`() {
-        val form = RegisterForm("", "a".repeat(10))
-        assertThat(registerUseCase.register(form), isLeftOfType<InvalidRegisterForm>())
-        verify { mockUserRepository wasNot called }
-    }
-
-    @Test
-    fun `Register should fail with existing username`() {
-        val form = RegisterForm("someuser", "somepassword")
-        every { mockUserRepository.exists(form.username!!) } returns true
-        assertThat(registerUseCase.register(form), isLeftOfType<UserExists>())
-    }
-
-    @Test
-    fun `Register should succeed with new user`() {
-        val form = RegisterForm("someuser", "somepassword")
-        every { mockUserRepository.exists(form.username!!) } returns false
-        every { mockUserRepository.create(any()) } returns PersistedUser(form.username!!, form.password!!, 1)
-        val res = registerUseCase.register(form)
-        assertThat(res, isRight())
-        res.map { assertThat(it.username, equalTo(form.username)) }
-    }
-}

domain/test/utils/SearchTermsParserKtTest.kt

@@ -1,4 +1,4 @@
-package be.simplenotes.domain.usecases.search
+package be.simplenotes.domain.utils
 
 import be.simplenotes.search.SearchTerms
 import com.natpryce.hamkrest.assertion.assertThat

domain/test/validation/UserValidationsTest.kt

@@ -1,10 +1,10 @@
 package be.simplenotes.domain.validation
 
+import be.simplenotes.domain.LoginError
+import be.simplenotes.domain.LoginForm
+import be.simplenotes.domain.RegisterForm
 import be.simplenotes.domain.testutils.isLeftOfType
 import be.simplenotes.domain.testutils.isRight
-import be.simplenotes.domain.usecases.users.login.InvalidLoginForm
-import be.simplenotes.domain.usecases.users.login.LoginForm
-import be.simplenotes.domain.usecases.users.register.RegisterForm
 import com.natpryce.hamkrest.assertion.assertThat
 import org.junit.jupiter.api.Nested
 import org.junit.jupiter.params.ParameterizedTest
@@ -28,7 +28,7 @@ internal class UserValidationsTest {
         @ParameterizedTest
         @MethodSource("invalidLoginForms")
         fun `validate invalid logins`(form: LoginForm) {
-            assertThat(UserValidations.validateLogin(form), isLeftOfType<InvalidLoginForm>())
+            assertThat(UserValidations.validateLogin(form), isLeftOfType<LoginError.InvalidLoginForm>())
         }
 
         @Suppress("Unused")
@@ -59,7 +59,7 @@ internal class UserValidationsTest {
         @ParameterizedTest
         @MethodSource("invalidRegisterForms")
         fun `validate invalid register`(form: LoginForm) {
-            assertThat(UserValidations.validateLogin(form), isLeftOfType<InvalidLoginForm>())
+            assertThat(UserValidations.validateLogin(form), isLeftOfType<LoginError.InvalidLoginForm>())
         }
 
         @Suppress("Unused")