test: add more tests and align to match order

Author: minsujang0

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

@@ -20,6 +20,31 @@ class SelectDslTest : WithAssertions {
     private class Dto
     private class View
 
+    @Test
+    fun `select() with a KClass and an expression`() {
+        // 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 `select() with an expression`() {
         // when
@@ -44,6 +69,32 @@ class SelectDslTest : WithAssertions {
         assertThat(actual).isEqualTo(expected)
     }
 
+    @Test
+    fun `select() with a KClass and expressions`() {
+        // when
+        val select = queryPart {
+            select(
+                View::class,
+                expression1,
+                expression2,
+            ).from(
+                entity1,
+            )
+        }.toQuery()
+
+        val actual: SelectQuery<View> = select // for type check
+
+        // then
+        val expected = SelectQueries.selectQuery(
+            returnType = View::class,
+            distinct = false,
+            select = listOf(expression1, expression2),
+            from = listOf(entity1),
+        )
+
+        assertThat(actual).isEqualTo(expected)
+    }
+
     @Test
     fun `select() with a generic type and expressions`() {
         // when
@@ -70,10 +121,10 @@ class SelectDslTest : WithAssertions {
     }
 
     @Test
-    fun `select() with a KClass`() {
+    fun `selectDistinct() with a KClass and an expression`() {
         // when
         val select = queryPart {
-            select(
+            selectDistinct(
                 BigDecimal::class,
                 expression1,
             ).from(
@@ -86,7 +137,7 @@ class SelectDslTest : WithAssertions {
         // then
         val expected = SelectQueries.selectQuery(
             returnType = BigDecimal::class,
-            distinct = false,
+            distinct = true,
             select = listOf(expression1),
             from = listOf(entity1),
         )
@@ -119,10 +170,11 @@ class SelectDslTest : WithAssertions {
     }
 
     @Test
-    fun `selectDistinct() with a generic type and expressions`() {
+    fun `selectDistinct() with a KClass and expressions`() {
         // when
         val select = queryPart {
-            selectDistinct<View>(
+            selectDistinct(
+                View::class,
                 expression1,
                 expression2,
             ).from(
@@ -144,35 +196,36 @@ class SelectDslTest : WithAssertions {
     }
 
     @Test
-    fun `selectDistinct() with a KClass`() {
+    fun `selectDistinct() with a generic type and expressions`() {
         // when
         val select = queryPart {
-            selectDistinct(
-                BigDecimal::class,
+            selectDistinct<View>(
                 expression1,
+                expression2,
             ).from(
                 entity1,
             )
         }.toQuery()
 
-        val actual: SelectQuery<BigDecimal> = select // for type check
+        val actual: SelectQuery<View> = select // for type check
 
         // then
         val expected = SelectQueries.selectQuery(
-            returnType = BigDecimal::class,
+            returnType = View::class,
             distinct = true,
-            select = listOf(expression1),
+            select = listOf(expression1, expression2),
             from = listOf(entity1),
         )
 
         assertThat(actual).isEqualTo(expected)
     }
 
     @Test
-    fun `selectNew() with a generic type and expressions`() {
+    fun `selectNew() with a KClass and expressions`() {
         // when
         val select = queryPart {
-            selectNew<Dto>(
+            selectNew(
+                Dto::class,
                 expression1,
                 expression2,
             ).from(
@@ -199,11 +252,10 @@ class SelectDslTest : WithAssertions {
     }
 
     @Test
-    fun `selectNew() with a KClass`() {
+    fun `selectNew() with a generic type and expressions`() {
         // when
         val select = queryPart {
-            selectNew(
-                Dto::class,
+            selectNew<Dto>(
                 expression1,
                 expression2,
             ).from(
@@ -230,10 +282,11 @@ class SelectDslTest : WithAssertions {
     }
 
     @Test
-    fun `selectDistinctNew() with a generic type and expressions`() {
+    fun `selectDistinctNew() with a KClass and expressions`() {
         // when
         val select = queryPart {
-            selectDistinctNew<Dto>(
+            selectDistinctNew(
+                Dto::class,
                 expression1,
                 expression2,
             ).from(
@@ -260,11 +313,10 @@ class SelectDslTest : WithAssertions {
     }
 
     @Test
-    fun `selectDistinctNew() with a KClass`() {
+    fun `selectDistinctNew() with a generic type and expressions`() {
         // when
         val select = queryPart {
-            selectDistinctNew(
-                Dto::class,
+            selectDistinctNew<Dto>(
                 expression1,
                 expression2,
             ).from(