diff --git a/lib/pom.xml b/lib/pom.xml index c53407721..dca5ff872 100644 --- a/lib/pom.xml +++ b/lib/pom.xml @@ -1,22 +1,23 @@ - 4.0.0 - pro.taskana - taskana-parent - 0.0.6-SNAPSHOT - pom - - This pom is parent to all taskana core modules and serves the common build. + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + 4.0.0 + pro.taskana + taskana-parent + 0.0.6-SNAPSHOT + pom - - 1.8 - + This pom is parent to all taskana core modules and serves the common build. - - taskana-core - taskana-cdi - taskana-spring - taskana-cdi-example - taskana-spring-example - + + 1.8 + + + + taskana-core + taskana-cdi + taskana-spring + taskana-cdi-example + taskana-spring-example + taskana-spring-txtest + diff --git a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskanaEngineImpl.java b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskanaEngineImpl.java index a654db9f0..a6c004e4e 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/impl/TaskanaEngineImpl.java +++ b/lib/taskana-core/src/main/java/pro/taskana/impl/TaskanaEngineImpl.java @@ -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> sessionStack = new ThreadLocal>(); + protected static ThreadLocal> 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 getSessionStack() { Stack stack = sessionStack.get(); if (stack == null) { - stack = new Stack(); + stack = new Stack<>(); sessionStack.set(stack); } return stack; diff --git a/lib/taskana-spring-txtest/.gitignore b/lib/taskana-spring-txtest/.gitignore new file mode 100644 index 000000000..1451260c3 --- /dev/null +++ b/lib/taskana-spring-txtest/.gitignore @@ -0,0 +1,2 @@ +/target/ +.checkstyle diff --git a/lib/taskana-spring-txtest/pom.xml b/lib/taskana-spring-txtest/pom.xml new file mode 100644 index 000000000..00d076d1f --- /dev/null +++ b/lib/taskana-spring-txtest/pom.xml @@ -0,0 +1,93 @@ + + 4.0.0 + pro.taskana + taskana-spring-txtest + 0.0.6-SNAPSHOT + + org.springframework.boot + spring-boot-starter-parent + 1.5.7.RELEASE + + + + + 1.8 + 1.8 + UTF-8 + + + + + org.springframework.boot + spring-boot-starter-web + + + org.springframework + spring-context + + + org.springframework + spring-jdbc + + + org.springframework.boot + spring-boot-starter-jdbc + + + org.springframework + spring-tx + + + com.h2database + h2 + + + org.springframework.boot + spring-boot-starter-test + + + pro.taskana + taskana-core + ${project.version} + + + pro.taskana + taskana-spring + ${project.version} + + + junit + junit + 4.12 + test + + + org.hamcrest + hamcrest-library + 1.3 + test + + + + + + org.apache.maven.plugins + maven-source-plugin + 2.2.1 + + + attach-sources + + jar-no-fork + + + + + + + + ${project.groupId}:${project.artifactId} + http://taskana.pro + The Taskana Spring sample application. + diff --git a/lib/taskana-spring-txtest/src/main/java/pro/taskana/springtx/TaskanaConfig.java b/lib/taskana-spring-txtest/src/main/java/pro/taskana/springtx/TaskanaConfig.java new file mode 100644 index 000000000..f70f58621 --- /dev/null +++ b/lib/taskana-spring-txtest/src/main/java/pro/taskana/springtx/TaskanaConfig.java @@ -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(); + } + +} diff --git a/lib/taskana-spring-txtest/src/main/java/pro/taskana/springtx/TaskanaConfigTestApplication.java b/lib/taskana-spring-txtest/src/main/java/pro/taskana/springtx/TaskanaConfigTestApplication.java new file mode 100644 index 000000000..629ac2531 --- /dev/null +++ b/lib/taskana-spring-txtest/src/main/java/pro/taskana/springtx/TaskanaConfigTestApplication.java @@ -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); + } +} diff --git a/lib/taskana-spring-txtest/src/main/java/pro/taskana/springtx/TaskanaTestController.java b/lib/taskana-spring-txtest/src/main/java/pro/taskana/springtx/TaskanaTestController.java new file mode 100644 index 000000000..361ad7143 --- /dev/null +++ b/lib/taskana-spring-txtest/src/main/java/pro/taskana/springtx/TaskanaTestController.java @@ -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; + } +} diff --git a/lib/taskana-spring-txtest/src/main/resources/postkorb-inmemorydb.properties b/lib/taskana-spring-txtest/src/main/resources/postkorb-inmemorydb.properties new file mode 100644 index 000000000..13bbb3c33 --- /dev/null +++ b/lib/taskana-spring-txtest/src/main/resources/postkorb-inmemorydb.properties @@ -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 diff --git a/lib/taskana-spring-txtest/src/main/resources/schema.sql b/lib/taskana-spring-txtest/src/main/resources/schema.sql new file mode 100644 index 000000000..235155eb2 --- /dev/null +++ b/lib/taskana-spring-txtest/src/main/resources/schema.sql @@ -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; \ No newline at end of file diff --git a/lib/taskana-spring-txtest/src/test/java/pro/taskana/springtx/TaskanaTransactionTest.java b/lib/taskana-spring-txtest/src/test/java/pro/taskana/springtx/TaskanaTransactionTest.java new file mode 100644 index 000000000..39c152a99 --- /dev/null +++ b/lib/taskana-spring-txtest/src/test/java/pro/taskana/springtx/TaskanaTransactionTest.java @@ -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 responseEntity = restTemplate.getForEntity("/schema", String.class); + assertThat(responseEntity.getBody(), is("TASKANA")); + } + + @Test + public void testTransaction() { + assertBefore(0, 0); + + ResponseEntity 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 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 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 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 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 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 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 tests = restTemplate.getForEntity("/geschbuch-tests", Integer.class); + if (tests.getStatusCode().is2xxSuccessful()) { + return tests.getBody(); + } else { + throw new RuntimeException("error get geschbuch.tests: " + tests.getBody()); + } + } +} diff --git a/lib/taskana-spring/pom.xml b/lib/taskana-spring/pom.xml index 06ec6c132..7f47a5646 100644 --- a/lib/taskana-spring/pom.xml +++ b/lib/taskana-spring/pom.xml @@ -191,6 +191,11 @@ h2 test + + org.mybatis + mybatis-spring + 1.3.1 + The helper module to integrate taskana into Spring projects. \ No newline at end of file diff --git a/lib/taskana-spring/src/main/java/pro/taskana/SpringTaskanaEngineImpl.java b/lib/taskana-spring/src/main/java/pro/taskana/SpringTaskanaEngineImpl.java index 111979ce4..355e78011 100644 --- a/lib/taskana-spring/src/main/java/pro/taskana/SpringTaskanaEngineImpl.java +++ b/lib/taskana-spring/src/main/java/pro/taskana/SpringTaskanaEngineImpl.java @@ -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(); } }