273 lines
9.6 KiB
Kotlin
273 lines
9.6 KiB
Kotlin
package fr.postgresjson
|
|
|
|
import com.fasterxml.jackson.core.type.TypeReference
|
|
import fr.postgresjson.connexion.Connection.QueryError
|
|
import fr.postgresjson.connexion.Paginated
|
|
import fr.postgresjson.connexion.select
|
|
import fr.postgresjson.connexion.selectOne
|
|
import fr.postgresjson.entity.Parameter
|
|
import fr.postgresjson.entity.UuidEntity
|
|
import fr.postgresjson.serializer.deserialize
|
|
import fr.postgresjson.serializer.toTypeReference
|
|
import org.junit.Assert.assertEquals
|
|
import org.junit.Assert.assertNotNull
|
|
import org.junit.Assert.assertTrue
|
|
import org.junit.jupiter.api.Assertions
|
|
import org.junit.jupiter.api.Test
|
|
import org.junit.jupiter.api.TestInstance
|
|
import org.junit.jupiter.api.assertThrows
|
|
import java.util.UUID
|
|
import kotlin.test.assertNull
|
|
|
|
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
|
|
class ConnectionTest : TestAbstract() {
|
|
private class ObjTest(val name: String, id: UUID = UUID.fromString("2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00")) : UuidEntity(id)
|
|
private class ObjTest2(val title: String, var test: ObjTest?) : UuidEntity()
|
|
private class ObjTest3(val first: String, var second: String, var third: Int) : UuidEntity()
|
|
private class ObjTestWithParameterObject(var first: ParameterObject, var second: ParameterObject) : UuidEntity()
|
|
private class ParameterObject(var third: String) : Parameter
|
|
|
|
@Test
|
|
fun getObject() {
|
|
val obj: ObjTest? = connection.selectOne("select to_json(a) from test a limit 1")
|
|
assertTrue(obj is ObjTest)
|
|
assertTrue(obj!!.id == UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"))
|
|
}
|
|
|
|
@Test
|
|
fun getExistingObject() {
|
|
val objs: List<ObjTest2> = connection.select(
|
|
"""
|
|
select
|
|
json_agg(j)
|
|
FROM (
|
|
SELECT
|
|
t.id, t.title,
|
|
t2 as test
|
|
from test2 t
|
|
JOIN test t2 ON t.test_id = t2.id
|
|
) j;
|
|
""".trimIndent()
|
|
)
|
|
assertNotNull(objs)
|
|
assertEquals(objs.size, 2)
|
|
assertEquals(objs[0].id, UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"))
|
|
assertEquals(objs[0].test!!.id, UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"))
|
|
}
|
|
|
|
@Test
|
|
fun `test call request with args`() {
|
|
val result: ObjTest? = connection.selectOne("select json_build_object('id', '2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00', 'name', ?::text)", listOf("myName"))
|
|
assertNotNull(result)
|
|
assertEquals("myName", result!!.name)
|
|
}
|
|
|
|
@Test
|
|
fun `test call request without args`() {
|
|
val result: ObjTest? = connection.selectOne("select json_build_object('id', '2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00', 'name', 'myName')", object : TypeReference<ObjTest>() {}) {
|
|
assertEquals("myName", this.rows[0].getString(0)?.deserialize<ObjTest>()?.name)
|
|
}
|
|
assertNotNull(result)
|
|
assertEquals("myName", result!!.name)
|
|
}
|
|
|
|
@Test
|
|
fun `test call request return null`() {
|
|
val result: ObjTest? = connection.selectOne("select null;", object : TypeReference<ObjTest>() {})
|
|
assertNull(result)
|
|
}
|
|
|
|
@Test
|
|
fun `test call request return nothing`() {
|
|
val result: ObjTest? = connection.selectOne("select * from test where false;", object : TypeReference<ObjTest>() {})
|
|
assertNull(result)
|
|
}
|
|
|
|
@Test
|
|
fun callRequestWithArgsEntity() {
|
|
val o = ObjTest("myName", id = UUID.fromString("2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00"))
|
|
val obj: ObjTest? = connection.selectOne("select json_build_object('id', id, 'name', name) FROM json_to_record(?::json) as o(id uuid, name text);", listOf(o))
|
|
assertNotNull(obj)
|
|
assertTrue(obj is ObjTest)
|
|
assertEquals(obj!!.id, UUID.fromString("2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00"))
|
|
assertEquals(obj.name, "myName")
|
|
}
|
|
|
|
@Test
|
|
fun `test update Entity`() {
|
|
val obj = ObjTest("before", id = UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"))
|
|
val objUpdated: ObjTest? = connection.update("select ?::jsonb || jsonb_build_object('name', 'after');", obj.toTypeReference(), obj)
|
|
assertTrue(objUpdated is ObjTest)
|
|
assertTrue(objUpdated!!.id == UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"))
|
|
assertTrue(objUpdated.name == "after")
|
|
}
|
|
|
|
@Test
|
|
fun callExec() {
|
|
val o = ObjTest("myName")
|
|
val result = connection.exec("select json_build_object('id', '2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00', 'name', ?::json->>'name')", listOf(o))
|
|
Assertions.assertEquals(1, result.rowsAffected)
|
|
}
|
|
|
|
@Test
|
|
fun `select one with named parameters`() {
|
|
val result: ObjTest3? = connection.selectOne(
|
|
"SELECT json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int)",
|
|
mapOf(
|
|
"first" to "ff",
|
|
"second" to "sec",
|
|
"third" to 123
|
|
)
|
|
)
|
|
assertEquals(result!!.first, "ff")
|
|
assertEquals(result.second, "sec")
|
|
assertEquals(result.third, 123)
|
|
}
|
|
|
|
@Test
|
|
fun `select one with named parameters object`() {
|
|
val result: ObjTestWithParameterObject? = connection.selectOne(
|
|
"SELECT json_build_object('first', :first::json, 'second', :second::json)",
|
|
mapOf(
|
|
"first" to ParameterObject("one"),
|
|
"second" to ParameterObject("two")
|
|
)
|
|
)
|
|
assertEquals("one", result!!.first.third)
|
|
assertEquals("two", result.second.third)
|
|
}
|
|
|
|
@Test
|
|
fun `select with named parameters`() {
|
|
val result: List<ObjTest3> = connection.select(
|
|
"""
|
|
SELECT json_build_array(
|
|
json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int),
|
|
json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int)
|
|
)
|
|
""".trimIndent(),
|
|
mapOf(
|
|
"first" to "ff",
|
|
"third" to 123,
|
|
"second" to "sec"
|
|
)
|
|
)
|
|
assertEquals(result[0].first, "ff")
|
|
assertEquals(result[0].second, "sec")
|
|
assertEquals(result[0].third, 123)
|
|
}
|
|
|
|
@Test
|
|
fun `select with named parameters as vararg of Pair`() {
|
|
val result: List<ObjTest3> = connection.select(
|
|
"""
|
|
SELECT json_build_array(
|
|
json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int),
|
|
json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int)
|
|
)
|
|
""".trimIndent(),
|
|
"first" to "ff",
|
|
"third" to 123,
|
|
"second" to "sec"
|
|
)
|
|
assertEquals(result[0].first, "ff")
|
|
assertEquals(result[0].second, "sec")
|
|
assertEquals(result[0].third, 123)
|
|
}
|
|
|
|
@Test
|
|
fun `select paginated`() {
|
|
val result: Paginated<ObjTest> = connection.select(
|
|
"""
|
|
SELECT json_build_array(
|
|
json_build_object('id', '417aaa7e-7bc6-49b7-9fe8-6c8433b3f430', 'name', :name::text),
|
|
json_build_object('id', 'abd46e7a-e749-4ce4-8361-e7b64da89da6', 'name', :name::text || '-2')
|
|
), 10 as total
|
|
LIMIT :limit OFFSET :offset
|
|
""".trimIndent(),
|
|
1,
|
|
2,
|
|
mapOf("name" to "ff")
|
|
|
|
)
|
|
assertNotNull(result)
|
|
assertEquals(result.result[0].name, "ff")
|
|
assertEquals(result.result[1].name, "ff-2")
|
|
assertEquals(result.total, 10)
|
|
assertEquals(result.offset, 0)
|
|
}
|
|
|
|
@Test
|
|
fun `test select paginated without result`() {
|
|
val result: Paginated<ObjTest> = connection.select(
|
|
"""
|
|
SELECT null,
|
|
10 as total
|
|
LIMIT :limit
|
|
OFFSET :offset
|
|
""".trimIndent(),
|
|
1,
|
|
2,
|
|
object : TypeReference<List<ObjTest>>() {}
|
|
)
|
|
assertNotNull(result)
|
|
assertTrue(result.result.isEmpty())
|
|
assertEquals(0, result.result.size)
|
|
assertEquals(result.total, 10)
|
|
assertEquals(result.offset, 0)
|
|
}
|
|
|
|
@Test
|
|
fun `test select paginated without total`() {
|
|
val exception = assertThrows<QueryError> {
|
|
val result: Paginated<ObjTest> = connection.select(
|
|
"""
|
|
SELECT null
|
|
LIMIT :limit
|
|
OFFSET :offset
|
|
""".trimIndent(),
|
|
1,
|
|
2,
|
|
object : TypeReference<List<ObjTest>>() {}
|
|
)
|
|
}
|
|
|
|
assertEquals(
|
|
"""
|
|
The query not return the "total" column
|
|
|
|
> :offset = 0, :limit = 2
|
|
> SELECT null
|
|
> LIMIT :limit
|
|
> OFFSET :offset
|
|
> -----
|
|
> ?column?
|
|
> null
|
|
""".trimIndent(),
|
|
exception.message
|
|
)
|
|
}
|
|
|
|
@Test
|
|
fun `selectOne with extra parameters`() {
|
|
val params: Map<String, Any?> = mapOf(
|
|
"first" to "ff",
|
|
"third" to 123,
|
|
"second" to "sec"
|
|
)
|
|
val result: ObjTest3? = connection.selectOne(
|
|
"""
|
|
SELECT json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int), 'plop'::text as other
|
|
""".trimIndent(),
|
|
params
|
|
) {
|
|
assertEquals("ff", it!!.first)
|
|
assertEquals("plop", rows[0].getString("other"))
|
|
}
|
|
assertNotNull(result)
|
|
assertEquals("ff", result!!.first)
|
|
assertEquals("sec", result.second)
|
|
assertEquals(123, result.third)
|
|
}
|
|
}
|