diff --git a/Sources/src/main/kotlin/allin/data/postgres/PostgresBetDataSource.kt b/Sources/src/main/kotlin/allin/data/postgres/PostgresBetDataSource.kt index 30854d4..974af41 100644 --- a/Sources/src/main/kotlin/allin/data/postgres/PostgresBetDataSource.kt +++ b/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 } diff --git a/Sources/src/test/kotlin/allin/ApplicationTest.kt b/Sources/src/test/kotlin/allin/ApplicationTest.kt index 9dd77ad..a6b436a 100644 --- a/Sources/src/test/kotlin/allin/ApplicationTest.kt +++ b/Sources/src/test/kotlin/allin/ApplicationTest.kt @@ -2,4 +2,5 @@ package allin class ApplicationTest { + } diff --git a/Sources/src/test/kotlin/allin/data/postgres/PostgresBetDataSourceTest.kt b/Sources/src/test/kotlin/allin/data/postgres/PostgresBetDataSourceTest.kt new file mode 100644 index 0000000..fb93e00 --- /dev/null +++ b/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) + } +} diff --git a/Sources/src/test/kotlin/allin/data/postgres/PostgresUserDataSourceTest.kt b/Sources/src/test/kotlin/allin/data/postgres/PostgresUserDataSourceTest.kt new file mode 100644 index 0000000..10bb275 --- /dev/null +++ b/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) + } + } +} \ No newline at end of file