Merge pull request #144 from jeffgbutler/master

Add some example tests

Author: jeffgbutler

src/test/java/examples/springbatch/common/Person.java renamed to src/test/java/examples/generated/always/PersonRecord.java

@@ -13,9 +13,9 @@
  *    See the License for the specific language governing permissions and
  *    limitations under the License.
  */
-package examples.springbatch.common;
+package examples.generated.always;
 
-public class Person {
+public class PersonRecord {
     private Integer id;
     private String firstName;
     private String lastName;

src/test/java/examples/generated/always/mybatis/GeneratedKey.java

@@ -0,0 +1,29 @@
+/**
+ *    Copyright 2016-2019 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package examples.generated.always.mybatis;
+
+public class GeneratedKey {
+
+    private Integer key;
+
+    public Integer getKey() {
+        return key;
+    }
+
+    public void setKey(Integer key) {
+        this.key = key;
+    }
+}

src/test/java/examples/generated/always/mybatis/GeneratedKeyList.java

@@ -0,0 +1,28 @@
+/**
+ *    Copyright 2016-2019 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package examples.generated.always.mybatis;
+
+import java.util.ArrayList;
+
+
+public class GeneratedKeyList extends ArrayList<GeneratedKey> {
+    
+    public GeneratedKeyList(int estimatedCapacity) {
+        for (int i = 0; i < estimatedCapacity; i++) {
+            add(new GeneratedKey());
+        }
+    }
+}

src/test/java/examples/generated/always/mybatis/PersonDynamicSqlSupport.java

@@ -0,0 +1,38 @@
+/**
+ *    Copyright 2016-2019 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package examples.generated.always.mybatis;
+
+import java.sql.JDBCType;
+
+import org.mybatis.dynamic.sql.SqlColumn;
+import org.mybatis.dynamic.sql.SqlTable;
+
+public final class PersonDynamicSqlSupport {
+    public static final Person person = new Person();
+    public static final SqlColumn<Integer> id = person.id;
+    public static final SqlColumn<String> firstName = person.firstName;
+    public static final SqlColumn<String> lastName = person.lastName;
+    
+    public static final class Person extends SqlTable {
+        public final SqlColumn<Integer> id = column("id", JDBCType.INTEGER);
+        public final SqlColumn<String> firstName = column("first_name", JDBCType.VARCHAR);
+        public final SqlColumn<String> lastName = column("last_name", JDBCType.VARCHAR);
+
+        public Person() {
+            super("Person");
+        }
+    }
+}

src/test/java/examples/generated/always/mybatis/PersonMapper.java

@@ -0,0 +1,68 @@
+/**
+ *    Copyright 2016-2019 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package examples.generated.always.mybatis;
+
+import java.util.List;
+import java.util.Map;
+
+import org.apache.ibatis.annotations.Insert;
+import org.apache.ibatis.annotations.InsertProvider;
+import org.apache.ibatis.annotations.Options;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.SelectProvider;
+import org.mybatis.dynamic.sql.insert.render.InsertSelectStatementProvider;
+import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
+import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider;
+import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
+import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
+
+import examples.generated.always.PersonRecord;
+
+public interface PersonMapper {
+
+    @InsertProvider(type = SqlProviderAdapter.class, method = "insertSelect")
+    @Options(useGeneratedKeys = true, keyProperty = "parameters.id")
+    int insertSelect(InsertSelectStatementProvider insertSelectStatement);
+
+    @InsertProvider(type = SqlProviderAdapter.class, method = "insert")
+    @Options(useGeneratedKeys = true, keyProperty = "record.id")
+    int insert(InsertStatementProvider<PersonRecord> insertStatement);
+    
+    @Insert({
+        "${insertStatement}"
+    })
+    @Options(useGeneratedKeys = true, keyProperty = "records.id")
+    int insertMultiple(@Param("insertStatement") String insertStatement, @Param("records") List<PersonRecord> records);
+
+    default int insertMultiple(MultiRowInsertStatementProvider<PersonRecord> multiRowInsertStatement) {
+        return insertMultiple(multiRowInsertStatement.getInsertStatement(), multiRowInsertStatement.getRecords());
+    }
+    
+    @SelectProvider(type = SqlProviderAdapter.class, method="select")
+    List<PersonRecord> selectMany(SelectStatementProvider selectStatement);
+
+    // insertSelect when there are multiple generated keys expected
+    @Insert({
+        "${insertStatement}"
+    })
+    @Options(useGeneratedKeys = true, keyProperty = "keys.key")
+    int insertSelectMultiple(@Param("insertStatement") String insertStatement, @Param("parameters") Map<String, Object> parameters,
+            @Param("keys") GeneratedKeyList keys);
+
+    default int insertSelect(InsertSelectStatementProvider insertSelectStatement, GeneratedKeyList keys) {
+        return insertSelectMultiple(insertSelectStatement.getInsertStatement(), insertSelectStatement.getParameters(), keys);
+    }
+}

src/test/java/examples/generated/always/mybatis/PersonMapperTest.java

@@ -0,0 +1,171 @@
+/**
+ *    Copyright 2016-2019 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package examples.generated.always.mybatis;
+
+import static examples.generated.always.mybatis.PersonDynamicSqlSupport.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.ibatis.datasource.unpooled.UnpooledDataSource;
+import org.apache.ibatis.jdbc.ScriptRunner;
+import org.apache.ibatis.mapping.Environment;
+import org.apache.ibatis.session.Configuration;
+import org.apache.ibatis.session.SqlSession;
+import org.apache.ibatis.session.SqlSessionFactory;
+import org.apache.ibatis.session.SqlSessionFactoryBuilder;
+import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mybatis.dynamic.sql.SqlBuilder;
+import org.mybatis.dynamic.sql.insert.render.InsertSelectStatementProvider;
+import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
+import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider;
+import org.mybatis.dynamic.sql.render.RenderingStrategies;
+import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
+
+import examples.generated.always.PersonRecord;
+
+public class PersonMapperTest {
+
+    private static final String JDBC_URL = "jdbc:hsqldb:mem:aname";
+    private static final String JDBC_DRIVER = "org.hsqldb.jdbcDriver"; 
+    
+    private SqlSessionFactory sqlSessionFactory;
+    
+    @BeforeEach
+    public void setup() throws Exception {
+        Class.forName(JDBC_DRIVER);
+        InputStream is = getClass().getResourceAsStream("/examples/generated/always/CreateGeneratedAlwaysDB.sql");
+        try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
+            ScriptRunner sr = new ScriptRunner(connection);
+            sr.setLogWriter(null);
+            sr.runScript(new InputStreamReader(is));
+        }
+        
+        UnpooledDataSource ds = new UnpooledDataSource(JDBC_DRIVER, JDBC_URL, "sa", "");
+        Environment environment = new Environment("test", new JdbcTransactionFactory(), ds);
+        Configuration config = new Configuration(environment);
+        config.addMapper(PersonMapper.class);
+        sqlSessionFactory = new SqlSessionFactoryBuilder().build(config);
+    }
+    
+    @Test
+    public void testInsertSelectWithOneRecord() {
+        try (SqlSession session = sqlSessionFactory.openSession()) {
+            PersonMapper mapper = session.getMapper(PersonMapper.class);
+            
+            PersonRecord record = new PersonRecord();
+            record.setFirstName("Fred");
+            record.setLastName("Flintstone");
+            
+            InsertStatementProvider<PersonRecord> insertStatement = SqlBuilder.insert(record)
+                    .into(person)
+                    .map(firstName).toProperty("firstName")
+                    .map(lastName).toProperty("lastName")
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+            
+            int rows = mapper.insert(insertStatement);
+            
+            assertThat(rows).isEqualTo(1);
+            assertThat(record.getId()).isEqualTo(22);
+            
+            InsertSelectStatementProvider insertSelectStatement = SqlBuilder.insertInto(person)
+                    .withColumnList(firstName, lastName)
+                    .withSelectStatement(SqlBuilder.select(firstName, lastName).from(person))
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+            
+            rows = mapper.insertSelect(insertSelectStatement);
+            assertThat(rows).isEqualTo(1);
+            assertThat(insertSelectStatement.getParameters().get("id")).isEqualTo(23);
+            
+            SelectStatementProvider selectStatement = SqlBuilder.select(id, firstName, lastName)
+                    .from(person)
+                    .orderBy(id)
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+            
+            List<PersonRecord> records = mapper.selectMany(selectStatement);
+            assertThat(records.size()).isEqualTo(2);
+            assertThat(records.get(0).getId()).isEqualTo(22);
+            assertThat(records.get(1).getId()).isEqualTo(23);
+        }
+    }
+
+    @Test
+    public void testInsertSelectWithMultipleRecords() {
+        try (SqlSession session = sqlSessionFactory.openSession()) {
+            PersonMapper mapper = session.getMapper(PersonMapper.class);
+            
+            PersonRecord record1 = new PersonRecord();
+            record1.setFirstName("Fred");
+            record1.setLastName("Flintstone");
+            
+            PersonRecord record2 = new PersonRecord();
+            record2.setFirstName("Barney");
+            record2.setLastName("Rubble");
+            
+            MultiRowInsertStatementProvider<PersonRecord> insertStatement = SqlBuilder.insertMultiple(record1, record2)
+                    .into(person)
+                    .map(firstName).toProperty("firstName")
+                    .map(lastName).toProperty("lastName")
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+            
+            int rows = mapper.insertMultiple(insertStatement);
+            
+            assertThat(rows).isEqualTo(2);
+            assertThat(record1.getId()).isEqualTo(22);
+            assertThat(record2.getId()).isEqualTo(23);
+            
+            InsertSelectStatementProvider insertSelectStatement = SqlBuilder.insertInto(person)
+                    .withColumnList(firstName, lastName)
+                    .withSelectStatement(SqlBuilder.select(firstName, lastName).from(person))
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+            
+            insertSelectStatement.getParameters().put("keys", new ArrayList<GeneratedKey>());
+            
+            GeneratedKeyList keys = new GeneratedKeyList(5);
+            
+            rows = mapper.insertSelect(insertSelectStatement, keys);
+            assertThat(rows).isEqualTo(2);
+            System.out.println(keys);
+            assertThat(keys.get(0).getKey()).isEqualTo(24);
+            assertThat(keys.get(1).getKey()).isEqualTo(25);
+            
+            SelectStatementProvider selectStatement = SqlBuilder.select(id, firstName, lastName)
+                    .from(person)
+                    .orderBy(id)
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+            
+            List<PersonRecord> records = mapper.selectMany(selectStatement);
+            assertThat(records.size()).isEqualTo(4);
+            assertThat(records.get(0).getId()).isEqualTo(22);
+            assertThat(records.get(1).getId()).isEqualTo(23);
+            assertThat(records.get(2).getId()).isEqualTo(24);
+            assertThat(records.get(3).getId()).isEqualTo(25);
+        }
+    }
+}