test: tests for select with KClass (#825)

Author: minsujang0

dsl/jpql/src/test/kotlin/com/linecorp/kotlinjdsl/dsl/jpql/select/SelectDslTest.kt

@@ -69,6 +69,31 @@ class SelectDslTest : WithAssertions {
         assertThat(actual).isEqualTo(expected)
     }
 
+    @Test
+    fun `select() with a KClass`() {
+        // when
+        val select = queryPart {
+            select(
+                BigDecimal::class,
+                expression1,
+            ).from(
+                entity1,
+            )
+        }.toQuery()
+
+        val actual: SelectQuery<BigDecimal> = select // for type check
+
+        // then
+        val expected = SelectQueries.selectQuery(
+            returnType = BigDecimal::class,
+            distinct = false,
+            select = listOf(expression1),
+            from = listOf(entity1),
+        )
+
+        assertThat(actual).isEqualTo(expected)
+    }
+
     @Test
     fun `selectDistinct() with an expression`() {
         // when
@@ -118,6 +143,31 @@ class SelectDslTest : WithAssertions {
         assertThat(actual).isEqualTo(expected)
     }
 
+    @Test
+    fun `selectDistinct() with a KClass`() {
+        // when
+        val select = queryPart {
+            selectDistinct(
+                BigDecimal::class,
+                expression1,
+            ).from(
+                entity1,
+            )
+        }.toQuery()
+
+        val actual: SelectQuery<BigDecimal> = select // for type check
+
+        // then
+        val expected = SelectQueries.selectQuery(
+            returnType = BigDecimal::class,
+            distinct = true,
+            select = listOf(expression1),
+            from = listOf(entity1),
+        )
+
+        assertThat(actual).isEqualTo(expected)
+    }
+
     @Test
     fun `selectNew() with a generic type and expressions`() {
         // when
@@ -148,6 +198,37 @@ class SelectDslTest : WithAssertions {
         assertThat(actual).isEqualTo(expected)
     }
 
+    @Test
+    fun `selectNew() with a KClass`() {
+        // when
+        val select = queryPart {
+            selectNew(
+                Dto::class,
+                expression1,
+                expression2,
+            ).from(
+                entity1,
+            )
+        }.toQuery()
+
+        val actual: SelectQuery<Dto> = select // for type check
+
+        // then
+        val expected = SelectQueries.selectQuery(
+            returnType = Dto::class,
+            distinct = false,
+            select = listOf(
+                Expressions.new(
+                    type = Dto::class,
+                    args = listOf(expression1, expression2),
+                ),
+            ),
+            from = listOf(entity1),
+        )
+
+        assertThat(actual).isEqualTo(expected)
+    }
+
     @Test
     fun `selectDistinctNew() with a generic type and expressions`() {
         // when
@@ -177,4 +258,35 @@ class SelectDslTest : WithAssertions {
 
         assertThat(actual).isEqualTo(expected)
     }
+
+    @Test
+    fun `selectDistinctNew() with a KClass`() {
+        // when
+        val select = queryPart {
+            selectDistinctNew(
+                Dto::class,
+                expression1,
+                expression2,
+            ).from(
+                entity1,
+            )
+        }.toQuery()
+
+        val actual: SelectQuery<Dto> = select // for type check
+
+        // then
+        val expected = SelectQueries.selectQuery(
+            returnType = Dto::class,
+            distinct = true,
+            select = listOf(
+                Expressions.new(
+                    type = Dto::class,
+                    args = listOf(expression1, expression2),
+                ),
+            ),
+            from = listOf(entity1),
+        )
+
+        assertThat(actual).isEqualTo(expected)
+    }
 }