Skip to content

Commit 3ab4104

Browse files
jeffgbutlerjeffgbutler
committed
Better tests
1 parent c1b7c62 commit 3ab4104

File tree

4 files changed

+195
-77
lines changed

4 files changed

+195
-77
lines changed

‎src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertValuePhraseVisitor.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -69,7 +69,7 @@ public <R> FieldAndValueAndParameters visit(ValueMapping<R> mapping) {
6969
}
7070

7171
private Function<SqlColumn<?>, String> toJdbcPlaceholder(String parameterName) {
72-
return column -> renderingStrategy
72+
return column -> column.renderingStrategy().orElse(renderingStrategy)
7373
.getFormattedJdbcPlaceholder(column, RenderingStrategy.DEFAULT_PARAMETER_PREFIX, parameterName);
7474
}
7575
}

‎src/test/java/examples/custom_render/CustomRenderingTest.java‎

Lines changed: 189 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -15,10 +15,20 @@
1515
*/
1616
package examples.custom_render;
1717

18-
import static examples.custom_render.JsonTestDynamicSqlSupport.*;
18+
import static examples.custom_render.JsonTestDynamicSqlSupport.description;
19+
import static examples.custom_render.JsonTestDynamicSqlSupport.id;
20+
import static examples.custom_render.JsonTestDynamicSqlSupport.info;
21+
import static examples.custom_render.JsonTestDynamicSqlSupport.jsonTest;
1922
import static org.assertj.core.api.Assertions.assertThat;
20-
import static org.mybatis.dynamic.sql.SqlBuilder.*;
23+
import static org.mybatis.dynamic.sql.SqlBuilder.deleteFrom;
24+
import static org.mybatis.dynamic.sql.SqlBuilder.insert;
25+
import static org.mybatis.dynamic.sql.SqlBuilder.insertInto;
26+
import static org.mybatis.dynamic.sql.SqlBuilder.insertMultiple;
27+
import static org.mybatis.dynamic.sql.SqlBuilder.isEqualTo;
28+
import static org.mybatis.dynamic.sql.SqlBuilder.select;
29+
import static org.mybatis.dynamic.sql.SqlBuilder.update;
2130

31+
import java.sql.JDBCType;
2232
import java.util.List;
2333
import java.util.Map;
2434
import java.util.Optional;
@@ -32,12 +42,14 @@
3242
import org.junit.jupiter.api.BeforeAll;
3343
import org.junit.jupiter.api.BeforeEach;
3444
import org.junit.jupiter.api.Test;
35-
import org.mybatis.dynamic.sql.SqlBuilder;
3645
import org.mybatis.dynamic.sql.SqlColumn;
37-
import org.mybatis.dynamic.sql.delete.DeleteDSLCompleter;
46+
import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
47+
import org.mybatis.dynamic.sql.insert.render.GeneralInsertStatementProvider;
48+
import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
49+
import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider;
3850
import org.mybatis.dynamic.sql.render.RenderingStrategies;
39-
import org.mybatis.dynamic.sql.select.SelectDSLCompleter;
4051
import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
52+
import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
4153
import org.testcontainers.junit.jupiter.Container;
4254
import org.testcontainers.junit.jupiter.Testcontainers;
4355

@@ -64,33 +76,105 @@ void resetDatabase() {
6476
try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
6577
JsonTestMapper mapper = sqlSession.getMapper(JsonTestMapper.class);
6678

67-
mapper.delete(DeleteDSLCompleter.allRows());
79+
DeleteStatementProvider deleteStatement = deleteFrom(jsonTest).build().render(RenderingStrategies.MYBATIS3);
80+
81+
mapper.delete(deleteStatement);
6882
}
6983
}
7084

7185
@Test
72-
void testInsert() {
86+
void testInsertRecord() {
7387
try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
7488
JsonTestMapper mapper = sqlSession.getMapper(JsonTestMapper.class);
7589

7690
JsonTestRecord record = new JsonTestRecord();
7791
record.setId(1);
7892
record.setDescription("Fred");
7993
record.setInfo("{\"firstName\": \"Fred\", \"lastName\": \"Flintstone\", \"age\": 30}");
94+
95+
InsertStatementProvider<JsonTestRecord> insertStatement = insert(record).into(jsonTest)
96+
.map(id).toProperty("id")
97+
.map(description).toProperty("description")
98+
.map(info).toProperty("info")
99+
.build()
100+
.render(RenderingStrategies.MYBATIS3);
101+
102+
String expected = "insert into JsonTest (id, description, info) "
103+
+ "values (#{record.id,jdbcType=INTEGER}, #{record.description,jdbcType=VARCHAR}, "
104+
+ "#{record.info,jdbcType=VARCHAR}::json)";
105+
106+
assertThat(insertStatement.getInsertStatement()).isEqualTo(expected);
80107

81-
int rows = mapper.insert(record);
108+
int rows = mapper.insert(insertStatement);
82109
assertThat(rows).isEqualTo(1);
83110

84111
record = new JsonTestRecord();
85112
record.setId(2);
86113
record.setDescription("Wilma");
87114
record.setInfo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}");
88115

89-
rows = mapper.insert(record);
116+
insertStatement = insert(record).into(jsonTest)
117+
.map(id).toProperty("id")
118+
.map(description).toProperty("description")
119+
.map(info).toProperty("info")
120+
.build()
121+
.render(RenderingStrategies.MYBATIS3);
122+
123+
rows = mapper.insert(insertStatement);
90124
assertThat(rows).isEqualTo(1);
91125

92-
List<JsonTestRecord> records = mapper.selectMany(SelectDSLCompleter.allRowsOrderedBy(id));
93-
assertThat(records.size()).isEqualTo(2);
126+
SelectStatementProvider selectStatement = select(id, description, info)
127+
.from(jsonTest)
128+
.orderBy(id)
129+
.build()
130+
.render(RenderingStrategies.MYBATIS3);
131+
132+
List<JsonTestRecord> records = mapper.selectMany(selectStatement);
133+
assertThat(records).hasSize(2);
134+
assertThat(records.get(0).getInfo()).isEqualTo("{\"firstName\": \"Fred\", \"lastName\": \"Flintstone\", \"age\": 30}");
135+
assertThat(records.get(1).getInfo()).isEqualTo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}");
136+
}
137+
}
138+
139+
@Test
140+
void testGeneralInsert() {
141+
try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
142+
JsonTestMapper mapper = sqlSession.getMapper(JsonTestMapper.class);
143+
144+
GeneralInsertStatementProvider insertStatement = insertInto(jsonTest)
145+
.set(id).toValue(1)
146+
.set(description).toValue("Fred")
147+
.set(info).toValue("{\"firstName\": \"Fred\", \"lastName\": \"Flintstone\", \"age\": 30}")
148+
.build()
149+
.render(RenderingStrategies.MYBATIS3);
150+
151+
String expected = "insert into JsonTest (id, description, info) "
152+
+ "values (#{parameters.p1,jdbcType=INTEGER}, #{parameters.p2,jdbcType=VARCHAR}, "
153+
+ "#{parameters.p3,jdbcType=VARCHAR}::json)";
154+
155+
assertThat(insertStatement.getInsertStatement()).isEqualTo(expected);
156+
157+
int rows = mapper.generalInsert(insertStatement);
158+
assertThat(rows).isEqualTo(1);
159+
160+
insertStatement = insertInto(jsonTest)
161+
.set(id).toValue(2)
162+
.set(description).toValue("Wilma")
163+
.set(info).toValue("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}")
164+
.build()
165+
.render(RenderingStrategies.MYBATIS3);
166+
167+
rows = mapper.generalInsert(insertStatement);
168+
assertThat(rows).isEqualTo(1);
169+
170+
SelectStatementProvider selectStatement = select(id, description, info)
171+
.from(jsonTest)
172+
.orderBy(id)
173+
.build()
174+
.render(RenderingStrategies.MYBATIS3);
175+
176+
List<JsonTestRecord> records = mapper.selectMany(selectStatement);
177+
assertThat(records).hasSize(2);
94178
assertThat(records.get(0).getInfo()).isEqualTo("{\"firstName\": \"Fred\", \"lastName\": \"Flintstone\", \"age\": 30}");
95179
assertThat(records.get(1).getInfo()).isEqualTo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}");
96180
}
@@ -110,12 +194,34 @@ void testInsertMultiple() {
110194
record2.setId(2);
111195
record2.setDescription("Wilma");
112196
record2.setInfo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}");
197+
198+
MultiRowInsertStatementProvider<JsonTestRecord> insertStatement = insertMultiple(record1, record2)
199+
.into(jsonTest)
200+
.map(id).toProperty("id")
201+
.map(description).toProperty("description")
202+
.map(info).toProperty("info")
203+
.build()
204+
.render(RenderingStrategies.MYBATIS3);
113205

114-
int rows = mapper.insertMultiple(record1, record2);
206+
String expected = "insert into JsonTest (id, description, info) "
207+
+ "values (#{records[0].id,jdbcType=INTEGER}, #{records[0].description,jdbcType=VARCHAR}, "
208+
+ "#{records[0].info,jdbcType=VARCHAR}::json), "
209+
+ "(#{records[1].id,jdbcType=INTEGER}, #{records[1].description,jdbcType=VARCHAR}, "
210+
+ "#{records[1].info,jdbcType=VARCHAR}::json)";
211+
212+
assertThat(insertStatement.getInsertStatement()).isEqualTo(expected);
213+
214+
int rows = mapper.insertMultiple(insertStatement);
115215
assertThat(rows).isEqualTo(2);
116216

117-
List<JsonTestRecord> records = mapper.selectMany(SelectDSLCompleter.allRowsOrderedBy(id));
118-
assertThat(records.size()).isEqualTo(2);
217+
SelectStatementProvider selectStatement = select(id, description, info)
218+
.from(jsonTest)
219+
.orderBy(id)
220+
.build()
221+
.render(RenderingStrategies.MYBATIS3);
222+
223+
List<JsonTestRecord> records = mapper.selectMany(selectStatement);
224+
assertThat(records).hasSize(2);
119225
assertThat(records.get(0).getInfo()).isEqualTo("{\"firstName\": \"Fred\", \"lastName\": \"Flintstone\", \"age\": 30}");
120226
assertThat(records.get(1).getInfo()).isEqualTo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}");
121227
}
@@ -136,17 +242,40 @@ void testUpdate() {
136242
record2.setDescription("Wilma");
137243
record2.setInfo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}");
138244

139-
int rows = mapper.insertMultiple(record1, record2);
245+
MultiRowInsertStatementProvider<JsonTestRecord> insertStatement = insertMultiple(record1, record2)
246+
.into(jsonTest)
247+
.map(id).toProperty("id")
248+
.map(description).toProperty("description")
249+
.map(info).toProperty("info")
250+
.build()
251+
.render(RenderingStrategies.MYBATIS3);
252+
253+
int rows = mapper.insertMultiple(insertStatement);
140254
assertThat(rows).isEqualTo(2);
255+
256+
UpdateStatementProvider updateStatement = update(jsonTest)
257+
.set(info).equalTo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 26}")
258+
.where(id, isEqualTo(2))
259+
.build()
260+
.render(RenderingStrategies.MYBATIS3);
261+
262+
String expected = "update JsonTest "
263+
+ "set info = #{parameters.p1,jdbcType=VARCHAR}::json "
264+
+ "where id = #{parameters.p2,jdbcType=INTEGER}";
141265

142-
rows = mapper.update(c ->
143-
c.set(info).equalTo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 26}")
144-
.where(id, isEqualTo(2))
145-
);
266+
assertThat(updateStatement.getUpdateStatement()).isEqualTo(expected);
267+
268+
rows = mapper.update(updateStatement);
146269
assertThat(rows).isEqualTo(1);
147270

148-
List<JsonTestRecord> records = mapper.selectMany(SelectDSLCompleter.allRowsOrderedBy(id));
149-
assertThat(records.size()).isEqualTo(2);
271+
SelectStatementProvider selectStatement = select(id, description, info)
272+
.from(jsonTest)
273+
.orderBy(id)
274+
.build()
275+
.render(RenderingStrategies.MYBATIS3);
276+
277+
List<JsonTestRecord> records = mapper.selectMany(selectStatement);
278+
assertThat(records).hasSize(2);
150279
assertThat(records.get(0).getInfo()).isEqualTo("{\"firstName\": \"Fred\", \"lastName\": \"Flintstone\", \"age\": 30}");
151280
assertThat(records.get(1).getInfo()).isEqualTo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 26}");
152281
}
@@ -167,11 +296,30 @@ void testDefererence() {
167296
record2.setDescription("Wilma");
168297
record2.setInfo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}");
169298

170-
int rows = mapper.insertMultiple(record1, record2);
299+
MultiRowInsertStatementProvider<JsonTestRecord> insertStatement = insertMultiple(record1, record2)
300+
.into(jsonTest)
301+
.map(id).toProperty("id")
302+
.map(description).toProperty("description")
303+
.map(info).toProperty("info")
304+
.build()
305+
.render(RenderingStrategies.MYBATIS3);
306+
307+
int rows = mapper.insertMultiple(insertStatement);
171308
assertThat(rows).isEqualTo(2);
172309

173-
Optional<JsonTestRecord> record = mapper.selectOne(c ->
174-
c.where(dereference(info, "age"), isEqualTo("25")));
310+
SelectStatementProvider selectStatement = select(id, description, info)
311+
.from(jsonTest)
312+
.where(dereference(info, "age"), isEqualTo("25"))
313+
.build()
314+
.render(RenderingStrategies.MYBATIS3);
315+
316+
String expected = "select id, description, info "
317+
+ "from JsonTest "
318+
+ "where info->>'age' = #{parameters.p1,jdbcType=VARCHAR}";
319+
320+
assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
321+
322+
Optional<JsonTestRecord> record = mapper.selectOne(selectStatement);
175323

176324
assertThat(record).hasValueSatisfying( c ->
177325
c.getInfo().equals("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}"));
@@ -193,22 +341,36 @@ void testDefererence2() {
193341
record2.setDescription("Wilma");
194342
record2.setInfo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}");
195343

196-
int rows = mapper.insertMultiple(record1, record2);
344+
MultiRowInsertStatementProvider<JsonTestRecord> insertStatement = insertMultiple(record1, record2)
345+
.into(jsonTest)
346+
.map(id).toProperty("id")
347+
.map(description).toProperty("description")
348+
.map(info).toProperty("info")
349+
.build()
350+
.render(RenderingStrategies.MYBATIS3);
351+
352+
int rows = mapper.insertMultiple(insertStatement);
197353
assertThat(rows).isEqualTo(2);
198354

199-
SelectStatementProvider selectStatement = SqlBuilder.select(dereference(info, "firstName").as("firstname"))
355+
SelectStatementProvider selectStatement = select(dereference(info, "firstName").as("firstname"))
200356
.from(jsonTest)
201357
.where(dereference(info, "age"), isEqualTo("25"))
202358
.build()
203359
.render(RenderingStrategies.MYBATIS3);
204360

361+
String expected = "select info->>'firstName' as firstname "
362+
+ "from JsonTest "
363+
+ "where info->>'age' = #{parameters.p1,jdbcType=VARCHAR}";
364+
365+
assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
366+
205367
List<Map<String, Object>> records = mapper.generalSelect(selectStatement);
206368
assertThat(records).hasSize(1);
207369
assertThat(records.get(0)).containsEntry("firstname", "Wilma");
208370
}
209371
}
210372

211373
private <T> SqlColumn<String> dereference(SqlColumn<T> column, String attribute) {
212-
return SqlColumn.of(column.name() + "->>'" + attribute + "'", column.table());
374+
return SqlColumn.of(column.name() + "->>'" + attribute + "'", column.table(), JDBCType.VARCHAR);
213375
}
214376
}

‎src/test/java/examples/custom_render/JsonTestDynamicSqlSupport.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -32,4 +32,4 @@ public JsonTest() {
3232
super("JsonTest");
3333
}
3434
}
35-
}
35+
}

0 commit comments

Comments
 (0)