Clean up routing configuration

backend/app/src/main/kotlin/backend/App.kt

@@ -1,25 +1,17 @@
 package backend
 
 import backend.config.configureAuth
-import backend.route.adminRoutes
-import backend.route.userRoutes
-import backend.repository.AdminRepository
-import backend.repository.UserRepository
-import backend.repository.WorkshopRepository
-import backend.route.workshopRoute
+import backend.config.configureRouting
+import backend.config.configureSerialization
 import com.inventy.plugins.DatabaseFactory
-import io.ktor.serialization.kotlinx.json.*
 import io.ktor.server.application.*
-import io.ktor.server.auth.*
-import io.ktor.server.plugins.contentnegotiation.*
-import io.ktor.server.response.*
-import io.ktor.server.routing.*
 
 
 fun main(args: Array<String>): Unit =
     io.ktor.server.netty.EngineMain.main(args)
 
 fun Application.module() {
+    configureSerialization()
     DatabaseFactory(
         dbHost = environment.config.property("database.host").getString(),
         dbPort = environment.config.property("database.port").getString(),
@@ -33,39 +25,4 @@ fun Application.module() {
 }
 
 
-fun Application.configureRouting() {
-    val userRepository = UserRepository()
-    val adminRepository = AdminRepository()
-    val workshopRepository = WorkshopRepository()
-
-    install(ContentNegotiation) {
-        json()
-    }
-    routing {
-        userRoutes(userRepository)
-        adminRoutes()
-        workshopRoute(workshopRepository)
-        healthz()
-
-        authenticate ("auth0-user") {
-            get("/auth") {
-                call.respondText("Hello, world!")
-            }
-        }
-
-        get {
-            call.respondText("Hello, world!")
-        }
-    }
-}
-
-private fun Routing.healthz() {
-    get("readiness") {
-        call.respondText("READY!")
-    }
-
-    get("liveness") {
-        call.respondText("ALIVE!")
-    }
-}
 

backend/app/src/main/kotlin/backend/config/DatabaseFactory.kt

@@ -32,7 +32,8 @@ class DatabaseFactory(
     }
 
     private fun hikari(): HikariDataSource {
-        if (embedded) {
+        val isRunningInTest = System.getProperty("RUNNING_IN_TEST") != null
+        if (isRunningInTest || embedded) {
             return HikariDataSource().apply {
                 dataSourceClassName = JdbcDataSource::class.qualifiedName
                 addDataSourceProperty("url", "jdbc:h2:mem:workshop;DB_CLOSE_DELAY=-1")

backend/app/src/main/kotlin/backend/config/Routing.kt

@@ -0,0 +1,34 @@
+package backend.config
+
+import backend.repository.AdminRepository
+import backend.repository.UserRepository
+import backend.repository.WorkshopRepository
+import backend.route.*
+import io.ktor.server.application.*
+import io.ktor.server.auth.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+
+fun Application.configureRouting() {
+    val userRepository = UserRepository()
+    val adminRepository = AdminRepository()
+    val workshopRepository = WorkshopRepository()
+
+    configureAuth0Route(userRepository)
+    configureUserRoutes(userRepository)
+    configureWorkshopRoutes(workshopRepository)
+    configureAdminRoutes(adminRepository)
+    configureApiRoutes()
+
+    routing {
+        authenticate ("auth0-user") {
+            get("/auth") {
+                call.respondText("Hello World!")
+            }
+        }
+
+        get {
+            call.respondText("Hello World!")
+        }
+    }
+}

backend/app/src/main/kotlin/backend/config/Serialization.kt

@@ -0,0 +1,27 @@
+package backend.config
+
+import io.ktor.http.*
+import io.ktor.serialization.kotlinx.json.*
+import io.ktor.server.application.*
+import io.ktor.server.plugins.contentnegotiation.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+
+fun Application.configureSerialization() {
+    install(ContentNegotiation) {
+        json(
+            contentType = ContentType.Application.Json,
+            json = kotlinx.serialization.json.Json {
+                prettyPrint = true
+                isLenient = true
+                ignoreUnknownKeys = true
+                coerceInputValues = true
+            }
+        )
+    }
+    routing {
+        get("/json/kotlinx-serialization") {
+                call.respond(mapOf("hello" to "world"))
+            }
+    }
+}

backend/app/src/main/kotlin/backend/route/AdminRoute.kt

@@ -1,6 +1,15 @@
 package backend.route
 
+import backend.repository.AdminRepository
+import io.ktor.server.application.*
 import io.ktor.server.routing.*
 
-fun Routing.adminRoutes() {
+
+fun Application.configureAdminRoutes(adminRepository: AdminRepository) {
+    routing {
+        adminRoutes(adminRepository)
+    }
+}
+
+fun Routing.adminRoutes(adminRepository: AdminRepository) {
 }

backend/app/src/main/kotlin/backend/route/ApiRoutes.kt

@@ -0,0 +1,21 @@
+package backend.route
+
+import io.ktor.server.application.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+
+fun Application.configureApiRoutes() {
+    routing {
+        healthz()
+    }
+}
+
+fun Routing.healthz() {
+    get("readiness") {
+        call.respondText("READY!")
+    }
+
+    get("liveness") {
+        call.respondText("ALIVE!")
+    }
+}

backend/app/src/main/kotlin/backend/route/Auth0Route.kt

@@ -0,0 +1,34 @@
+package backend.route
+
+import backend.dto.UserDTO
+import backend.repository.UserRepository
+import io.ktor.http.*
+import io.ktor.server.application.*
+import io.ktor.server.auth.*
+import io.ktor.server.request.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+
+fun Application.configureAuth0Route(userRepository: UserRepository) {
+    routing {
+        auth0Route(userRepository)
+    }
+}
+
+fun Route.auth0Route(userRepository: UserRepository) {
+    authenticate ("basic-auth0") {
+        post("/auth0") {
+            val userDTO = call.receive<UserDTO>()
+            val user = userRepository.readByEmail(userDTO.email)
+            if (user?.id != null) {
+                userRepository.updateProviders(user.id, user.providers, userDTO.providers)
+                call.respond(HttpStatusCode.OK)
+                return@post
+            } else {
+                val create = userRepository.create(userDTO)
+                call.respond(HttpStatusCode.Created, create)
+                return@post
+            }
+        }
+    }
+}

backend/app/src/main/kotlin/backend/route/UserRoute.kt

@@ -39,19 +39,4 @@ fun Routing.userRoutes(userRepository: UserRepository) {
         userRepository.cancelWorkshopRegistration(userId, call.parameters["workshopId"]!!.toInt())
         call.respondText("Workshop cancelled")
     }
-    authenticate ("basic-auth0") {
-        post("/user") {
-            val userDTO = call.receive<UserDTO>()
-            val user = userRepository.readByEmail(userDTO.email)
-            if (user?.id != null) {
-                userRepository.updateProviders(user.id, user.providers, userDTO.providers)
-                call.respond(HttpStatusCode.OK)
-                return@post
-            } else {
-                val create = userRepository.create(userDTO)
-                call.respond(HttpStatusCode.Created, create)
-                return@post
-            }
-        }
-    }
 }

backend/app/src/main/kotlin/backend/route/WorkshopRoute.kt

@@ -8,9 +8,9 @@ import io.ktor.server.auth.*
 import io.ktor.server.response.*
 import io.ktor.server.routing.*
 
-fun Application.configureWorkshopRoutes(userRepository: UserRepository) {
+fun Application.configureWorkshopRoutes(workshopRepository: WorkshopRepository) {
     routing {
-        userRoutes(userRepository)
+        workshopRoute(workshopRepository)
     }
 }
 

backend/app/src/main/resources/application.yaml

@@ -18,4 +18,4 @@ database:
 auth0:
   issuer: 'https://damoad.eu.auth0.com/'
   # The audience is the identifier of the API that you want to call (client-id of the application in Auth0)
-  audience: OEymhO5ditl1CiiMStu18WgoquU93JJF
+  audience: workshop-wizard-backend

backend/app/src/main/resources/logback.xml

@@ -9,4 +9,5 @@
     </root>
     <logger name="org.eclipse.jetty" level="INFO"/>
     <logger name="io.netty" level="INFO"/>
+    <logger name="com.zaxxer" level="INFO"/>
 </configuration>

backend/app/src/test/kotlin/backend/ApplicationTest.kt

@@ -0,0 +1,22 @@
+package backend
+
+import backend.config.configureRouting
+import io.ktor.client.request.*
+import io.ktor.client.statement.*
+import io.ktor.http.*
+import io.ktor.server.testing.*
+import kotlin.test.*
+
+class ApplicationTest {
+    @Test
+    fun testRoot() = testApplication {
+        System.setProperty("RUNNING_IN_TEST", "true")
+        application {
+            configureRouting()
+        }
+        client.get("/").apply {
+            assertEquals(HttpStatusCode.OK, status)
+            assertEquals("Hello World!", bodyAsText())
+        }
+    }
+}