More tests !

api/test/routing/UserControllerKtTest.kt

@@ -0,0 +1,142 @@
+package routing
+
+import be.vandewalleh.auth.SimpleJWT
+import be.vandewalleh.entities.User
+import be.vandewalleh.mainModule
+import be.vandewalleh.module
+import be.vandewalleh.services.UserService
+import io.ktor.http.*
+import io.ktor.server.testing.*
+import io.mockk.every
+import io.mockk.mockk
+import org.amshove.kluent.*
+import org.junit.jupiter.api.*
+import org.kodein.di.Kodein
+import org.kodein.di.generic.bind
+import org.kodein.di.generic.instance
+import utils.*
+import java.time.LocalDateTime
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class UserControllerKtTest {
+
+    private val userService = mockk<UserService>()
+
+    init {
+        // new user
+        every { userService.userExists("new", "new@test.com") } returns false
+        every { userService.createUser("new", "new@test.com", any()) } returns User {
+            this.createdAt = LocalDateTime.now()
+            this.username = "new"
+            this.email = "new@test.com"
+        }
+
+        // existing user
+        every { userService.userExists("existing", "existing@test.com") } returns true
+        every { userService.createUser("existing", "existing@test.com", any()) } returns null
+        every { userService.getUserId("existing@test.com") } returns 1
+        every { userService.deleteUser(1) } returns true andThen false
+
+        // modified user
+        every { userService.userExists("modified", "modified@test.com") } returns true
+        every {
+            userService.userExists(
+                and(not("modified"), not("existing")),
+                and(not("modified@test.com"), not("existing@test.com"))
+            )
+        } returns false
+        every { userService.userExists(1) } returns true
+        every { userService.createUser("modified", "modified@test.com", any()) } returns null
+        every { userService.getUserId("modified@test.com") } returns 1
+        every { userService.updateUser(1, "ThisIsMyNewName", "ThisIsMyNewName@mail.com", any()) } returns Unit
+
+    }
+
+
+    private val kodein = Kodein {
+        import(mainModule, allowOverride = true)
+        bind<UserService>(overrides = true) with instance(userService)
+    }
+
+    private val testEngine = TestApplicationEngine().apply {
+        start()
+        application.module(kodein)
+    }
+
+    @Nested
+    inner class CreateUser {
+        @Test
+        fun `create a new user`() {
+            val res = testEngine.post("/user") {
+                json {
+                    it["username"] = "new"
+                    it["password"] = "test"
+                    it["email"] = "new@test.com"
+                }
+            }
+            res.status() `should be equal to` HttpStatusCode.Created
+            res.content `should be equal to json` """{msg:"Created"}"""
+        }
+
+        @Test
+        fun `create an existing user`() {
+            val res = testEngine.post("/user") {
+                json {
+                    it["username"] = "existing"
+                    it["email"] = "existing@test.com"
+                    it["password"] = "test"
+                }
+            }
+            res.status() `should be equal to` HttpStatusCode.Conflict
+            res.content `should be equal to json` """{msg:"Conflict"}"""
+        }
+    }
+
+
+    @Nested
+    inner class DeleteUser {
+
+        @Test
+        fun `delete an existing user`() {
+            val authJwt by kodein.instance<SimpleJWT>("auth")
+            val token = authJwt.sign(1)
+
+            val res = testEngine.delete("/user") {
+                addHeader(HttpHeaders.Authorization, "Bearer $token")
+            }
+            res.status() `should be equal to` HttpStatusCode.OK
+            res.content `should be equal to json` """{msg:"OK"}"""
+
+            // try again
+            val res2 = testEngine.delete("/user") {
+                setToken(token)
+            }
+            res2.status() `should be equal to` HttpStatusCode.NotFound
+            res2.content `should be equal to json` """{msg:"Not Found"}"""
+        }
+    }
+
+    @Nested
+    inner class ModifyUser {
+
+        @Test
+        fun `modify a user`() {
+            val authJwt by kodein.instance<SimpleJWT>("auth")
+            val token = authJwt.sign(1)
+
+            val res = testEngine.put("/user") {
+                setToken(token)
+                json {
+                    it["username"] = "ThisIsMyNewName"
+                    it["email"] = "ThisIsMyNewName@mail.com"
+                }
+            }
+
+            res.status() `should be equal to` HttpStatusCode.OK
+            res.content `should be equal to json` """{msg:"OK"}"""
+
+        }
+    }
+
+
+}

api/test/utils/Assertions.kt

@@ -0,0 +1,19 @@
+package utils
+
+import org.skyscreamer.jsonassert.JSONAssert
+
+infix fun String?.shouldBeEqualToJson(expected: String?) = JSONAssert.assertEquals(expected, this, false)
+
+infix fun String?.`should be equal to json`(expected: String?) = shouldBeEqualToJson(expected)
+
+infix fun String?.shouldStrictlyBeEqualToJson(expected: String?) = JSONAssert.assertEquals(expected, this, true)
+
+infix fun String?.`should strictly be equal to json`(expected: String?) = shouldStrictlyBeEqualToJson(expected)
+
+infix fun String?.shouldNotStrictlyBeEqualToJson(expected: String?) = JSONAssert.assertNotEquals(expected, this, true)
+
+infix fun String?.`should not strictly be equal to json`(expected: String?) = shouldNotStrictlyBeEqualToJson(expected)
+
+infix fun String?.shouldNotBeEqualToJson(expected: String?) = JSONAssert.assertNotEquals(expected, this, false)
+
+infix fun String?.`should not be equal to json`(expected: String?) = shouldNotBeEqualToJson(expected)

api/test/utils/JsonAssertExtensions.kt

@@ -0,0 +1,23 @@
+package utils
+
+import org.json.JSONObject
+
+operator fun JSONObject.set(name: String, value: String) {
+    this.put(name, value)
+}
+
+operator fun JSONObject.set(name: String, value: Double) {
+    this.put(name, value)
+}
+
+operator fun JSONObject.set(name: String, value: Long) {
+    this.put(name, value)
+}
+
+operator fun JSONObject.set(name: String, value: Int) {
+    this.put(name, value)
+}
+
+operator fun JSONObject.set(name: String, value: Boolean) {
+    this.put(name, value)
+}

api/test/utils/KtorTestingExtensions.kt

@@ -0,0 +1,52 @@
+package utils
+
+import io.ktor.http.HttpHeaders
+import io.ktor.http.HttpMethod
+import io.ktor.server.testing.*
+import org.json.JSONObject
+
+
+fun TestApplicationRequest.json(block: (JSONObject) -> Unit) {
+    addHeader(HttpHeaders.ContentType, "application/json")
+    setBody(JSONObject().apply(block).toString())
+}
+
+fun TestApplicationRequest.setToken(token: String) {
+    addHeader(HttpHeaders.Authorization, "Bearer $token")
+}
+
+fun TestApplicationEngine.post(
+    uri: String,
+    setup: TestApplicationRequest.() -> Unit = {}
+): TestApplicationResponse = handleRequest {
+    this.uri = uri
+    this.method = HttpMethod.Post
+    setup()
+}.response
+
+fun TestApplicationEngine.get(
+    uri: String,
+    setup: TestApplicationRequest.() -> Unit = {}
+): TestApplicationResponse = handleRequest {
+    this.uri = uri
+    this.method = HttpMethod.Get
+    setup()
+}.response
+
+fun TestApplicationEngine.delete(
+    uri: String,
+    setup: TestApplicationRequest.() -> Unit = {}
+): TestApplicationResponse = handleRequest {
+    this.uri = uri
+    this.method = HttpMethod.Delete
+    setup()
+}.response
+
+fun TestApplicationEngine.put(
+    uri: String,
+    setup: TestApplicationRequest.() -> Unit = {}
+): TestApplicationResponse = handleRequest {
+    this.uri = uri
+    this.method = HttpMethod.Put
+    setup()
+}.response