Tests for name conflicts and Kotlin lambda

Author: jeffgbutler

src/test/kotlin/examples/kotlin/mybatis3/joins/JoinMapper.kt

@@ -19,8 +19,9 @@ import org.apache.ibatis.annotations.ResultMap
 import org.apache.ibatis.annotations.SelectProvider
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider
 import org.mybatis.dynamic.sql.util.SqlProviderAdapter
+import org.mybatis.dynamic.sql.util.mybatis3.GeneralMapper
 
-interface JoinMapper {
+interface JoinMapper : GeneralMapper {
     @SelectProvider(type = SqlProviderAdapter::class, method = "select")
     @ResultMap("SimpleJoinResult")
     fun selectMany(selectStatement: SelectStatementProvider): List<OrderMaster>

src/test/kotlin/examples/kotlin/mybatis3/joins/JoinMapperTest.kt

@@ -31,7 +31,6 @@ import org.assertj.core.api.Assertions.entry
 import org.junit.jupiter.api.Test
 import org.mybatis.dynamic.sql.SqlBuilder.*
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.from
-import org.mybatis.dynamic.sql.util.mybatis3.GeneralMapper
 import java.io.InputStreamReader
 import java.sql.DriverManager
 
@@ -51,7 +50,6 @@ class JoinMapperTest {
         val environment = Environment("test", JdbcTransactionFactory(), ds)
         val config = Configuration(environment)
         config.addMapper(JoinMapper::class.java)
-        config.addMapper(GeneralMapper::class.java)
         return SqlSessionFactoryBuilder().build(config).openSession()
     }
 
@@ -161,7 +159,7 @@ class JoinMapperTest {
     @Test
     fun testFullJoinWithAliases() {
         newSession().use { session ->
-            val mapper = session.getMapper(GeneralMapper::class.java)
+            val mapper = session.getMapper(JoinMapper::class.java)
 
             val selectStatement = select(OrderLine.orderId, OrderLine.quantity, ItemMaster.itemId,
                     ItemMaster.description).from(OrderMaster, "om") {
@@ -181,33 +179,46 @@ class JoinMapperTest {
 
             assertThat(selectStatement.selectStatement).isEqualTo(expectedStatement)
 
-            val rows = mapper.selectManyMappedRows(selectStatement)
+            data class OrderDetail (val itemId: Int?, val orderId: Int?, val quantity: Int?, val description: String?)
+
+            val rows = mapper.selectMany(selectStatement) {
+                OrderDetail(
+                    it["ITEM_ID"] as Int?,
+                    it["ORDER_ID"] as Int?,
+                    it["QUANTITY"] as Int?,
+                    it["DESCRIPTION"] as String?
+                )
+            }
 
             assertThat(rows).hasSize(6)
 
-            assertThat(rows[0]).containsExactly(
-                entry("DESCRIPTION", "Catcher Glove"),
-                entry("ITEM_ID", 55)
-            )
+            with(rows[0]) {
+                assertThat(itemId).isEqualTo(55)
+                assertThat(orderId).isNull()
+                assertThat(quantity).isNull()
+                assertThat(description).isEqualTo("Catcher Glove")
+            }
 
-            assertThat(rows[3]).containsExactly(
-                entry("ORDER_ID", 2),
-                entry("QUANTITY", 6)
-            )
+            with(rows[3]) {
+                assertThat(itemId).isNull()
+                assertThat(orderId).isEqualTo(2)
+                assertThat(quantity).isEqualTo(6)
+                assertThat(description).isNull()
+            }
 
-            assertThat(rows[5]).containsExactly(
-                entry("ORDER_ID", 2),
-                entry("QUANTITY", 1),
-                entry("DESCRIPTION", "Outfield Glove"),
-                entry("ITEM_ID", 44)
-            )
+            with(rows[5]) {
+                assertThat(itemId).isEqualTo(44)
+                assertThat(orderId).isEqualTo(2)
+                assertThat(quantity).isEqualTo(1)
+                assertThat(description).isEqualTo("Outfield Glove")
+            }
         }
     }
 
     @Test
     fun testFullJoinWithoutAliases() {
         newSession().use { session ->
-            val mapper = session.getMapper(GeneralMapper::class.java)
+            val mapper = session.getMapper(JoinMapper::class.java)
 
             val selectStatement = select(OrderLine.orderId, OrderLine.quantity, ItemMaster.itemId,
                     ItemMaster.description).from(OrderMaster, "om") {
@@ -253,7 +264,7 @@ class JoinMapperTest {
     @Test
     fun testLeftJoinWithAliases() {
         newSession().use { session ->
-            val mapper = session.getMapper(GeneralMapper::class.java)
+            val mapper = session.getMapper(JoinMapper::class.java)
 
             val selectStatement = select(OrderLine.orderId, OrderLine.quantity, ItemMaster.itemId,
                     ItemMaster.description).from(OrderMaster, "om") {
@@ -294,7 +305,7 @@ class JoinMapperTest {
     @Test
     fun testLeftJoinWithoutAliases() {
         newSession().use { session ->
-            val mapper = session.getMapper(GeneralMapper::class.java)
+            val mapper = session.getMapper(JoinMapper::class.java)
 
             val selectStatement = select(OrderLine.orderId, OrderLine.quantity, ItemMaster.itemId,
                     ItemMaster.description).from(OrderMaster, "om") {
@@ -335,7 +346,7 @@ class JoinMapperTest {
     @Test
     fun testRightJoinWithAliases() {
         newSession().use { session ->
-            val mapper = session.getMapper(GeneralMapper::class.java)
+            val mapper = session.getMapper(JoinMapper::class.java)
 
             val selectStatement = select(OrderLine.orderId, OrderLine.quantity, ItemMaster.itemId,
                     ItemMaster.description).from(OrderMaster, "om") {
@@ -376,7 +387,7 @@ class JoinMapperTest {
     @Test
     fun testRightJoinWithoutAliases() {
         newSession().use { session ->
-            val mapper = session.getMapper(GeneralMapper::class.java)
+            val mapper = session.getMapper(JoinMapper::class.java)
 
             val selectStatement = select(OrderLine.orderId, OrderLine.quantity, ItemMaster.itemId,
                     ItemMaster.description).from(OrderMaster, "om") {