Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactor AssertJ assertions into more idiomatic ones

Browse Source 
This commit refactors some AssertJ assertions into more idiomatic and
readable ones. Using the dedicated assertion instead of a generic one
will produce more meaningful error messages. 

For instance, consider collection size:
```
// expected: 5 but was: 2
assertThat(collection.size()).equals(5);
// Expected size: 5 but was: 2 in: [1, 2]
assertThat(collection).hasSize(5);
```

Closes gh-30104
This commit is contained in:
Krzysztof Krasoń
2023-04-04 17:34:07 +02:00
committed by GitHub
parent dd97ee4e99
commit 1734deca1e
371 changed files with 3177 additions and 3076 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
spring-jdbc/src/test/java/org/springframework/jdbc/config/JdbcNamespaceIntegrationTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2020 the original author or authors.
* Copyright 2002-2023 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.
@@ -184,7 +184,7 @@ class JdbcNamespaceIntegrationTests {
for (String dataSourceName : dataSources) {
DataSource dataSource = context.getBean(dataSourceName, DataSource.class);
assertNumRowsInTestTable(new JdbcTemplate(dataSource), count);
assertThat(dataSource instanceof AbstractDriverBasedDataSource).isTrue();
assertThat(dataSource).isInstanceOf(AbstractDriverBasedDataSource.class);
AbstractDriverBasedDataSource adbDataSource = (AbstractDriverBasedDataSource) dataSource;
assertThat(adbDataSource.getUrl()).contains(dataSourceName);
}
@@ -195,7 +195,7 @@ class JdbcNamespaceIntegrationTests {
try (ConfigurableApplicationContext context = context(file)) {
DataSource dataSource = context.getBean(DataSource.class);
assertNumRowsInTestTable(new JdbcTemplate(dataSource), 1);
assertThat(dataSource instanceof AbstractDriverBasedDataSource).isTrue();
assertThat(dataSource).isInstanceOf(AbstractDriverBasedDataSource.class);
AbstractDriverBasedDataSource adbDataSource = (AbstractDriverBasedDataSource) dataSource;
assertThat(urlPredicate.test(adbDataSource.getUrl())).isTrue();
}

22
spring-jdbc/src/test/java/org/springframework/jdbc/core/JdbcTemplateQueryTests.java
View File

@@ -84,7 +84,7 @@ public class JdbcTemplateQueryTests {
given(this.resultSet.next()).willReturn(true, true, false);
given(this.resultSet.getObject(1)).willReturn(11, 12);
List<Map<String, Object>> li = this.template.queryForList(sql);
assertThat(li.size()).as("All rows returned").isEqualTo(2);
assertThat(li).as("All rows returned").hasSize(2);
assertThat(((Integer) li.get(0).get("age")).intValue()).as("First row is Integer").isEqualTo(11);
assertThat(((Integer) li.get(1).get("age")).intValue()).as("Second row is Integer").isEqualTo(12);
verify(this.resultSet).close();
@@ -96,7 +96,7 @@ public class JdbcTemplateQueryTests {
String sql = "SELECT AGE FROM CUSTMR WHERE ID < 3";
given(this.resultSet.next()).willReturn(false);
List<Map<String, Object>> li = this.template.queryForList(sql);
assertThat(li.size()).as("All rows returned").isEqualTo(0);
assertThat(li).as("All rows returned").isEmpty();
verify(this.resultSet).close();
verify(this.statement).close();
}
@@ -107,7 +107,7 @@ public class JdbcTemplateQueryTests {
given(this.resultSet.next()).willReturn(true, false);
given(this.resultSet.getObject(1)).willReturn(11);
List<Map<String, Object>> li = this.template.queryForList(sql);
assertThat(li.size()).as("All rows returned").isEqualTo(1);
assertThat(li).as("All rows returned").hasSize(1);
assertThat(((Integer) li.get(0).get("age")).intValue()).as("First row is Integer").isEqualTo(11);
verify(this.resultSet).close();
verify(this.statement).close();
@@ -119,7 +119,7 @@ public class JdbcTemplateQueryTests {
given(this.resultSet.next()).willReturn(true, false);
given(this.resultSet.getInt(1)).willReturn(11);
List<Integer> li = this.template.queryForList(sql, Integer.class);
assertThat(li.size()).as("All rows returned").isEqualTo(1);
assertThat(li).as("All rows returned").hasSize(1);
assertThat(li.get(0).intValue()).as("Element is Integer").isEqualTo(11);
verify(this.resultSet).close();
verify(this.statement).close();
@@ -153,7 +153,7 @@ public class JdbcTemplateQueryTests {
given(this.resultSet.next()).willReturn(true, false);
given(this.resultSet.getInt(1)).willReturn(22);
Object o = this.template.queryForObject(sql, (RowMapper<Integer>) (rs, rowNum) -> rs.getInt(1));
assertThat(o instanceof Integer).as("Correct result type").isTrue();
assertThat(o).as("Correct result type").isInstanceOf(Integer.class);
verify(this.resultSet).close();
verify(this.statement).close();
}
@@ -284,7 +284,7 @@ public class JdbcTemplateQueryTests {
given(this.resultSet.next()).willReturn(true, true, false);
given(this.resultSet.getObject(1)).willReturn(11, 12);
List<Map<String, Object>> li = this.template.queryForList(sql, 3);
assertThat(li.size()).as("All rows returned").isEqualTo(2);
assertThat(li).as("All rows returned").hasSize(2);
assertThat(((Integer) li.get(0).get("age")).intValue()).as("First row is Integer").isEqualTo(11);
assertThat(((Integer) li.get(1).get("age")).intValue()).as("Second row is Integer").isEqualTo(12);
verify(this.preparedStatement).setObject(1, 3);
@@ -297,7 +297,7 @@ public class JdbcTemplateQueryTests {
String sql = "SELECT AGE FROM CUSTMR WHERE ID < ?";
given(this.resultSet.next()).willReturn(false);
List<Map<String, Object>> li = this.template.queryForList(sql, 3);
assertThat(li.size()).as("All rows returned").isEqualTo(0);
assertThat(li).as("All rows returned").isEmpty();
verify(this.preparedStatement).setObject(1, 3);
verify(this.resultSet).close();
verify(this.preparedStatement).close();
@@ -309,7 +309,7 @@ public class JdbcTemplateQueryTests {
given(this.resultSet.next()).willReturn(true, false);
given(this.resultSet.getObject(1)).willReturn(11);
List<Map<String, Object>> li = this.template.queryForList(sql, 3);
assertThat(li.size()).as("All rows returned").isEqualTo(1);
assertThat(li).as("All rows returned").hasSize(1);
assertThat(((Integer) li.get(0).get("age")).intValue()).as("First row is Integer").isEqualTo(11);
verify(this.preparedStatement).setObject(1, 3);
verify(this.resultSet).close();
@@ -322,7 +322,7 @@ public class JdbcTemplateQueryTests {
given(this.resultSet.next()).willReturn(true, false);
given(this.resultSet.getInt(1)).willReturn(11);
List<Integer> li = this.template.queryForList(sql, Integer.class, 3);
assertThat(li.size()).as("All rows returned").isEqualTo(1);
assertThat(li).as("All rows returned").hasSize(1);
assertThat(li.get(0).intValue()).as("First row is Integer").isEqualTo(11);
verify(this.preparedStatement).setObject(1, 3);
verify(this.resultSet).close();
@@ -347,7 +347,7 @@ public class JdbcTemplateQueryTests {
given(this.resultSet.next()).willReturn(true, false);
given(this.resultSet.getInt(1)).willReturn(22);
Object o = this.template.queryForObject(sql, (rs, rowNum) -> rs.getInt(1), 3);
assertThat(o instanceof Integer).as("Correct result type").isTrue();
assertThat(o).as("Correct result type").isInstanceOf(Integer.class);
verify(this.preparedStatement).setObject(1, 3);
verify(this.resultSet).close();
verify(this.preparedStatement).close();
@@ -377,7 +377,7 @@ public class JdbcTemplateQueryTests {
given(this.resultSet.next()).willReturn(true, false);
given(this.resultSet.getInt(1)).willReturn(22);
Object o = this.template.queryForObject(sql, Integer.class, 3);
assertThat(o instanceof Integer).as("Correct result type").isTrue();
assertThat(o).as("Correct result type").isInstanceOf(Integer.class);
verify(this.preparedStatement).setObject(1, 3);
verify(this.resultSet).close();
verify(this.preparedStatement).close();

38
spring-jdbc/src/test/java/org/springframework/jdbc/core/JdbcTemplateTests.java
View File

@@ -106,7 +106,7 @@ public class JdbcTemplateTests {
@Test
public void testBeanProperties() throws Exception {
assertThat(this.template.getDataSource() == this.dataSource).as("datasource ok").isTrue();
assertThat(this.template.getDataSource()).as("datasource ok").isSameAs(this.dataSource);
assertThat(this.template.isIgnoreWarnings()).as("ignores warnings by default").isTrue();
this.template.setIgnoreWarnings(false);
boolean condition = !this.template.isIgnoreWarnings();
@@ -120,7 +120,7 @@ public class JdbcTemplateTests {
given(this.preparedStatement.executeUpdate()).willReturn(1);
Dispatcher d = new Dispatcher(idParam, sql);
int rowsAffected = this.template.update(d);
assertThat(rowsAffected == 1).as("1 update affected 1 row").isTrue();
assertThat(rowsAffected).as("1 update affected 1 row").isEqualTo(1);
verify(this.preparedStatement).setInt(1, idParam);
verify(this.preparedStatement).close();
verify(this.connection).close();
@@ -219,9 +219,9 @@ public class JdbcTemplateTests {
// Match
String[] forenames = sh.getStrings();
assertThat(forenames.length == results.length).as("same length").isTrue();
assertThat(forenames).as("same length").hasSameSizeAs(results);
for (int i = 0; i < forenames.length; i++) {
assertThat(forenames[i].equals(results[i])).as("Row " + i + " matches").isTrue();
assertThat(forenames[i]).as("Row " + i + " matches").isEqualTo(results[i]);
}
if (fetchSize != null) {
@@ -263,7 +263,7 @@ public class JdbcTemplateTests {
@Test
public void testConnectionCallback() throws Exception {
String result = this.template.execute((ConnectionCallback<String>) con -> {
assertThat(con instanceof ConnectionProxy).isTrue();
assertThat(con).isInstanceOf(ConnectionProxy.class);
assertThat(((ConnectionProxy) con).getTargetConnection()).isSameAs(JdbcTemplateTests.this.connection);
return "test";
});
@@ -340,7 +340,7 @@ public class JdbcTemplateTests {
given(this.connection.createStatement()).willReturn(this.statement);
int actualRowsAffected = this.template.update(sql);
assertThat(actualRowsAffected == rowsAffected).as("Actual rows affected is correct").isTrue();
assertThat(actualRowsAffected).as("Actual rows affected is correct").isEqualTo(rowsAffected);
verify(this.statement).close();
verify(this.connection).close();
}
@@ -356,7 +356,7 @@ public class JdbcTemplateTests {
int actualRowsAffected = this.template.update(sql,
4, new SqlParameterValue(Types.NUMERIC, 2, 1.4142f));
assertThat(actualRowsAffected == rowsAffected).as("Actual rows affected is correct").isTrue();
assertThat(actualRowsAffected).as("Actual rows affected is correct").isEqualTo(rowsAffected);
verify(this.preparedStatement).setObject(1, 4);
verify(this.preparedStatement).setObject(2, 1.4142f, Types.NUMERIC, 2);
verify(this.preparedStatement).close();
@@ -387,7 +387,7 @@ public class JdbcTemplateTests {
given(this.connection.createStatement()).willReturn(this.statement);
int actualRowsAffected = this.template.update(sql);
assertThat(actualRowsAffected == rowsAffected).as("Actual rows affected is correct").isTrue();
assertThat(actualRowsAffected).as("Actual rows affected is correct").isEqualTo(rowsAffected);
verify(this.statement).close();
verify(this.connection).close();
@@ -405,7 +405,7 @@ public class JdbcTemplateTests {
JdbcTemplate template = new JdbcTemplate(this.dataSource, false);
int[] actualRowsAffected = template.batchUpdate(sql);
assertThat(actualRowsAffected.length == 2).as("executed 2 updates").isTrue();
assertThat(actualRowsAffected).as("executed 2 updates").hasSize(2);
verify(this.statement).addBatch(sql[0]);
verify(this.statement).addBatch(sql[1]);
@@ -445,7 +445,7 @@ public class JdbcTemplateTests {
JdbcTemplate template = new JdbcTemplate(this.dataSource, false);
int[] actualRowsAffected = template.batchUpdate(sql);
assertThat(actualRowsAffected.length == 2).as("executed 2 updates").isTrue();
assertThat(actualRowsAffected).as("executed 2 updates").hasSize(2);
verify(this.statement, never()).addBatch(anyString());
verify(this.statement).close();
@@ -494,7 +494,7 @@ public class JdbcTemplateTests {
JdbcTemplate template = new JdbcTemplate(this.dataSource, false);
int[] actualRowsAffected = template.batchUpdate(sql, setter);
assertThat(actualRowsAffected.length == 2).as("executed 2 updates").isTrue();
assertThat(actualRowsAffected).as("executed 2 updates").hasSize(2);
assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected[0]);
assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);
@@ -535,7 +535,7 @@ public class JdbcTemplateTests {
JdbcTemplate template = new JdbcTemplate(this.dataSource, false);
int[] actualRowsAffected = template.batchUpdate(sql, setter);
assertThat(actualRowsAffected.length == 2).as("executed 2 updates").isTrue();
assertThat(actualRowsAffected).as("executed 2 updates").hasSize(2);
assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected[0]);
assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);
@@ -572,7 +572,7 @@ public class JdbcTemplateTests {
JdbcTemplate template = new JdbcTemplate(this.dataSource, false);
int[] actualRowsAffected = template.batchUpdate(sql, setter);
assertThat(actualRowsAffected.length == 2).as("executed 2 updates").isTrue();
assertThat(actualRowsAffected).as("executed 2 updates").hasSize(2);
assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected[0]);
assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);
@@ -609,7 +609,7 @@ public class JdbcTemplateTests {
JdbcTemplate template = new JdbcTemplate(this.dataSource, false);
int[] actualRowsAffected = template.batchUpdate(sql, setter);
assertThat(actualRowsAffected.length == 2).as("executed 2 updates").isTrue();
assertThat(actualRowsAffected).as("executed 2 updates").hasSize(2);
assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected[0]);
assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);
@@ -640,7 +640,7 @@ public class JdbcTemplateTests {
};
int[] actualRowsAffected = this.template.batchUpdate(sql, setter);
assertThat(actualRowsAffected.length == 2).as("executed 2 updates").isTrue();
assertThat(actualRowsAffected).as("executed 2 updates").hasSize(2);
assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected[0]);
assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);
@@ -691,7 +691,7 @@ public class JdbcTemplateTests {
JdbcTemplate template = new JdbcTemplate(this.dataSource, false);
int[] actualRowsAffected = template.batchUpdate(sql, Collections.emptyList());
assertThat(actualRowsAffected.length == 0).as("executed 0 updates").isTrue();
assertThat(actualRowsAffected).as("executed 0 updates").isEmpty();
}
@Test
@@ -707,7 +707,7 @@ public class JdbcTemplateTests {
JdbcTemplate template = new JdbcTemplate(this.dataSource, false);
int[] actualRowsAffected = template.batchUpdate(sql, ids);
assertThat(actualRowsAffected.length == 2).as("executed 2 updates").isTrue();
assertThat(actualRowsAffected).as("executed 2 updates").hasSize(2);
assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected[0]);
assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);
@@ -732,7 +732,7 @@ public class JdbcTemplateTests {
this.template = new JdbcTemplate(this.dataSource, false);
int[] actualRowsAffected = this.template.batchUpdate(sql, ids, sqlTypes);
assertThat(actualRowsAffected.length == 2).as("executed 2 updates").isTrue();
assertThat(actualRowsAffected).as("executed 2 updates").hasSize(2);
assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected[0]);
assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);
verify(this.preparedStatement, times(2)).addBatch();
@@ -756,7 +756,7 @@ public class JdbcTemplateTests {
JdbcTemplate template = new JdbcTemplate(this.dataSource, false);
int[][] actualRowsAffected = template.batchUpdate(sql, ids, 2, setter);
assertThat(actualRowsAffected[0].length).as("executed 2 updates").isEqualTo(2);
assertThat(actualRowsAffected[0]).as("executed 2 updates").hasSize(2);
assertThat(actualRowsAffected[0][0]).isEqualTo(rowsAffected1[0]);
assertThat(actualRowsAffected[0][1]).isEqualTo(rowsAffected1[1]);
assertThat(actualRowsAffected[1][0]).isEqualTo(rowsAffected2[0]);

40
spring-jdbc/src/test/java/org/springframework/jdbc/core/namedparam/NamedParameterJdbcTemplateTests.java
View File

@@ -228,8 +228,8 @@ public class NamedParameterJdbcTemplateTests {
return cust1;
});
assertThat(cust.getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(cust.getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
assertThat(cust.getId()).as("Customer id was assigned correctly").isEqualTo(1);
assertThat(cust.getForename()).as("Customer forename was assigned correctly").isEqualTo("rod");
verify(connection).prepareStatement(SELECT_NAMED_PARAMETERS_PARSED);
verify(preparedStatement).setObject(1, 1, Types.DECIMAL);
verify(preparedStatement).setString(2, "UK");
@@ -253,8 +253,8 @@ public class NamedParameterJdbcTemplateTests {
return cust1;
});
assertThat(cust.getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(cust.getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
assertThat(cust.getId()).as("Customer id was assigned correctly").isEqualTo(1);
assertThat(cust.getForename()).as("Customer forename was assigned correctly").isEqualTo("rod");
verify(connection).prepareStatement(SELECT_NO_PARAMETERS);
verify(resultSet).close();
verify(preparedStatement).close();
@@ -278,8 +278,8 @@ public class NamedParameterJdbcTemplateTests {
});
assertThat(customers).hasSize(1);
assertThat(customers.get(0).getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(customers.get(0).getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
assertThat(customers.get(0).getId()).as("Customer id was assigned correctly").isEqualTo(1);
assertThat(customers.get(0).getForename()).as("Customer forename was assigned correctly").isEqualTo("rod");
verify(connection).prepareStatement(SELECT_NAMED_PARAMETERS_PARSED);
verify(preparedStatement).setObject(1, 1, Types.DECIMAL);
verify(preparedStatement).setString(2, "UK");
@@ -303,8 +303,8 @@ public class NamedParameterJdbcTemplateTests {
});
assertThat(customers).hasSize(1);
assertThat(customers.get(0).getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(customers.get(0).getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
assertThat(customers.get(0).getId()).as("Customer id was assigned correctly").isEqualTo(1);
assertThat(customers.get(0).getForename()).as("Customer forename was assigned correctly").isEqualTo("rod");
verify(connection).prepareStatement(SELECT_NO_PARAMETERS);
verify(resultSet).close();
verify(preparedStatement).close();
@@ -328,8 +328,8 @@ public class NamedParameterJdbcTemplateTests {
});
assertThat(customers).hasSize(1);
assertThat(customers.get(0).getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(customers.get(0).getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
assertThat(customers.get(0).getId()).as("Customer id was assigned correctly").isEqualTo(1);
assertThat(customers.get(0).getForename()).as("Customer forename was assigned correctly").isEqualTo("rod");
verify(connection).prepareStatement(SELECT_NAMED_PARAMETERS_PARSED);
verify(preparedStatement).setObject(1, 1, Types.DECIMAL);
verify(preparedStatement).setString(2, "UK");
@@ -353,8 +353,8 @@ public class NamedParameterJdbcTemplateTests {
});
assertThat(customers).hasSize(1);
assertThat(customers.get(0).getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(customers.get(0).getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
assertThat(customers.get(0).getId()).as("Customer id was assigned correctly").isEqualTo(1);
assertThat(customers.get(0).getForename()).as("Customer forename was assigned correctly").isEqualTo("rod");
verify(connection).prepareStatement(SELECT_NO_PARAMETERS);
verify(resultSet).close();
verify(preparedStatement).close();
@@ -378,8 +378,8 @@ public class NamedParameterJdbcTemplateTests {
return cust1;
});
assertThat(cust.getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(cust.getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
assertThat(cust.getId()).as("Customer id was assigned correctly").isEqualTo(1);
assertThat(cust.getForename()).as("Customer forename was assigned correctly").isEqualTo("rod");
verify(connection).prepareStatement(SELECT_NAMED_PARAMETERS_PARSED);
verify(preparedStatement).setObject(1, 1, Types.DECIMAL);
verify(preparedStatement).setString(2, "UK");
@@ -407,8 +407,8 @@ public class NamedParameterJdbcTemplateTests {
})) {
s.forEach(cust -> {
count.incrementAndGet();
assertThat(cust.getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(cust.getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
assertThat(cust.getId()).as("Customer id was assigned correctly").isEqualTo(1);
assertThat(cust.getForename()).as("Customer forename was assigned correctly").isEqualTo("rod");
});
}
@@ -467,7 +467,7 @@ public class NamedParameterJdbcTemplateTests {
int[] actualRowsAffected = namedParameterTemplate.batchUpdate(
"UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = :id", ids);
assertThat(actualRowsAffected.length == 2).as("executed 2 updates").isTrue();
assertThat(actualRowsAffected.length).as("executed 2 updates").isEqualTo(2);
assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected[0]);
assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);
verify(connection).prepareStatement("UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = ?");
@@ -486,7 +486,7 @@ public class NamedParameterJdbcTemplateTests {
int[] actualRowsAffected = namedParameterTemplate.batchUpdate(
"UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = :id", ids);
assertThat(actualRowsAffected.length == 0).as("executed 0 updates").isTrue();
assertThat(actualRowsAffected.length).as("executed 0 updates").isEqualTo(0);
}
@Test
@@ -502,7 +502,7 @@ public class NamedParameterJdbcTemplateTests {
int[] actualRowsAffected = namedParameterTemplate.batchUpdate(
"UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = :id", ids);
assertThat(actualRowsAffected.length == 2).as("executed 2 updates").isTrue();
assertThat(actualRowsAffected.length).as("executed 2 updates").isEqualTo(2);
assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected[0]);
assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);
verify(connection).prepareStatement("UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = ?");
@@ -567,7 +567,7 @@ public class NamedParameterJdbcTemplateTests {
int[] actualRowsAffected = namedParameterTemplate.batchUpdate(
"UPDATE NOSUCHTABLE SET DATE_DISPATCHED = SYSDATE WHERE ID = :id", ids);
assertThat(actualRowsAffected.length == 3).as("executed 3 updates").isTrue();
assertThat(actualRowsAffected.length).as("executed 3 updates").isEqualTo(3);
assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected[0]);
assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);
assertThat(actualRowsAffected[2]).isEqualTo(rowsAffected[2]);

6
spring-jdbc/src/test/java/org/springframework/jdbc/core/simple/CallMetaDataContextTests.java
View File

@@ -91,17 +91,17 @@ public class CallMetaDataContextTests {
context.processParameters(parameters);
Map<String, Object> inParameters = context.matchInParameterValuesWithCallParameters(parameterSource);
assertThat(inParameters.size()).as("Wrong number of matched in parameter values").isEqualTo(2);
assertThat(inParameters).as("Wrong number of matched in parameter values").hasSize(2);
assertThat(inParameters.containsKey("id")).as("in parameter value missing").isTrue();
assertThat(inParameters.containsKey("name")).as("in out parameter value missing").isTrue();
boolean condition = !inParameters.containsKey("customer_no");
assertThat(condition).as("out parameter value matched").isTrue();
List<String> names = context.getOutParameterNames();
assertThat(names.size()).as("Wrong number of out parameters").isEqualTo(2);
assertThat(names).as("Wrong number of out parameters").hasSize(2);
List<SqlParameter> callParameters = context.getCallParameters();
assertThat(callParameters.size()).as("Wrong number of call parameters").isEqualTo(3);
assertThat(callParameters).as("Wrong number of call parameters").hasSize(3);
}
}

4
spring-jdbc/src/test/java/org/springframework/jdbc/core/support/JdbcDaoSupportTests.java
View File

@@ -48,7 +48,7 @@ public class JdbcDaoSupportTests {
dao.afterPropertiesSet();
assertThat(dao.getDataSource()).as("Correct DataSource").isEqualTo(ds);
assertThat(dao.getJdbcTemplate().getDataSource()).as("Correct JdbcTemplate").isEqualTo(ds);
assertThat(test.size()).as("initDao called").isEqualTo(1);
assertThat(test).as("initDao called").hasSize(1);
}
@Test
@@ -64,7 +64,7 @@ public class JdbcDaoSupportTests {
dao.setJdbcTemplate(template);
dao.afterPropertiesSet();
assertThat(template).as("Correct JdbcTemplate").isEqualTo(dao.getJdbcTemplate());
assertThat(test.size()).as("initDao called").isEqualTo(1);
assertThat(test).as("initDao called").hasSize(1);
}
}

2
spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java
View File

@@ -1736,7 +1736,7 @@ public class DataSourceTransactionManagerTests {
protected void doAfterCompletion(int status) {
assertThat(this.afterCompletionCalled).isFalse();
this.afterCompletionCalled = true;
assertThat(status == this.status).isTrue();
assertThat(status).isEqualTo(this.status);
assertThat(TransactionSynchronizationManager.hasResource(this.dataSource)).isTrue();
}
}

20
spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DriverManagerDataSourceTests.java
View File

@@ -55,11 +55,11 @@ public class DriverManagerDataSourceTests {
ds.setPassword(pwd);
Connection actualCon = ds.getConnection();
assertThat(actualCon == connection).isTrue();
assertThat(actualCon).isSameAs(connection);
assertThat(ds.getUrl().equals(jdbcUrl)).isTrue();
assertThat(ds.getPassword().equals(pwd)).isTrue();
assertThat(ds.getUsername().equals(uname)).isTrue();
assertThat(ds.getUrl()).isEqualTo(jdbcUrl);
assertThat(ds.getPassword()).isEqualTo(pwd);
assertThat(ds.getUsername()).isEqualTo(uname);
}
@Test
@@ -90,9 +90,9 @@ public class DriverManagerDataSourceTests {
ds.setConnectionProperties(connProps);
Connection actualCon = ds.getConnection();
assertThat(actualCon == connection).isTrue();
assertThat(actualCon).isSameAs(connection);
assertThat(ds.getUrl().equals(jdbcUrl)).isTrue();
assertThat(ds.getUrl()).isEqualTo(jdbcUrl);
}
@Test
@@ -127,11 +127,11 @@ public class DriverManagerDataSourceTests {
ds.setConnectionProperties(connProps);
Connection actualCon = ds.getConnection();
assertThat(actualCon == connection).isTrue();
assertThat(actualCon).isSameAs(connection);
assertThat(ds.getUrl().equals(jdbcUrl)).isTrue();
assertThat(ds.getPassword().equals(pwd)).isTrue();
assertThat(ds.getUsername().equals(uname)).isTrue();
assertThat(ds.getUrl()).isEqualTo(jdbcUrl);
assertThat(ds.getPassword()).isEqualTo(pwd);
assertThat(ds.getUsername()).isEqualTo(uname);
}
@Test

6
spring-jdbc/src/test/java/org/springframework/jdbc/object/BatchSqlUpdateTests.java
View File

@@ -88,16 +88,16 @@ public class BatchSqlUpdateTests {
assertThat(update.getQueueCount()).isEqualTo(0);
if (flushThroughBatchSize) {
assertThat(actualRowsAffected.length == 0).as("flush did not execute updates").isTrue();
assertThat(actualRowsAffected).as("flush did not execute updates").isEmpty();
}
else {
assertThat(actualRowsAffected.length == 2).as("executed 2 updates").isTrue();
assertThat(actualRowsAffected).as("executed 2 updates").hasSize(2);
assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected[0]);
assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);
}
actualRowsAffected = update.getRowsAffected();
assertThat(actualRowsAffected.length == 2).as("executed 2 updates").isTrue();
assertThat(actualRowsAffected).as("executed 2 updates").hasSize(2);
assertThat(actualRowsAffected[0]).isEqualTo(rowsAffected[0]);
assertThat(actualRowsAffected[1]).isEqualTo(rowsAffected[1]);

6
spring-jdbc/src/test/java/org/springframework/jdbc/object/GenericSqlQueryTests.java
View File

@@ -107,10 +107,10 @@ public class GenericSqlQueryTests {
Object[] params = new Object[] {1, "UK"};
queryResults = query.execute(params);
}
assertThat(queryResults.size() == 1).as("Customer was returned correctly").isTrue();
assertThat(queryResults).as("Customer was returned correctly").hasSize(1);
Customer cust = (Customer) queryResults.get(0);
assertThat(cust.getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(cust.getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
assertThat(cust.getId()).as("Customer id was assigned correctly").isEqualTo(1);
assertThat(cust.getForename()).as("Customer forename was assigned correctly").isEqualTo("rod");
verify(resultSet).close();
verify(preparedStatement).setObject(1, 1, Types.INTEGER);

48
spring-jdbc/src/test/java/org/springframework/jdbc/object/SqlQueryTests.java
View File

@@ -111,8 +111,8 @@ public class SqlQueryTests {
@Override
protected Integer mapRow(ResultSet rs, int rownum, @Nullable Object[] params, @Nullable Map<? ,?> context)
throws SQLException {
assertThat(params == null).as("params were null").isTrue();
assertThat(context == null).as("context was null").isTrue();
assertThat(params).as("params were null").isNull();
assertThat(context).as("context was null").isNull();
return rs.getInt(1);
}
};
@@ -221,8 +221,8 @@ public class SqlQueryTests {
CustomerQuery query = new CustomerQuery(dataSource);
Customer cust = query.findCustomer(1, 1);
assertThat(cust.getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(cust.getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
assertThat(cust.getId()).as("Customer id was assigned correctly").isEqualTo(1);
assertThat(cust.getForename()).as("Customer forename was assigned correctly").isEqualTo("rod");
verify(preparedStatement).setObject(1, 1, Types.NUMERIC);
verify(preparedStatement).setObject(2, 1, Types.NUMERIC);
verify(connection).prepareStatement(SELECT_ID_WHERE);
@@ -261,8 +261,8 @@ public class SqlQueryTests {
CustomerQuery query = new CustomerQuery(dataSource);
Customer cust = query.findCustomer("rod");
assertThat(cust.getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(cust.getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
assertThat(cust.getId()).as("Customer id was assigned correctly").isEqualTo(1);
assertThat(cust.getForename()).as("Customer forename was assigned correctly").isEqualTo("rod");
verify(preparedStatement).setString(1, "rod");
verify(connection).prepareStatement(SELECT_ID_FORENAME_WHERE);
verify(resultSet).close();
@@ -307,11 +307,11 @@ public class SqlQueryTests {
CustomerQuery query = new CustomerQuery(dataSource);
Customer cust1 = query.findCustomer(1, "rod");
assertThat(cust1 != null).as("Found customer").isTrue();
assertThat(cust1.getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(cust1).as("Found customer").isNotNull();
assertThat(cust1.getId()).as("Customer id was assigned correctly").isEqualTo(1);
Customer cust2 = query.findCustomer(1, "Roger");
assertThat(cust2 == null).as("No customer found").isTrue();
assertThat(cust2).as("No customer found").isNull();
verify(preparedStatement).setObject(1, 1, Types.INTEGER);
verify(preparedStatement).setString(2, "rod");
@@ -387,7 +387,7 @@ public class SqlQueryTests {
CustomerQuery query = new CustomerQuery(dataSource);
List<Customer> list = query.execute(1, 1);
assertThat(list.size() == 2).as("2 results in list").isTrue();
assertThat(list.size()).as("2 results in list").isEqualTo(2);
assertThat(list.get(0).getForename()).isEqualTo("rod");
assertThat(list.get(1).getForename()).isEqualTo("dave");
verify(preparedStatement).setObject(1, 1, Types.NUMERIC);
@@ -423,7 +423,7 @@ public class SqlQueryTests {
CustomerQuery query = new CustomerQuery(dataSource);
List<Customer> list = query.execute("one");
assertThat(list.size() == 2).as("2 results in list").isTrue();
assertThat(list.size()).as("2 results in list").isEqualTo(2);
assertThat(list.get(0).getForename()).isEqualTo("rod");
assertThat(list.get(1).getForename()).isEqualTo("dave");
verify(preparedStatement).setString(1, "one");
@@ -467,8 +467,8 @@ public class SqlQueryTests {
CustomerQuery query = new CustomerQuery(dataSource);
Customer cust = query.findCustomer(1);
assertThat(cust.getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(cust.getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
assertThat(cust.getId()).as("Customer id was assigned correctly").isEqualTo(1);
assertThat(cust.getForename()).as("Customer forename was assigned correctly").isEqualTo("rod");
verify(preparedStatement).setObject(1, 1, Types.NUMERIC);
verify(resultSet).close();
verify(preparedStatement).close();
@@ -563,8 +563,8 @@ public class SqlQueryTests {
CustomerQuery query = new CustomerQuery(dataSource);
Customer cust = query.findCustomer(1, "UK");
assertThat(cust.getId() == 1).as("Customer id was assigned correctly").isTrue();
assertThat(cust.getForename().equals("rod")).as("Customer forename was assigned correctly").isTrue();
assertThat(cust.getId()).as("Customer id was assigned correctly").isEqualTo(1);
assertThat(cust.getForename()).as("Customer forename was assigned correctly").isEqualTo("rod");
verify(preparedStatement).setObject(1, 1, Types.NUMERIC);
verify(preparedStatement).setString(2, "UK");
verify(resultSet).close();
@@ -613,10 +613,11 @@ public class SqlQueryTests {
List<Customer> cust = query.findCustomers(ids);
assertThat(cust.size()).as("We got two customers back").isEqualTo(2);
assertThat(1).as("First customer id was assigned correctly").isEqualTo(cust.get(0).getId());
assertThat("rod").as("First customer forename was assigned correctly").isEqualTo(cust.get(0).getForename());
assertThat(2).as("Second customer id was assigned correctly").isEqualTo(cust.get(1).getId());
assertThat("juergen").as("Second customer forename was assigned correctly").isEqualTo(cust.get(1).getForename());
assertThat(cust.get(0).getId()).as("First customer id was assigned correctly").isEqualTo(1);
assertThat(cust.get(0).getForename()).as("First customer forename was assigned correctly").isEqualTo("rod");
assertThat(cust.get(1).getId()).as("Second customer id was assigned correctly").isEqualTo(2);
assertThat(cust.get(1).getForename()).as("Second customer forename was assigned correctly")
.isEqualTo("juergen");
verify(preparedStatement).setObject(1, 1, Types.NUMERIC);
verify(preparedStatement).setObject(2, 2, Types.NUMERIC);
verify(resultSet).close();
@@ -662,10 +663,11 @@ public class SqlQueryTests {
List<Customer> cust = query.findCustomers(1);
assertThat(cust.size()).as("We got two customers back").isEqualTo(2);
assertThat(1).as("First customer id was assigned correctly").isEqualTo(cust.get(0).getId());
assertThat("rod").as("First customer forename was assigned correctly").isEqualTo(cust.get(0).getForename());
assertThat(2).as("Second customer id was assigned correctly").isEqualTo(cust.get(1).getId());
assertThat("juergen").as("Second customer forename was assigned correctly").isEqualTo(cust.get(1).getForename());
assertThat(cust.get(0).getId()).as("First customer id was assigned correctly").isEqualTo(1);
assertThat(cust.get(0).getForename()).as("First customer forename was assigned correctly").isEqualTo("rod");
assertThat(cust.get(1).getId()).as("Second customer id was assigned correctly").isEqualTo(2);
assertThat(cust.get(1).getForename()).as("Second customer forename was assigned correctly")
.isEqualTo("juergen");
verify(preparedStatement).setObject(1, 1, Types.NUMERIC);
verify(preparedStatement).setObject(2, 1, Types.NUMERIC);

309
spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java
View File

@@ -89,7 +89,7 @@ public class JdbcTransactionManagerTests {
@AfterEach
public void verifyTransactionSynchronizationManagerState() {
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
assertThat(TransactionSynchronizationManager.getResourceMap()).isEmpty();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
@@ -142,8 +142,9 @@ public class JdbcTransactionManagerTests {
final DataSource dsToUse = (lazyConnection ? new LazyConnectionDataSourceProxy(ds) : ds);
tm = new JdbcTransactionManager(dsToUse);
TransactionTemplate tt = new TransactionTemplate(tm);
assertThat(!TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -169,8 +170,9 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
if (autoCommit && (!lazyConnection || createStatement)) {
InOrder ordered = inOrder(con);
@@ -231,8 +233,9 @@ public class JdbcTransactionManagerTests {
final DataSource dsToUse = (lazyConnection ? new LazyConnectionDataSourceProxy(ds) : ds);
tm = new JdbcTransactionManager(dsToUse);
TransactionTemplate tt = new TransactionTemplate(tm);
assertThat(!TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
final RuntimeException ex = new RuntimeException("Application exception");
assertThatRuntimeException().isThrownBy(() ->
@@ -256,8 +259,9 @@ public class JdbcTransactionManagerTests {
}))
.isEqualTo(ex);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
if (autoCommit && (!lazyConnection || createStatement)) {
InOrder ordered = inOrder(con);
@@ -277,8 +281,9 @@ public class JdbcTransactionManagerTests {
public void testTransactionRollbackOnly() throws Exception {
tm.setTransactionSynchronization(JdbcTransactionManager.SYNCHRONIZATION_NEVER);
TransactionTemplate tt = new TransactionTemplate(tm);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
ConnectionHolder conHolder = new ConnectionHolder(con, true);
TransactionSynchronizationManager.bindResource(ds, conHolder);
@@ -288,8 +293,9 @@ public class JdbcTransactionManagerTests {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(!status.isNewTransaction()).as("Is existing transaction").isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
throw ex;
}
});
@@ -297,14 +303,15 @@ public class JdbcTransactionManagerTests {
}
catch (RuntimeException ex2) {
// expected
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
assertThat(ex2).as("Correct exception thrown").isEqualTo(ex);
}
finally {
TransactionSynchronizationManager.unbindResource(ds);
}
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
}
@Test
@@ -322,8 +329,9 @@ public class JdbcTransactionManagerTests {
if (failEarly) {
tm.setFailEarlyOnGlobalRollbackOnly(true);
}
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition());
TestTransactionSynchronization synch =
@@ -338,18 +346,18 @@ public class JdbcTransactionManagerTests {
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(!status.isNewTransaction()).as("Is existing transaction").isTrue();
assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
assertThat(status.isRollbackOnly()).as("Is not rollback-only").isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
assertThat(!status.isNewTransaction()).as("Is existing transaction").isTrue();
assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
status.setRollbackOnly();
}
});
assertThat(!status.isNewTransaction()).as("Is existing transaction").isTrue();
assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
assertThat(status.isRollbackOnly()).as("Is rollback-only").isTrue();
}
});
@@ -372,7 +380,7 @@ public class JdbcTransactionManagerTests {
}
}
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(synch.beforeCommitCalled).isFalse();
assertThat(synch.beforeCompletionCalled).isTrue();
assertThat(synch.afterCommitCalled).isFalse();
@@ -385,8 +393,9 @@ public class JdbcTransactionManagerTests {
public void testParticipatingTransactionWithIncompatibleIsolationLevel() throws Exception {
tm.setValidateExistingTransaction(true);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() -> {
final TransactionTemplate tt = new TransactionTemplate(tm);
@@ -408,7 +417,7 @@ public class JdbcTransactionManagerTests {
});
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).rollback();
verify(con).close();
}
@@ -418,8 +427,9 @@ public class JdbcTransactionManagerTests {
willThrow(new SQLException("read-only not supported")).given(con).setReadOnly(true);
tm.setValidateExistingTransaction(true);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() -> {
final TransactionTemplate tt = new TransactionTemplate(tm);
@@ -442,15 +452,16 @@ public class JdbcTransactionManagerTests {
});
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).rollback();
verify(con).close();
}
@Test
public void testParticipatingTransactionWithTransactionStartedFromSynch() throws Exception {
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
@@ -476,12 +487,12 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(synch.beforeCommitCalled).isTrue();
assertThat(synch.beforeCompletionCalled).isTrue();
assertThat(synch.afterCommitCalled).isTrue();
assertThat(synch.afterCompletionCalled).isTrue();
assertThat(synch.afterCompletionException instanceof IllegalStateException).isTrue();
assertThat(synch.afterCompletionException).isInstanceOf(IllegalStateException.class);
verify(con, times(2)).commit();
verify(con, times(2)).close();
}
@@ -492,8 +503,9 @@ public class JdbcTransactionManagerTests {
final Connection con2 = mock();
given(ds2.getConnection()).willReturn(con2);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
final TransactionTemplate tt = new TransactionTemplate(tm);
@@ -514,7 +526,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(synch.beforeCommitCalled).isTrue();
assertThat(synch.beforeCompletionCalled).isTrue();
assertThat(synch.afterCommitCalled).isTrue();
@@ -531,8 +543,9 @@ public class JdbcTransactionManagerTests {
JdbcTransactionManager tm2 = new JdbcTransactionManager(ds);
// tm has no synch enabled (used at outer level), tm2 has synch enabled (inner level)
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition());
final TestTransactionSynchronization synch =
@@ -544,18 +557,18 @@ public class JdbcTransactionManagerTests {
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(!status.isNewTransaction()).as("Is existing transaction").isTrue();
assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
assertThat(status.isRollbackOnly()).as("Is not rollback-only").isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
assertThat(!status.isNewTransaction()).as("Is existing transaction").isTrue();
assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
status.setRollbackOnly();
}
});
assertThat(!status.isNewTransaction()).as("Is existing transaction").isTrue();
assertThat(status.isNewTransaction()).as("Is existing transaction").isFalse();
assertThat(status.isRollbackOnly()).as("Is rollback-only").isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
}
@@ -564,7 +577,7 @@ public class JdbcTransactionManagerTests {
tm.commit(ts);
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(synch.beforeCommitCalled).isFalse();
assertThat(synch.beforeCompletionCalled).isTrue();
assertThat(synch.afterCommitCalled).isFalse();
@@ -577,8 +590,9 @@ public class JdbcTransactionManagerTests {
public void testPropagationRequiresNewWithExistingTransaction() throws Exception {
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -604,7 +618,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).rollback();
verify(con).commit();
verify(con, times(2)).close();
@@ -623,9 +637,10 @@ public class JdbcTransactionManagerTests {
final TransactionTemplate tt2 = new TransactionTemplate(tm2);
tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -651,8 +666,8 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse();
verify(con).commit();
verify(con).close();
verify(con2).rollback();
@@ -673,9 +688,10 @@ public class JdbcTransactionManagerTests {
final TransactionTemplate tt2 = new TransactionTemplate(tm2);
tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
assertThatExceptionOfType(CannotCreateTransactionException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@@ -694,8 +710,8 @@ public class JdbcTransactionManagerTests {
}
})).withCause(failure);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.hasResource(ds2)).as("Hasn't thread connection").isFalse();
verify(con).rollback();
verify(con).close();
}
@@ -704,8 +720,9 @@ public class JdbcTransactionManagerTests {
public void testPropagationNotSupportedWithExistingTransaction() throws Exception {
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -717,9 +734,10 @@ public class JdbcTransactionManagerTests {
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection")
.isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
assertThat(!status.isNewTransaction()).as("Isn't new transaction").isTrue();
assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
status.setRollbackOnly();
@@ -731,7 +749,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).commit();
verify(con).close();
}
@@ -740,8 +758,9 @@ public class JdbcTransactionManagerTests {
public void testPropagationNeverWithExistingTransaction() throws Exception {
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@@ -759,7 +778,7 @@ public class JdbcTransactionManagerTests {
}
}));
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).rollback();
verify(con).close();
}
@@ -768,8 +787,9 @@ public class JdbcTransactionManagerTests {
public void testPropagationSupportsAndRequiresNew() throws Exception {
TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -790,7 +810,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).commit();
verify(con).close();
}
@@ -804,8 +824,9 @@ public class JdbcTransactionManagerTests {
final
TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -829,7 +850,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con1).close();
verify(con2).commit();
verify(con2).close();
@@ -844,7 +865,7 @@ public class JdbcTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
tt.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
tt.setReadOnly(true);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
@@ -854,7 +875,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
InOrder ordered = inOrder(con);
ordered.verify(con).setReadOnly(true);
ordered.verify(con).setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
@@ -877,7 +898,7 @@ public class JdbcTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
tt.setReadOnly(true);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
@@ -887,7 +908,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
InOrder ordered = inOrder(con, stmt);
ordered.verify(con).setReadOnly(true);
ordered.verify(con).setAutoCommit(false);
@@ -909,7 +930,7 @@ public class JdbcTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(tm);
tt.setTimeout(timeout);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
try {
tt.execute(new TransactionCallbackWithoutResult() {
@@ -943,7 +964,7 @@ public class JdbcTransactionManagerTests {
}
}
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
if (timeout > 1) {
verify(ps).setQueryTimeout(timeout - 1);
verify(con).commit();
@@ -963,7 +984,7 @@ public class JdbcTransactionManagerTests {
given(con.getWarnings()).willThrow(new SQLException());
TransactionTemplate tt = new TransactionTemplate(tm);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
@@ -984,7 +1005,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
InOrder ordered = inOrder(con);
ordered.verify(con).setAutoCommit(false);
ordered.verify(con).commit();
@@ -998,7 +1019,7 @@ public class JdbcTransactionManagerTests {
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRES_NEW);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -1042,7 +1063,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
InOrder ordered = inOrder(con);
ordered.verify(con).setAutoCommit(false);
ordered.verify(con).commit();
@@ -1056,7 +1077,7 @@ public class JdbcTransactionManagerTests {
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRES_NEW);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -1101,7 +1122,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
InOrder ordered = inOrder(con);
ordered.verify(con).setAutoCommit(false);
ordered.verify(con).commit();
@@ -1125,7 +1146,7 @@ public class JdbcTransactionManagerTests {
}
}));
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).close();
}
@@ -1142,7 +1163,7 @@ public class JdbcTransactionManagerTests {
}
}));
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).close();
}
@@ -1160,7 +1181,7 @@ public class JdbcTransactionManagerTests {
}
}));
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).close();
}
@@ -1177,7 +1198,7 @@ public class JdbcTransactionManagerTests {
}
}));
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).close();
}
@@ -1195,7 +1216,7 @@ public class JdbcTransactionManagerTests {
}
}));
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).rollback();
verify(con).close();
}
@@ -1214,7 +1235,7 @@ public class JdbcTransactionManagerTests {
}
}));
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
InOrder ordered = inOrder(con);
ordered.verify(con).setAutoCommit(false);
ordered.verify(con).rollback();
@@ -1237,7 +1258,7 @@ public class JdbcTransactionManagerTests {
}
}));
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
InOrder ordered = inOrder(con);
ordered.verify(con).setAutoCommit(false);
ordered.verify(con).rollback();
@@ -1259,7 +1280,7 @@ public class JdbcTransactionManagerTests {
}
}));
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
InOrder ordered = inOrder(con);
ordered.verify(con).setAutoCommit(false);
ordered.verify(con).rollback();
@@ -1271,53 +1292,53 @@ public class JdbcTransactionManagerTests {
public void testTransactionWithPropagationSupports() throws Exception {
TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!status.isNewTransaction()).as("Is not new transaction").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(status.isNewTransaction()).as("Is not new transaction").isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
}
@Test
public void testTransactionWithPropagationNotSupported() throws Exception {
TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!status.isNewTransaction()).as("Is not new transaction").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(status.isNewTransaction()).as("Is not new transaction").isFalse();
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
}
@Test
public void testTransactionWithPropagationNever() throws Exception {
TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!status.isNewTransaction()).as("Is not new transaction").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(status.isNewTransaction()).as("Is not new transaction").isFalse();
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
}
@Test
@@ -1342,31 +1363,32 @@ public class JdbcTransactionManagerTests {
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
assertThat(!status.hasSavepoint()).as("Isn't nested transaction").isTrue();
assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
for (int i = 0; i < count; i++) {
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
assertThat(!status.isNewTransaction()).as("Isn't new transaction").isTrue();
assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
assertThat(status.hasSavepoint()).as("Is nested transaction").isTrue();
}
});
}
assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
assertThat(!status.hasSavepoint()).as("Isn't nested transaction").isTrue();
assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con, times(count)).releaseSavepoint(sp);
verify(con).commit();
verify(con).close();
@@ -1383,30 +1405,31 @@ public class JdbcTransactionManagerTests {
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
assertThat(!status.hasSavepoint()).as("Isn't nested transaction").isTrue();
assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
assertThat(!status.isNewTransaction()).as("Isn't new transaction").isTrue();
assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
assertThat(status.hasSavepoint()).as("Is nested transaction").isTrue();
status.setRollbackOnly();
}
});
assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
assertThat(!status.hasSavepoint()).as("Isn't nested transaction").isTrue();
assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).rollback(sp);
verify(con).releaseSavepoint(sp);
verify(con).commit();
@@ -1424,21 +1447,22 @@ public class JdbcTransactionManagerTests {
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
assertThat(!status.hasSavepoint()).as("Isn't nested transaction").isTrue();
assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
assertThatIllegalStateException().isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
assertThat(!status.isNewTransaction()).as("Isn't new transaction").isTrue();
assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
assertThat(status.hasSavepoint()).as("Is nested transaction").isTrue();
TransactionTemplate ntt = new TransactionTemplate(tm);
ntt.execute(new TransactionCallbackWithoutResult() {
@@ -1446,19 +1470,19 @@ public class JdbcTransactionManagerTests {
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
assertThat(!status.isNewTransaction()).as("Isn't new transaction").isTrue();
assertThat(!status.hasSavepoint()).as("Is regular transaction").isTrue();
assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
assertThat(status.hasSavepoint()).as("Is regular transaction").isFalse();
throw new IllegalStateException();
}
});
}
}));
assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
assertThat(!status.hasSavepoint()).as("Isn't nested transaction").isTrue();
assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).rollback(sp);
verify(con).releaseSavepoint(sp);
verify(con).commit();
@@ -1476,21 +1500,22 @@ public class JdbcTransactionManagerTests {
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
assertThat(!status.hasSavepoint()).as("Isn't nested transaction").isTrue();
assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
assertThatExceptionOfType(UnexpectedRollbackException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
assertThat(!status.isNewTransaction()).as("Isn't new transaction").isTrue();
assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
assertThat(status.hasSavepoint()).as("Is nested transaction").isTrue();
TransactionTemplate ntt = new TransactionTemplate(tm);
ntt.execute(new TransactionCallbackWithoutResult() {
@@ -1498,19 +1523,19 @@ public class JdbcTransactionManagerTests {
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Has thread connection").isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization active").isTrue();
assertThat(!status.isNewTransaction()).as("Isn't new transaction").isTrue();
assertThat(!status.hasSavepoint()).as("Is regular transaction").isTrue();
assertThat(status.isNewTransaction()).as("Isn't new transaction").isFalse();
assertThat(status.hasSavepoint()).as("Is regular transaction").isFalse();
status.setRollbackOnly();
}
});
}
}));
assertThat(status.isNewTransaction()).as("Is new transaction").isTrue();
assertThat(!status.hasSavepoint()).as("Isn't nested transaction").isTrue();
assertThat(status.hasSavepoint()).as("Isn't nested transaction").isFalse();
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).rollback(sp);
verify(con).releaseSavepoint(sp);
verify(con).commit();
@@ -1528,8 +1553,9 @@ public class JdbcTransactionManagerTests {
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -1541,7 +1567,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).releaseSavepoint(sp);
verify(con).commit();
verify(con).close();
@@ -1559,8 +1585,9 @@ public class JdbcTransactionManagerTests {
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -1572,7 +1599,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).rollback(sp);
verify(con).commit();
verify(con).close();
@@ -1582,8 +1609,9 @@ public class JdbcTransactionManagerTests {
public void testTransactionWithPropagationNested() throws Exception {
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -1592,7 +1620,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).commit();
verify(con).close();
}
@@ -1601,8 +1629,9 @@ public class JdbcTransactionManagerTests {
public void testTransactionWithPropagationNestedAndRollback() throws Exception {
final TransactionTemplate tt = new TransactionTemplate(tm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).as("Synchronization not active")
.isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -1612,7 +1641,7 @@ public class JdbcTransactionManagerTests {
}
});
assertThat(!TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isTrue();
assertThat(TransactionSynchronizationManager.hasResource(ds)).as("Hasn't thread connection").isFalse();
verify(con).rollback();
verify(con).close();
}
@@ -1688,7 +1717,7 @@ public class JdbcTransactionManagerTests {
protected void doAfterCompletion(int status) {
assertThat(this.afterCompletionCalled).isFalse();
this.afterCompletionCalled = true;
assertThat(status == this.status).isTrue();
assertThat(status).isEqualTo(this.status);
assertThat(TransactionSynchronizationManager.hasResource(this.dataSource)).isTrue();
}
}

104
spring-jdbc/src/test/java/org/springframework/jdbc/support/SQLErrorCodesFactoryTests.java
View File

@@ -50,8 +50,8 @@ public class SQLErrorCodesFactoryTests {
@Test
public void testDefaultInstanceWithNoSuchDatabase() {
SQLErrorCodes sec = SQLErrorCodesFactory.getInstance().getErrorCodes("xx");
assertThat(sec.getBadSqlGrammarCodes().length == 0).isTrue();
assertThat(sec.getDataIntegrityViolationCodes().length == 0).isTrue();
assertThat(sec.getBadSqlGrammarCodes().length).isEqualTo(0);
assertThat(sec.getDataIntegrityViolationCodes().length).isEqualTo(0);
}
/**
@@ -64,80 +64,80 @@ public class SQLErrorCodesFactoryTests {
}
private void assertIsOracle(SQLErrorCodes sec) {
assertThat(sec.getBadSqlGrammarCodes().length > 0).isTrue();
assertThat(sec.getDataIntegrityViolationCodes().length > 0).isTrue();
assertThat(sec.getBadSqlGrammarCodes().length).isGreaterThan(0);
assertThat(sec.getDataIntegrityViolationCodes().length).isGreaterThan(0);
// These had better be a Bad SQL Grammar code
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "942") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "6550") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "942")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "6550")).isGreaterThanOrEqualTo(0);
// This had better NOT be
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "9xx42") >= 0).isFalse();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "9xx42")).isLessThan(0);
}
private void assertIsSQLServer(SQLErrorCodes sec) {
assertThat(sec.getDatabaseProductName()).isEqualTo("Microsoft SQL Server");
assertThat(sec.getBadSqlGrammarCodes().length > 0).isTrue();
assertThat(sec.getBadSqlGrammarCodes().length).isGreaterThan(0);
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "156") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "170") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "207") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "208") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "209") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "9xx42") >= 0).isFalse();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "156")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "170")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "207")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "208")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "209")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "9xx42")).isLessThan(0);
assertThat(sec.getPermissionDeniedCodes().length > 0).isTrue();
assertThat(Arrays.binarySearch(sec.getPermissionDeniedCodes(), "229") >= 0).isTrue();
assertThat(sec.getPermissionDeniedCodes().length).isGreaterThan(0);
assertThat(Arrays.binarySearch(sec.getPermissionDeniedCodes(), "229")).isGreaterThanOrEqualTo(0);
assertThat(sec.getDuplicateKeyCodes().length > 0).isTrue();
assertThat(Arrays.binarySearch(sec.getDuplicateKeyCodes(), "2601") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getDuplicateKeyCodes(), "2627") >= 0).isTrue();
assertThat(sec.getDuplicateKeyCodes().length).isGreaterThan(0);
assertThat(Arrays.binarySearch(sec.getDuplicateKeyCodes(), "2601")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getDuplicateKeyCodes(), "2627")).isGreaterThanOrEqualTo(0);
assertThat(sec.getDataIntegrityViolationCodes().length > 0).isTrue();
assertThat(Arrays.binarySearch(sec.getDataIntegrityViolationCodes(), "544") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getDataIntegrityViolationCodes(), "8114") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getDataIntegrityViolationCodes(), "8115") >= 0).isTrue();
assertThat(sec.getDataIntegrityViolationCodes().length).isGreaterThan(0);
assertThat(Arrays.binarySearch(sec.getDataIntegrityViolationCodes(), "544")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getDataIntegrityViolationCodes(), "8114")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getDataIntegrityViolationCodes(), "8115")).isGreaterThanOrEqualTo(0);
assertThat(sec.getDataAccessResourceFailureCodes().length > 0).isTrue();
assertThat(Arrays.binarySearch(sec.getDataAccessResourceFailureCodes(), "4060") >= 0).isTrue();
assertThat(sec.getDataAccessResourceFailureCodes().length).isGreaterThan(0);
assertThat(Arrays.binarySearch(sec.getDataAccessResourceFailureCodes(), "4060")).isGreaterThanOrEqualTo(0);
assertThat(sec.getCannotAcquireLockCodes().length > 0).isTrue();
assertThat(Arrays.binarySearch(sec.getCannotAcquireLockCodes(), "1222") >= 0).isTrue();
assertThat(sec.getCannotAcquireLockCodes().length).isGreaterThan(0);
assertThat(Arrays.binarySearch(sec.getCannotAcquireLockCodes(), "1222")).isGreaterThanOrEqualTo(0);
assertThat(sec.getDeadlockLoserCodes().length > 0).isTrue();
assertThat(Arrays.binarySearch(sec.getDeadlockLoserCodes(), "1205") >= 0).isTrue();
assertThat(sec.getDeadlockLoserCodes().length).isGreaterThan(0);
assertThat(Arrays.binarySearch(sec.getDeadlockLoserCodes(), "1205")).isGreaterThanOrEqualTo(0);
}
private void assertIsHsql(SQLErrorCodes sec) {
assertThat(sec.getBadSqlGrammarCodes().length > 0).isTrue();
assertThat(sec.getDataIntegrityViolationCodes().length > 0).isTrue();
assertThat(sec.getBadSqlGrammarCodes().length).isGreaterThan(0);
assertThat(sec.getDataIntegrityViolationCodes().length).isGreaterThan(0);
// This had better be a Bad SQL Grammar code
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "-22") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "-22")).isGreaterThanOrEqualTo(0);
// This had better NOT be
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "-9") >= 0).isFalse();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "-9")).isLessThan(0);
}
private void assertIsDB2(SQLErrorCodes sec) {
assertThat(sec.getBadSqlGrammarCodes().length > 0).isTrue();
assertThat(sec.getDataIntegrityViolationCodes().length > 0).isTrue();
assertThat(sec.getBadSqlGrammarCodes().length).isGreaterThan(0);
assertThat(sec.getDataIntegrityViolationCodes().length).isGreaterThan(0);
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "942") >= 0).isFalse();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "942")).isLessThan(0);
// This had better NOT be
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "-204") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "-204")).isGreaterThanOrEqualTo(0);
}
private void assertIsHana(SQLErrorCodes sec) {
assertThat(sec.getBadSqlGrammarCodes().length > 0).isTrue();
assertThat(sec.getDataIntegrityViolationCodes().length > 0).isTrue();
assertThat(sec.getBadSqlGrammarCodes().length).isGreaterThan(0);
assertThat(sec.getDataIntegrityViolationCodes().length).isGreaterThan(0);
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "368") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getPermissionDeniedCodes(), "10") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getDuplicateKeyCodes(), "301") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getDataIntegrityViolationCodes(), "461") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getDataAccessResourceFailureCodes(), "-813") >=0).isTrue();
assertThat(Arrays.binarySearch(sec.getInvalidResultSetAccessCodes(), "582") >=0).isTrue();
assertThat(Arrays.binarySearch(sec.getCannotAcquireLockCodes(), "131") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getCannotSerializeTransactionCodes(), "138") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getDeadlockLoserCodes(), "133") >= 0).isTrue();
assertThat(Arrays.binarySearch(sec.getBadSqlGrammarCodes(), "368")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getPermissionDeniedCodes(), "10")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getDuplicateKeyCodes(), "301")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getDataIntegrityViolationCodes(), "461")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getDataAccessResourceFailureCodes(), "-813")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getInvalidResultSetAccessCodes(), "582")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getCannotAcquireLockCodes(), "131")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getCannotSerializeTransactionCodes(), "138")).isGreaterThanOrEqualTo(0);
assertThat(Arrays.binarySearch(sec.getDeadlockLoserCodes(), "133")).isGreaterThanOrEqualTo(0);
}
@@ -163,8 +163,8 @@ public class SQLErrorCodesFactoryTests {
// Should have failed to load without error
TestSQLErrorCodesFactory sf = new TestSQLErrorCodesFactory();
assertThat(sf.getErrorCodes("XX").getBadSqlGrammarCodes().length == 0).isTrue();
assertThat(sf.getErrorCodes("Oracle").getDataIntegrityViolationCodes().length == 0).isTrue();
assertThat(sf.getErrorCodes("XX").getBadSqlGrammarCodes().length).isEqualTo(0);
assertThat(sf.getErrorCodes("Oracle").getDataIntegrityViolationCodes().length).isEqualTo(0);
}
/**
@@ -184,7 +184,7 @@ public class SQLErrorCodesFactoryTests {
// Should have loaded without error
TestSQLErrorCodesFactory sf = new TestSQLErrorCodesFactory();
assertThat(sf.getErrorCodes("XX").getBadSqlGrammarCodes().length == 0).isTrue();
assertThat(sf.getErrorCodes("XX").getBadSqlGrammarCodes().length).isEqualTo(0);
assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes()).hasSize(2);
assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes()[0]).isEqualTo("1");
assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes()[1]).isEqualTo("2");
@@ -205,7 +205,7 @@ public class SQLErrorCodesFactoryTests {
// Should have failed to load without error
TestSQLErrorCodesFactory sf = new TestSQLErrorCodesFactory();
assertThat(sf.getErrorCodes("XX").getBadSqlGrammarCodes().length == 0).isTrue();
assertThat(sf.getErrorCodes("XX").getBadSqlGrammarCodes().length).isEqualTo(0);
assertThat(sf.getErrorCodes("Oracle").getBadSqlGrammarCodes()).isEmpty();
}