✨ Test users and start testing bets

Sources/src/main/kotlin/allin/data/postgres/PostgresBetDataSource.kt

@@ -21,7 +21,6 @@ class PostgresBetDataSource(private val database: Database) : BetDataSource {
 
             filters.size == 1 -> {
                 val filter = filters.first()
-
                 when (filter) {
                     BetFilter.PUBLIC -> database.bets.filter { !it.isPrivate }
                     BetFilter.INVITATION -> database.bets.filter { it.isPrivate }

Sources/src/test/kotlin/allin/ApplicationTest.kt

@@ -2,4 +2,5 @@ package allin
 
 class ApplicationTest {
 
+
 }

Sources/src/test/kotlin/allin/data/postgres/PostgresBetDataSourceTest.kt

@@ -0,0 +1,129 @@
+package allin.data.postgres
+
+import allin.data.postgres.entities.betAnswerInfos
+import allin.data.postgres.entities.betInfos
+import allin.data.postgres.entities.betResults
+import allin.model.*
+import org.junit.jupiter.api.*
+import org.junit.jupiter.api.Assertions.*
+import org.ktorm.database.Database
+import org.ktorm.dsl.eq
+import org.ktorm.entity.removeIf
+import org.ktorm.support.postgresql.PostgreSqlDialect
+import java.time.ZoneId
+import java.time.ZonedDateTime
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+@TestMethodOrder(MethodOrderer.OrderAnnotation::class)
+class PostgresBetDataSourceTest {
+
+    private lateinit var database: Database
+    private lateinit var dataSource: PostgresBetDataSource
+    lateinit var user: User
+
+    @BeforeAll
+    fun setUp() {
+        val dbDatabase = System.getenv()["POSTGRES_DB"]
+        val dbUser = System.getenv()["POSTGRES_USER"]
+        val dbPassword = System.getenv()["POSTGRES_PASSWORD"]
+        val dbHost = System.getenv()["POSTGRES_HOST"]
+        val url = "jdbc:postgresql://$dbHost/$dbDatabase"
+
+        database = Database.connect(
+            url = url,
+            user = dbUser,
+            password = dbPassword,
+            dialect = PostgreSqlDialect()
+        )
+
+        user = User(
+            id = "123",
+            username = "JohnDoe",
+            email = "johndoe@example.com",
+            password = "securePassword123",
+            nbCoins = 1000,
+            token = null,
+            image = null,
+            bestWin = 500,
+            nbBets = 50,
+            nbFriends = 10
+        )
+
+
+        dataSource = PostgresBetDataSource(database)
+        PostgresUserDataSource(database).addUser(user)
+    }
+
+    @Test
+    @Order(1)
+    fun testAddBet() {
+        val bet = Bet(
+            id = "bbba08f7-744f-4d23-9706-b31bdf24f614",
+            theme = "Sports",
+            sentenceBet = "Will team A win?",
+            type = BetType.BINARY,
+            endRegistration = ZonedDateTime.now(ZoneId.of("+02:00")).plusDays(1),
+            endBet = ZonedDateTime.now(ZoneId.of("+02:00")).plusDays(2),
+            isPrivate = false,
+            response = listOf(YES_VALUE, NO_VALUE),
+            createdBy = user.id
+        )
+        dataSource.addBet(bet)
+
+        val retrievedBet = dataSource.getBetById("bbba08f7-744f-4d23-9706-b31bdf24f614")
+        assertNotNull(retrievedBet)
+        assertEquals("bbba08f7-744f-4d23-9706-b31bdf24f614", retrievedBet?.id)
+    }
+
+    @Test
+    @Order(2)
+    fun testGetAllBets() {
+        val userDTO = user.toDto()
+        val bets = dataSource.getAllBets(emptyList(), userDTO)
+        assertTrue(bets.isNotEmpty())
+    }
+
+    @Test
+    @Order(3)
+    fun testUpdateBet() {
+        val updatedData = UpdatedBetData(
+            id = "bbba08f7-744f-4d23-9706-b31bdf24f614",
+            endBet = ZonedDateTime.now(ZoneId.of("+02:00")).plusDays(3),
+            isPrivate = true,
+            response = listOf(YES_VALUE, NO_VALUE)
+        )
+        val result = dataSource.updateBet(updatedData)
+        assertTrue(result)
+
+        val retrievedBet = dataSource.getBetById("bbba08f7-744f-4d23-9706-b31bdf24f614")
+        assertNotNull(retrievedBet)
+        assertTrue(retrievedBet?.isPrivate ?: false)
+    }
+
+    @Test
+    @Order(4)
+    fun testConfirmBet() {
+        dataSource.confirmBet("bbba08f7-744f-4d23-9706-b31bdf24f614", YES_VALUE)
+
+        val retrievedBet = dataSource.getBetById("bbba08f7-744f-4d23-9706-b31bdf24f614")
+        assertNotNull(retrievedBet)
+        assertEquals(BetStatus.FINISHED, retrievedBet?.status)
+    }
+
+    @Test
+    @Order(5)
+    fun testGetBetDetailById() {
+        val betDetail = dataSource.getBetDetailById("bbba08f7-744f-4d23-9706-b31bdf24f614", user.id)
+        assertNotNull(betDetail)
+        assertEquals("bbba08f7-744f-4d23-9706-b31bdf24f614", betDetail?.bet?.id)
+    }
+
+    @AfterAll
+    fun tearDown() {
+        database.betResults.removeIf { it.betId eq "bbba08f7-744f-4d23-9706-b31bdf24f614" }
+        database.betInfos.removeIf { it.id eq "bbba08f7-744f-4d23-9706-b31bdf24f614" }
+        database.betAnswerInfos.removeIf { it.betId eq "bbba08f7-744f-4d23-9706-b31bdf24f614" }
+        dataSource.removeBet("bbba08f7-744f-4d23-9706-b31bdf24f614")
+        PostgresUserDataSource(database).deleteUser(user.username)
+    }
+}

Sources/src/test/kotlin/allin/data/postgres/PostgresUserDataSourceTest.kt

@@ -0,0 +1,229 @@
+import allin.data.postgres.PostgresUserDataSource
+import allin.data.postgres.entities.UsersEntity
+import allin.data.postgres.entities.users
+import allin.ext.executeWithResult
+import allin.model.User
+import junit.framework.TestCase.*
+import org.junit.jupiter.api.*
+import org.ktorm.database.Database
+import org.ktorm.dsl.eq
+import org.ktorm.dsl.update
+import org.ktorm.entity.find
+import org.ktorm.support.postgresql.PostgreSqlDialect
+import java.time.Instant
+import java.util.*
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+@TestMethodOrder(MethodOrderer.OrderAnnotation::class)
+class PostgresUserDataSourceTest {
+
+    private lateinit var userDataSource: PostgresUserDataSource
+    private lateinit var database: Database
+
+    @BeforeAll
+    fun setUp() {
+        val dbDatabase = System.getenv()["POSTGRES_DB"]
+        val dbUser = System.getenv()["POSTGRES_USER"]
+        val dbPassword = System.getenv()["POSTGRES_PASSWORD"]
+        val dbHost = System.getenv()["POSTGRES_HOST"]
+        val url = "jdbc:postgresql://$dbHost/$dbDatabase"
+
+        database = Database.connect(
+            url = url,
+            user = dbUser,
+            password = dbPassword,
+            dialect = PostgreSqlDialect()
+        )
+
+        userDataSource = PostgresUserDataSource(database)
+
+    }
+
+    @AfterAll
+    fun delUser() {
+        userDataSource.deleteUser("JaneDoe")
+    }
+
+    @Test
+    @Order(1)
+    fun addUser() {
+        val user = User(
+            id = "123",
+            username = "JohnDoe",
+            email = "johndoe@example.com",
+            password = "securePassword123",
+            nbCoins = 1000,
+            token = null,
+            image = null,
+            bestWin = 500,
+            nbBets = 50,
+            nbFriends = 10
+        )
+
+        userDataSource.addUser(user)
+
+        val addedUser = database.users.find { it.id eq "123" }
+        assertNotNull(addedUser)
+        assertEquals("JohnDoe", addedUser?.username)
+    }
+
+    @Test
+    @Order(2)
+    fun getUserByUsername() {
+        val result = userDataSource.getUserByUsername("JohnDoe")
+
+        assertNotNull(result.first)
+        assertEquals("JohnDoe", result.first?.username)
+        assertEquals("securePassword123", result.second)
+
+        val resultS = userDataSource.getUserByUsername("nonexistent")
+
+        assertNull(resultS.first)
+        assertNull(resultS.second)
+    }
+
+    @Test
+    @Order(3)
+    fun getUserById() {
+        val result = userDataSource.getUserById("123")
+
+        assertNotNull(result)
+        assertEquals("JohnDoe", result?.username)
+    }
+
+    @Test
+    @Order(4)
+    fun deleteUser() {
+        val result = userDataSource.deleteUser("JohnDoe")
+
+        assertTrue(result)
+
+        val deletedUser = database.users.find { it.id eq "123" }
+        assertNull(deletedUser)
+
+        val resultS = userDataSource.deleteUser("nonexistent")
+        assertFalse(resultS)
+    }
+
+    @Test
+    @Order(5)
+    fun addCoins() {
+        userDataSource.addUser(
+            User(
+                id = "11111",
+                username = "JaneDoe",
+                email = "janedoe@example.com",
+                password = "securePassword456",
+                nbCoins = 1000,
+                token = null,
+                image = null,
+                bestWin = 500,
+                nbBets = 50,
+                nbFriends = 10
+            )
+        )
+
+        userDataSource.addCoins("JaneDoe", 500)
+
+        val updatedUser = database.users.find { it.id eq "11111" }
+        assertNotNull(updatedUser)
+        assertEquals(1500, updatedUser?.nbCoins)
+    }
+
+    @Test
+    @Order(6)
+    fun removeCoins() {
+        userDataSource.removeCoins("JaneDoe", 300)
+        val updatedUser = database.users.find { it.id eq "11111" }
+        assertNotNull(updatedUser)
+        assertEquals(1200, updatedUser?.nbCoins)
+    }
+
+    @Test
+    @Order(7)
+    fun userExists() {
+        val result = userDataSource.userExists("JaneDoe")
+        assertTrue(result)
+        val resultS = userDataSource.userExists("nonexistent")
+        assertFalse(resultS)
+    }
+
+    @Test
+    @Order(8)
+    fun emailExists() {
+        val result = userDataSource.emailExists("janedoe@example.com")
+
+        assertTrue(result)
+
+        val resultS = userDataSource.emailExists("nonexistent@example.com")
+
+        assertFalse(resultS)
+    }
+
+    @Test
+    @Order(9)
+    fun canHaveDailyGift() {
+        database.update(UsersEntity) {
+            set(it.lastGift, Instant.now().minusSeconds(86400 * 2)) // 2 days ago
+            where { it.username eq "JaneDoe" }
+        }
+
+        val result = userDataSource.canHaveDailyGift("JaneDoe")
+
+        assertTrue(result)
+
+        val resultS = userDataSource.canHaveDailyGift("JaneDoe")
+
+        assertFalse(resultS)
+    }
+
+    @Test
+    @Order(10)
+    fun addImage() {
+        val imageBytes = "sampleImage".toByteArray()
+
+        userDataSource.addImage("11111", imageBytes)
+
+        val resultSet = database.executeWithResult(
+            """
+            SELECT encode(image, 'base64') AS image 
+            FROM userimage 
+            WHERE user_id = '11111'
+            """.trimIndent()
+        )
+
+        assertNotNull(resultSet)
+        if (resultSet != null && resultSet.next()) {
+            val image = resultSet.getString("image")
+            assertEquals(Base64.getEncoder().encodeToString(imageBytes), image)
+        }
+    }
+
+    @Test
+    @Order(11)
+    fun getImage() {
+        val result = userDataSource.getImage("11111")
+
+        assertNotNull(result)
+    }
+
+    @Test
+    @Order(12)
+    fun removeImage() {
+        userDataSource.removeImage("11111")
+
+        val resultSet = database.executeWithResult(
+            """
+            SELECT encode(image, 'base64') AS image 
+            FROM userimage 
+            WHERE user_id = '11111'
+            """.trimIndent()
+        )
+
+        assertNotNull(resultSet)
+        if (resultSet != null && resultSet.next()) {
+            val image = resultSet.getString("image")
+            assertNull(image)
+        }
+    }
+}