Merge pull request #100 from halotukozak/polishing

Polishing

Author: halotukozak

backend/Dockerfile

@@ -2,7 +2,7 @@
 FROM gradle:8.3.0-jdk17 AS build
 WORKDIR /backend
 COPY . .
-RUN gradle build --no-daemon
+RUN gradle assemble --no-daemon
 
 # Run stage
 FROM openjdk:17-slim

backend/build.gradle.kts

@@ -4,6 +4,8 @@ val exposed_version: String by project
 val h2_version: String by project
 val kotlin_version: String by project
 val logback_version: String by project
+val testcontainers_version: String by project
+
 
 plugins {
   kotlin("jvm") version "2.1.20"
@@ -66,4 +68,7 @@ dependencies {
   implementation("io.github.serpro69:kotlin-faker:1.14.0")
   testImplementation("io.ktor:ktor-server-test-host")
   testImplementation("org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version")
+  testImplementation("org.testcontainers:testcontainers:$testcontainers_version")
+  testImplementation("org.testcontainers:postgresql:$testcontainers_version")
+  testImplementation("org.testcontainers:junit-jupiter:$testcontainers_version")
 }

backend/gradle.properties

@@ -4,3 +4,4 @@ h2_version=2.3.232
 kotlin_version=2.1.20
 ktor_version=3.1.2
 logback_version=1.4.14
+testcontainers_version=1.20.6

backend/src/main/kotlin/edu/agh/roomie/Databases.kt

@@ -13,10 +13,10 @@ import kotlin.random.Random
 
 fun Application.configureDatabases(): Database {
   val database = if (isDeployment) Database.connect(
-    url = "jdbc:postgresql://dpg-cvtqhis9c44c738puva0-a.oregon-postgres.render.com/roomie_hkrz",
+    url = System.getenv("DATABASE_URL"),
     driver = "org.postgresql.Driver",
-    user = "roomie",
-    password = "A9hloke0pADrSXz8TzIGEUTYfiJzQM72"
+    user = System.getenv("DB_USER"),
+    password = System.getenv("DB_PASSWORD")
   ) else Database.connect(
     url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1",
     user = "root",

backend/src/main/kotlin/edu/agh/roomie/service/MatchService.kt

@@ -16,17 +16,17 @@ class MatchService(database: Database) {
 
   class InvitationEntity(id: EntityID<Int>) : IntEntity(id) {
     companion object : IntEntityClass<InvitationEntity>(InvitationTable) {
-      fun findMatchesForUser(userId: Int) = find {
+      fun findMatchesForUser(userId: Int): List<EntityID<Int>> = find {
         (InvitationTable.userId eq userId) and (InvitationTable.requestStatus eq MatchStatus.ACK) and (InvitationTable.responseStatus eq MatchStatus.ACK)
-      }.toList().map { it.matchedUserId }
+      }.map { it.matchedUserId }
 
-      fun findRequestReceivedForUser(userId: Int) = find {
+      fun findRequestReceivedForUser(userId: Int): List<EntityID<Int>> = find {
         (InvitationTable.matchedUserId eq userId) and (InvitationTable.responseStatus eq MatchStatus.NONE) and (InvitationTable.requestStatus eq MatchStatus.ACK)
-      }.toList().map { it.userId }
+      }.map { it.userId }
 
-      fun findResponseSentForUser(userId: Int) = find {
-        (InvitationTable.userId eq userId) and (InvitationTable.requestStatus neq MatchStatus.NACK)
-      }.toList()
+      fun findPendingSentRequestsForUser(userId: Int): List<EntityID<Int>> = find {
+        (InvitationTable.userId eq userId) and (InvitationTable.requestStatus eq MatchStatus.ACK) and (InvitationTable.responseStatus eq MatchStatus.NONE)
+      }.map { it.matchedUserId }
     }
 
     var userId by InvitationTable.userId
@@ -51,49 +51,46 @@ class MatchService(database: Database) {
   }
 
   fun getResultsForUser(userId: Int): MatchResultResponse = transaction {
-    val user = UserService.UserEntity.findById(userId)!!.toShared()
+    val user = UserService.UserEntity.findById(userId)?.toShared() ?: throw IllegalArgumentException("User not found")
 
     val matches = InvitationEntity.findMatchesForUser(userId)
-    val sentRequests =
-      InvitationEntity.findResponseSentForUser(userId)
-        .filter { it.requestStatus == MatchStatus.ACK && it.responseStatus == MatchStatus.NONE }
-        .map { it.matchedUserId }
+    val sentRequests = InvitationEntity.findPendingSentRequestsForUser(userId)
     val receivedRequests = InvitationEntity.findRequestReceivedForUser(userId)
-    val allUsers = UserService.UserEntity.findByIds(
-      matches + sentRequests + receivedRequests
-    )
+
+    val allUserIds = (matches + sentRequests + receivedRequests).distinct()
+    val allUsers = UserService.UserEntity.findByIds(allUserIds).associateBy { it.id }
 
     MatchResultResponse(
-      allUsers.filter { it.id in matches }.map { Match(it.toShared(), countScore(it.toShared(), user)) },
-      allUsers.filter { it.id in sentRequests }.map { Match(it.toShared(), countScore(it.toShared(), user)) },
-      allUsers.filter { it.id in receivedRequests }.map { Match(it.toShared(), countScore(it.toShared(), user)) })
+      matches = matches.mapNotNull { allUsers[it] }
+        .map { Match(it.toShared(), countScore(it.toShared(), user)) },
+      sentRequests = sentRequests.mapNotNull { allUsers[it] }
+        .map { Match(it.toShared(), countScore(it.toShared(), user)) },
+      receivedRequests = receivedRequests.mapNotNull { allUsers[it] }
+        .map { Match(it.toShared(), countScore(it.toShared(), user)) })
   }
 
   fun getAvailableMatchesForUser(userId: Int): List<User> = transaction {
-    val requestsSent =
-      InvitationEntity.find {
-        (InvitationTable.userId eq userId) and (InvitationTable.requestStatus neq MatchStatus.NONE)
-      }.toList().map { it.matchedUserId }
-
-    val result = 
+    val requestsSent = InvitationEntity.find {
+      (InvitationTable.userId eq userId) and (InvitationTable.requestStatus neq MatchStatus.NONE)
+    }.map { it.matchedUserId }
+
+    // Find users who:
+    // 1. Are not the current user
+    // 2. Haven't been swiped on by the current user
+    // 3. Have completed their profile (have info and preferences)
     UserService.UserEntity.find {
       (UsersTable.id neq userId) and (UsersTable.id notInList requestsSent) and (UsersTable.info neq null) and (UsersTable.preferences neq null)
     }.map { it.toShared() }
-    result
   }
 
   fun getRequestReceivedForUser(userId: Int): List<User> = transaction {
-    val requests = InvitationEntity.findRequestReceivedForUser(userId)
-    UserService.UserEntity.findByIds(requests).map { it.toShared() }
+    val requestUserIds = InvitationEntity.findRequestReceivedForUser(userId)
+    UserService.UserEntity.findByIds(requestUserIds).map { it.toShared() }
   }
 
   fun registerSwipe(thisUserId: Int, swipedUserId: Int, status: MatchStatus): MatchStatus = transaction {
-    val thisUser = UserService.UserEntity.findById(thisUserId)
-    val swipedUser = UserService.UserEntity.findById(swipedUserId)
-
-    if (thisUser == null || swipedUser == null) {
-      throw IllegalArgumentException("User not found")
-    }
+    val thisUser = UserService.UserEntity.findById(thisUserId) ?: throw IllegalArgumentException("User not found")
+    val swipedUser = UserService.UserEntity.findById(swipedUserId) ?: throw IllegalArgumentException("User not found")
 
     val invitation = InvitationEntity.find {
       (InvitationTable.userId eq thisUser.id) and (InvitationTable.matchedUserId eq swipedUser.id)

backend/src/main/kotlin/edu/agh/roomie/service/UserService.kt

@@ -19,9 +19,7 @@ class UserService(database: Database) {
     return hash.joinToString("") { "%02x".format(it) }
   }
 
-  private fun verifyPassword(password: String, hashedPassword: String): Boolean {
-    return hashPassword(password) == hashedPassword
-  }
+  private fun verifyPassword(password: String, hashedPassword: String): Boolean = hashPassword(password) == hashedPassword
 
   class UserEntity(id: EntityID<Int>) : IntEntity(id) {
     companion object : IntEntityClass<UserEntity>(UsersTable) {
@@ -62,7 +60,6 @@ class UserService(database: Database) {
     if (user != null && verifyPassword(password, user.password)) {
       user.id.value
     } else {
-      println("Authentication failed for user: $email")
       null
     }
   }

backend/src/test/kotlin/edu/agh/roomie/TestUtils.kt

@@ -0,0 +1,52 @@
+package edu.agh.roomie
+
+import org.jetbrains.exposed.sql.Database
+import org.jetbrains.exposed.sql.SchemaUtils
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.testcontainers.containers.PostgreSQLContainer
+import org.testcontainers.utility.DockerImageName
+
+object TestUtils {
+  private val postgresContainer by lazy {
+    PostgreSQLContainer<Nothing>(DockerImageName.parse("postgres:15-alpine")).apply {
+      withDatabaseName("testdb")
+      withUsername("test")
+      withPassword("test")
+      start()
+    }
+  }
+
+  /**
+   * Creates a PostgreSQL database for testing using TestContainers
+   */
+
+  val testDatabase: Database by lazy {
+    Database.connect(
+      url = postgresContainer.jdbcUrl,
+      user = postgresContainer.username,
+      driver = "org.postgresql.Driver",
+      password = postgresContainer.password
+    )
+  }
+
+  fun createTestDatabase(): Database {
+    // Ensure the container is started
+    if (!postgresContainer.isRunning) {
+      postgresContainer.start()
+    }
+
+    return testDatabase.also {
+      transaction { SchemaUtils.dropDatabase() }
+    }
+  }
+
+  /**
+   * Executes a transaction on the test database
+   */
+  fun <T> withTestDatabase(block: () -> T): T {
+    val database = createTestDatabase()
+    return transaction(database) {
+      block()
+    }
+  }
+}