nosu
/
taskana
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

TSK-173 switch to SpringManagedTransactionFactory and add test application

This commit is contained in:
BerndBreier 2018-01-30 07:44:43 +01:00 committed by Marcel Lengl
parent 663ce463b2
commit 396dd54144
12 changed files with 568 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
lib/pom.xml
View File

@ -1,22 +1,23 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>pro.taskana</groupId>
<artifactId>taskana-parent</artifactId>
<version>0.0.6-SNAPSHOT</version>
<packaging>pom</packaging>
<description>This pom is parent to all taskana core modules and serves the common build.</description>
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>pro.taskana</groupId>
<artifactId>taskana-parent</artifactId>
<version>0.0.6-SNAPSHOT</version>
<packaging>pom</packaging>
<properties>
<java.version>1.8</java.version>
</properties>
<description>This pom is parent to all taskana core modules and serves the common build.</description>
<modules>
<module>taskana-core</module>
<module>taskana-cdi</module>
<module>taskana-spring</module>
<module>taskana-cdi-example</module>
<module>taskana-spring-example</module>
</modules>
<properties>
<java.version>1.8</java.version>
</properties>
<modules>
<module>taskana-core</module>
<module>taskana-cdi</module>
<module>taskana-spring</module>
<module>taskana-cdi-example</module>
<module>taskana-spring-example</module>
<module>taskana-spring-txtest</module>
</modules>
</project>

40
lib/taskana-core/src/main/java/pro/taskana/impl/TaskanaEngineImpl.java
View File

@ -1,5 +1,6 @@
package pro.taskana.impl;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Stack;
@ -23,6 +24,7 @@ import pro.taskana.WorkbasketService;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.AutocommitFailedException;
import pro.taskana.exceptions.ConnectionNotSetException;
import pro.taskana.exceptions.SystemException;
import pro.taskana.exceptions.UnsupportedDatabaseException;
import pro.taskana.impl.persistence.MapTypeHandler;
import pro.taskana.model.mappings.AttachmentMapper;
@ -42,7 +44,7 @@ public class TaskanaEngineImpl implements TaskanaEngine {
private static final String DEFAULT = "default";
private static final Logger LOGGER = LoggerFactory.getLogger(TaskanaEngineImpl.class);
protected static ThreadLocal<Stack<SqlSessionManager>> sessionStack = new ThreadLocal<Stack<SqlSessionManager>>();
protected static ThreadLocal<Stack<SqlSessionManager>> sessionStack = new ThreadLocal<>();
protected TaskanaEngineConfiguration taskanaEngineConfiguration;
protected TransactionFactory transactionFactory;
protected SqlSessionManager sessionManager;
@ -59,27 +61,24 @@ public class TaskanaEngineImpl implements TaskanaEngine {
@Override
public TaskService getTaskService() {
SqlSession session = this.sessionManager;
TaskServiceImpl taskServiceImpl = new TaskServiceImpl(this, session.getMapper(TaskMapper.class),
return new TaskServiceImpl(this, session.getMapper(TaskMapper.class),
session.getMapper(ObjectReferenceMapper.class), session.getMapper(AttachmentMapper.class));
return taskServiceImpl;
}
@Override
public TaskMonitorService getTaskMonitorService() {
SqlSession session = this.sessionManager;
TaskMonitorServiceImpl taskMonitorServiceImpl = new TaskMonitorServiceImpl(this,
return new TaskMonitorServiceImpl(this,
session.getMapper(TaskMonitorMapper.class));
return taskMonitorServiceImpl;
}
@Override
public WorkbasketService getWorkbasketService() {
SqlSession session = this.sessionManager;
WorkbasketServiceImpl workbasketServiceImpl = new WorkbasketServiceImpl(this,
return new WorkbasketServiceImpl(this,
session.getMapper(WorkbasketMapper.class),
session.getMapper(DistributionTargetMapper.class),
session.getMapper(WorkbasketAccessMapper.class));
return workbasketServiceImpl;
}
@Override
@ -123,7 +122,7 @@ public class TaskanaEngineImpl implements TaskanaEngine {
* TaskanaEngine.closeConnection() or TaskanaEngine.setConnection(null). Both calls have the same effect.
*
* @param connection
* TODO
* The connection that passed into TaskanaEngine
*/
@Override
public void setConnection(java.sql.Connection connection) {
@ -171,10 +170,8 @@ public class TaskanaEngineImpl implements TaskanaEngine {
void initSqlSession() {
if (mode == ConnectionManagementMode.EXPLICIT && this.connection == null) {
throw new ConnectionNotSetException();
} else if (mode != ConnectionManagementMode.EXPLICIT) {
if (!this.sessionManager.isManagedSessionStarted()) {
this.sessionManager.startManagedSession();
}
} else if (mode != ConnectionManagementMode.EXPLICIT && !this.sessionManager.isManagedSessionStarted()) {
this.sessionManager.startManagedSession();
}
}
@ -216,18 +213,15 @@ public class TaskanaEngineImpl implements TaskanaEngine {
*
* @return a {@link SqlSessionFactory}
*/
private SqlSessionManager createSqlSessionManager() {
protected SqlSessionManager createSqlSessionManager() {
Environment environment = new Environment(DEFAULT, this.transactionFactory,
taskanaEngineConfiguration.getDatasource());
Configuration configuration = new Configuration(environment);
// set databaseId
String databaseProductName;
try {
databaseProductName = taskanaEngineConfiguration.getDatasource()
.getConnection()
.getMetaData()
.getDatabaseProductName();
try (Connection con = taskanaEngineConfiguration.getDatasource().getConnection()) {
databaseProductName = con.getMetaData().getDatabaseProductName();
if (databaseProductName.contains("DB2")) {
configuration.setDatabaseId("db2");
} else if (databaseProductName.contains("H2")) {
@ -243,7 +237,8 @@ public class TaskanaEngineImpl implements TaskanaEngine {
LOGGER.error(
"Method createSqlSessionManager() could not open a connection to the database. No databaseId has been set.",
e);
throw new RuntimeException(e);
throw new SystemException(
"Method createSqlSessionManager() could not open a connection to the database. No databaseId has been set");
}
// add mappers
@ -257,9 +252,8 @@ public class TaskanaEngineImpl implements TaskanaEngine {
configuration.addMapper(QueryMapper.class);
configuration.addMapper(AttachmentMapper.class);
configuration.getTypeHandlerRegistry().register(MapTypeHandler.class);
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(configuration);
SqlSessionManager sessionManager = SqlSessionManager.newInstance(sessionFactory);
return sessionManager;
SqlSessionFactory localSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
return SqlSessionManager.newInstance(localSessionFactory);
}
/**
@ -290,7 +284,7 @@ public class TaskanaEngineImpl implements TaskanaEngine {
protected static Stack<SqlSessionManager> getSessionStack() {
Stack<SqlSessionManager> stack = sessionStack.get();
if (stack == null) {
stack = new Stack<SqlSessionManager>();
stack = new Stack<>();
sessionStack.set(stack);
}
return stack;

2
lib/taskana-spring-txtest/.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
/target/
.checkstyle

93
lib/taskana-spring-txtest/pom.xml Normal file
View File

@ -0,0 +1,93 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>pro.taskana</groupId>
<artifactId>taskana-spring-txtest</artifactId>
<version>0.0.6-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.7.RELEASE</version>
<relativePath />
</parent>
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<dependency>
<groupId>pro.taskana</groupId>
<artifactId>taskana-core</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>pro.taskana</groupId>
<artifactId>taskana-spring</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-library</artifactId>
<version>1.3</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<version>2.2.1</version>
<executions>
<execution>
<id>attach-sources</id>
<goals>
<goal>jar-no-fork</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<name>${project.groupId}:${project.artifactId}</name>
<url>http://taskana.pro</url>
<description>The Taskana Spring sample application.</description>
</project>

92
lib/taskana-spring-txtest/src/main/java/pro/taskana/springtx/TaskanaConfig.java Normal file
View File

@ -0,0 +1,92 @@
package pro.taskana.springtx;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import pro.taskana.ClassificationService;
import pro.taskana.TaskService;
import pro.taskana.TaskanaEngine;
import pro.taskana.WorkbasketService;
import pro.taskana.configuration.SpringTaskanaEngineConfiguration;
/**
* Class to set /load configuration for Taskana Library
*
* @author v101536 (Kilian Burkhardt)
*/
@Configuration
@EnableTransactionManagement()
public class TaskanaConfig {
@Profile("inmemorydb")
@Configuration
@PropertySource("classpath:postkorb-inmemorydb.properties")
static class InmemoryDBProperties {
}
@Bean
@Primary
@ConfigurationProperties(prefix = "postkorb.datasource")
public DataSourceProperties dataSourceProperties() {
return new DataSourceProperties();
}
@Bean
@Primary
public DataSource dataSource(DataSourceProperties properties) {
DataSource dataSource = properties.initializeDataSourceBuilder().build();
// if TaskanaEngineImpl runs with SpringManagedTransactionFactory, then
// there is no need to wrap the dataSource into TransactionAwareDataSourceProxy ...
// return new TransactionAwareDataSourceProxy(dataSource);
return dataSource;
}
@Bean
public DataSourceTransactionManager transactionManager(DataSource dataSource) {
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource);
return transactionManager;
}
@Bean
public SpringTaskanaEngineConfiguration taskanaEngineConfiguration(DataSource dataSource) {
SpringTaskanaEngineConfiguration taskanaEngineConfiguration = new SpringTaskanaEngineConfiguration();
taskanaEngineConfiguration.setDataSource(dataSource);
return taskanaEngineConfiguration;
}
@Bean
public TaskanaEngine taskanaEngine(SpringTaskanaEngineConfiguration taskanaEngineConfiguration)
throws SQLException {
TaskanaEngine taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
// taskanaEngine.setConnectionManagementMode(TaskanaEngine.ConnectionManagementMode.EXPLICIT);
return taskanaEngine;
}
@Bean
public WorkbasketService workbasketService(TaskanaEngine taskanaEngine) {
return taskanaEngine.getWorkbasketService();
}
@Bean
public TaskService taskService(TaskanaEngine taskanaEngine) {
return taskanaEngine.getTaskService();
}
@Bean
public ClassificationService classificationService(TaskanaEngine taskanaEngine) {
return taskanaEngine.getClassificationService();
}
}

19
lib/taskana-spring-txtest/src/main/java/pro/taskana/springtx/TaskanaConfigTestApplication.java Normal file
View File

@ -0,0 +1,19 @@
package pro.taskana.springtx;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.annotation.Import;
/**
* Class to start an Application to test Taskana
*
* @author v101536 (Kilian Burkhardt)
*/
@SpringBootApplication
@Import(TaskanaConfig.class)
public class TaskanaConfigTestApplication {
public static void main(String[] args) {
new SpringApplicationBuilder(TaskanaConfigTestApplication.class).run(args);
}
}

128
lib/taskana-spring-txtest/src/main/java/pro/taskana/springtx/TaskanaTestController.java Normal file
View File

@ -0,0 +1,128 @@
package pro.taskana.springtx;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import pro.taskana.TaskanaEngine;
import pro.taskana.Workbasket;
import pro.taskana.exceptions.InvalidWorkbasketException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.impl.WorkbasketImpl;
import pro.taskana.impl.util.IdGenerator;
import pro.taskana.model.WorkbasketType;
/**
* @author Titus Meyer (v081065)
*/
@RestController
public class TaskanaTestController {
@Autowired
private JdbcTemplate jdbcTemplate;
@Autowired
private TaskanaEngine taskanaEngine;
@Transactional(rollbackFor = Exception.class)
@RequestMapping("/schema")
public @ResponseBody String schema() {
String schema = jdbcTemplate.queryForObject("SELECT SCHEMA()", String.class);
System.err.println("current schema: " + schema);
return schema;
}
@Transactional(readOnly = true, rollbackFor = Exception.class)
@RequestMapping("/workbaskets")
public @ResponseBody Integer workbaskets() {
return getWorkbaskets();
}
@Transactional(readOnly = true, rollbackFor = Exception.class)
@RequestMapping("/geschbuch-tests")
public @ResponseBody Integer geschbuchTests() {
return getGeschbuchTests();
}
@Transactional(rollbackFor = Exception.class)
@RequestMapping("/transaction")
public @ResponseBody String transaction(@RequestParam(value = "rollback", defaultValue = "false") String rollback)
throws WorkbasketNotFoundException, InvalidWorkbasketException, NotAuthorizedException {
taskanaEngine.getWorkbasketService().createWorkbasket(createWorkBasket("key", "workbasket"));
int workbaskets = getWorkbaskets();
if (Boolean.valueOf(rollback)) {
throw new RuntimeException("workbaskets: " + workbaskets);
} else {
return "workbaskets: " + workbaskets;
}
}
@Transactional(rollbackFor = Exception.class)
@RequestMapping("/transaction-many")
public @ResponseBody String transactionMany(
@RequestParam(value = "rollback", defaultValue = "false") String rollback)
throws WorkbasketNotFoundException, InvalidWorkbasketException, NotAuthorizedException {
taskanaEngine.getWorkbasketService().createWorkbasket(createWorkBasket("key1", "workbasket1"));
taskanaEngine.getWorkbasketService().createWorkbasket(createWorkBasket("key2", "workbasket2"));
taskanaEngine.getWorkbasketService().createWorkbasket(createWorkBasket("key3", "workbasket3"));
if (Boolean.valueOf(rollback)) {
throw new RuntimeException("workbaskets: " + getWorkbaskets());
} else {
return "workbaskets: " + getWorkbaskets();
}
}
@Transactional(rollbackFor = Exception.class)
@RequestMapping("/geschbuch")
public @ResponseBody String transactionGeschbuch(
@RequestParam(value = "rollback", defaultValue = "false") String rollback)
throws WorkbasketNotFoundException, InvalidWorkbasketException, NotAuthorizedException {
taskanaEngine.getWorkbasketService().createWorkbasket(createWorkBasket("key1", "workbasket1"));
taskanaEngine.getWorkbasketService().createWorkbasket(createWorkBasket("key2", "workbasket2"));
jdbcTemplate.execute("INSERT INTO GESCHBUCH.TEST VALUES ('1', 'test')");
jdbcTemplate.execute("INSERT INTO GESCHBUCH.TEST VALUES ('2', 'test2')");
if (Boolean.valueOf(rollback)) {
throw new RuntimeException("workbaskets: " + getWorkbaskets() + ", tests: " + getGeschbuchTests());
} else {
return "workbaskets: " + getWorkbaskets() + ", tests: " + getGeschbuchTests();
}
}
@Transactional(rollbackFor = Exception.class)
@RequestMapping("/cleanup")
public @ResponseBody String cleanup() {
jdbcTemplate.execute("DELETE FROM WORKBASKET");
jdbcTemplate.execute("DELETE FROM GESCHBUCH.TEST");
System.err.println("cleaned workbasket and test tables");
return "cleaned workbasket and test tables";
}
private int getWorkbaskets() {
// return taskanaEngine.getWorkbasketService().getWorkbaskets().size();
return jdbcTemplate.queryForObject("SELECT COUNT(*) FROM WORKBASKET", Integer.class);
}
private int getGeschbuchTests() {
return jdbcTemplate.queryForObject("SELECT COUNT(*) FROM GESCHBUCH.TEST", Integer.class);
}
private Workbasket createWorkBasket(String key, String name) {
WorkbasketImpl workbasket = (WorkbasketImpl) taskanaEngine.getWorkbasketService().newWorkbasket();
String id1 = IdGenerator.generateWithPrefix("TWB");
workbasket.setId(id1);
workbasket.setKey(key);
workbasket.setName(name);
workbasket.setType(WorkbasketType.GROUP);
workbasket.setDomain("generali");
return workbasket;
}
}

24
lib/taskana-spring-txtest/src/main/resources/postkorb-inmemorydb.properties Normal file
View File

@ -0,0 +1,24 @@
######## Spring #######
spring.jpa.show-sql=true
spring.datasource.platform=h2
spring.datasource.initialize=true
spring.datasource.schema=classpath:sql/taskana-schema.sql
spring.h2.console.enabled=true
security.basic.enabled=false
######## Postkorb / Taskana DB #######
postkorb.datasource.url=jdbc:h2:mem:testdb
#postkorb.datasource.url=jdbc:h2:mem:testdb;TRACE_LEVEL_FIle=4
postkorb.datasource.schema=classpath:schema.sql
postkorb.datasource.driverClassName=org.h2.Driver
postkorb.datasource.hibernate.dialect=org.hibernate.dialect.H2
postkorb.datasource.username=sa
postkorb.datasource.password=sa
#logging.level.org.springframework.transaction.interceptor=TRACE
#logging.level.org.springframework.transaction=TRACE
#logging.level.org.mybatis.spring.transaction=TRACE
#logging.level.org.apache.ibatis.transaction=TRACE
#logging.level.pro.taskana=DEBUG
#logging.level.pro.taskana.impl=DEBUG
#logging.level.pro.taskana.model=DEBUG

8
lib/taskana-spring-txtest/src/main/resources/schema.sql Normal file
View File

@ -0,0 +1,8 @@
CREATE SCHEMA IF NOT EXISTS TASKANA;
CREATE SCHEMA IF NOT EXISTS GESCHBUCH;
CREATE TABLE IF NOT EXISTS GESCHBUCH.TEST (
ID CHAR(40) NOT NULL,
NAME VARCHAR(255) NOT NULL,
PRIMARY KEY (ID)
);
SET SCHEMA TASKANA;

158
lib/taskana-spring-txtest/src/test/java/pro/taskana/springtx/TaskanaTransactionTest.java Normal file
View File

@ -0,0 +1,158 @@
package pro.taskana.springtx;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;
import javax.sql.DataSource;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.ResponseEntity;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;
/**
* @author Titus Meyer (v081065)
*/
@RunWith(SpringRunner.class)
@SpringBootTest(classes = TaskanaConfigTestApplication.class,
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ActiveProfiles({"inmemorydb", "dev"})
public class TaskanaTransactionTest {
@Autowired
private TestRestTemplate restTemplate;
@Autowired
private DataSource dataSource;
@Before
public void before() {
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate.execute("DELETE FROM WORKBASKET");
jdbcTemplate.execute("DELETE FROM GESCHBUCH.TEST");
}
@Test
public void testTaskanaSchema() {
ResponseEntity<String> responseEntity = restTemplate.getForEntity("/schema", String.class);
assertThat(responseEntity.getBody(), is("TASKANA"));
}
@Test
public void testTransaction() {
assertBefore(0, 0);
ResponseEntity<String> responseEntity = restTemplate.getForEntity("/transaction", String.class);
System.err.println("response: " + responseEntity.getBody());
assertThat(responseEntity.getBody(), containsString("workbaskets: 1"));
assertAfter(1, 0);
}
@Test
public void testTransactionRollback() {
assertBefore(0, 0);
ResponseEntity<String> responseEntity = restTemplate.getForEntity("/transaction?rollback={rollback}",
String.class, "true");
System.err.println("result: " + responseEntity.getBody());
assertThat(responseEntity.getBody(), containsString("workbaskets: 1"));
assertAfter(0, 0);
}
@Test
public void testTransactionCombined() {
assertBefore(0, 0);
ResponseEntity<String> responseEntity = restTemplate.getForEntity("/transaction-many", String.class);
System.err.println("response: " + responseEntity.getBody());
assertThat(responseEntity.getBody(), containsString("workbaskets: 3"));
assertAfter(3, 0);
}
@Test
public void testTransactionCombinedRollback() {
assertBefore(0, 0);
ResponseEntity<String> responseEntity = restTemplate.getForEntity("/transaction-many?rollback={rollback}",
String.class, "true");
System.err.println("result: " + responseEntity.getBody());
assertThat(responseEntity.getBody(), containsString("workbaskets: 3"));
assertAfter(0, 0);
}
@Test
public void testTransactionGeschbuch() {
assertBefore(0, 0);
ResponseEntity<String> responseEntity = restTemplate.getForEntity("/geschbuch", String.class);
System.err.println("response: " + responseEntity.getBody());
assertThat(responseEntity.getBody(), containsString("workbaskets: 2"));
assertThat(responseEntity.getBody(), containsString("tests: 2"));
assertAfter(2, 2);
}
@Test
public void testTransactionGeschbuchRollback() {
assertBefore(0, 0);
ResponseEntity<String> responseEntity = restTemplate.getForEntity("/geschbuch?rollback={rollback}",
String.class, "true");
System.err.println("response: " + responseEntity.getBody());
assertThat(responseEntity.getBody(), containsString("workbaskets: 2"));
assertThat(responseEntity.getBody(), containsString("tests: 2"));
assertAfter(0, 0);
}
private void assertBefore(int workbaskets, int tests) {
assertWorkbaskets("before", workbaskets);
assertGeschbuchTests("before", tests);
}
private void assertAfter(int workbaskets, int tests) {
assertWorkbaskets("after", workbaskets);
assertGeschbuchTests("after", tests);
}
private void assertWorkbaskets(String assertion, int value) {
int workbaskets = getWorkbaskets();
System.err.println(assertion + " workbaskets: " + workbaskets);
assertThat(workbaskets, is(value));
}
private void assertGeschbuchTests(String assertion, int value) {
int tests = getGeschbuchTests();
System.err.println(assertion + " tests: " + tests);
assertThat(tests, is(value));
}
private int getWorkbaskets() {
ResponseEntity<Integer> workbaskets = restTemplate.getForEntity("/workbaskets", Integer.class);
if (workbaskets.getStatusCode().is2xxSuccessful()) {
return workbaskets.getBody();
} else {
throw new RuntimeException("error get workbaskets: " + workbaskets.getBody());
}
}
private int getGeschbuchTests() {
ResponseEntity<Integer> tests = restTemplate.getForEntity("/geschbuch-tests", Integer.class);
if (tests.getStatusCode().is2xxSuccessful()) {
return tests.getBody();
} else {
throw new RuntimeException("error get geschbuch.tests: " + tests.getBody());
}
}
}

5
lib/taskana-spring/pom.xml
View File

@ -191,6 +191,11 @@
<artifactId>h2</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>
</dependencies>
<description>The helper module to integrate taskana into Spring projects.</description>
</project>

5
lib/taskana-spring/src/main/java/pro/taskana/SpringTaskanaEngineImpl.java
View File

@ -4,7 +4,7 @@ import java.sql.SQLException;
import javax.annotation.PostConstruct;
import org.apache.ibatis.transaction.managed.ManagedTransactionFactory;
import org.mybatis.spring.transaction.SpringManagedTransactionFactory;
import pro.taskana.configuration.SpringTaskanaEngineConfiguration;
import pro.taskana.impl.TaskanaEngineImpl;
@ -20,7 +20,8 @@ public class SpringTaskanaEngineImpl extends TaskanaEngineImpl {
@PostConstruct
public void init() throws SQLException {
this.transactionFactory = new ManagedTransactionFactory();
this.transactionFactory = new SpringManagedTransactionFactory();
this.sessionManager = createSqlSessionManager();
}
}