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

Merge pull request #58 from MLengl/TSK-63 

TSK-63: Summary-Service/Controller/Test into Task-..
This commit is contained in:
Holger Hagen 2017-12-11 12:59:38 +01:00 committed by GitHub
parent d6651a9ed5 3e78f2e789
commit b14dd4c98a
15 changed files with 199 additions and 416 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
lib/taskana-core/src/main/java/pro/taskana/SummaryService.java
View File

@ -1,14 +0,0 @@
package pro.taskana;
import java.util.List;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.model.TaskSummary;
/**
* This interface manages the summaries of some models.
*/
public interface SummaryService {
List<TaskSummary> getTaskSummariesByWorkbasketId(String workbasketId) throws WorkbasketNotFoundException;
}

9
lib/taskana-core/src/main/java/pro/taskana/TaskService.java
View File

@ -8,6 +8,7 @@ import pro.taskana.model.DueWorkbasketCounter;
import pro.taskana.model.Task;
import pro.taskana.model.TaskState;
import pro.taskana.model.TaskStateCounter;
import pro.taskana.model.TaskSummary;
import java.util.List;
@ -110,4 +111,12 @@ public interface TaskService {
* @throws Exception if no result can be found by @{link TaskMapper}.
*/
List<Task> getTasksByWorkbasketIdAndState(String workbasketId, TaskState taskState) throws WorkbasketNotFoundException, NotAuthorizedException, Exception;
/**
* Getting a short summary of all tasks in a specific workbasket.
* @param workbasketId ID of workbasket where tasks are located.
* @return TaskSummaryList with all TaskSummaries of a workbasket
* @throws WorkbasketNotFoundException if a Workbasket can´t be located.
*/
List<TaskSummary> getTaskSummariesByWorkbasketId(String workbasketId) throws WorkbasketNotFoundException;
}

7
lib/taskana-core/src/main/java/pro/taskana/TaskanaEngine.java
View File

@ -25,13 +25,6 @@ public interface TaskanaEngine {
*/
ClassificationService getClassificationService();
/**
* Can be used for each operation for summaries with short-infos about
* one or more objects.
* @return a SummaryService-BEAN
*/
SummaryService getSummaryService();
/**
* The Taskana configuration.
* @return the TaskanaConfiguration

54
lib/taskana-core/src/main/java/pro/taskana/impl/SummaryServiceImpl.java
View File

@ -1,54 +0,0 @@
package pro.taskana.impl;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.SummaryService;
import pro.taskana.TaskanaEngine;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.impl.util.LoggerUtils;
import pro.taskana.model.TaskSummary;
import pro.taskana.model.mappings.SummaryMapper;
/**
* @author mle
* Organization of Table-Summaries with less informations.
*/
public class SummaryServiceImpl implements SummaryService {
public static final Logger LOGGER = LoggerFactory.getLogger(SummaryServiceImpl.class);
private SummaryMapper summaryMapper;
private TaskanaEngineImpl taskanaEngineImpl;
public SummaryServiceImpl(TaskanaEngine taskanaEngine, SummaryMapper summaryMapper) {
this.summaryMapper = summaryMapper;
this.taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;
}
@Override
public List<TaskSummary> getTaskSummariesByWorkbasketId(String workbasketId) throws WorkbasketNotFoundException {
LOGGER.debug("entry to getTaskSummariesByWorkbasketId(workbasketId = {}", workbasketId);
List<TaskSummary> taskSummaries = new ArrayList<>();
taskanaEngineImpl.getWorkbasketService().getWorkbasket(workbasketId);
try {
taskanaEngineImpl.openConnection();
taskSummaries = summaryMapper.findTasksummariesByWorkbasketId(workbasketId);
} catch (Exception ex) {
LOGGER.error("Getting TASKSUMMARY failed internally.", ex);
} finally {
if (taskSummaries == null) {
taskSummaries = new ArrayList<>();
}
taskanaEngineImpl.returnConnection();
if (LOGGER.isDebugEnabled()) {
int numberOfResultObjects = taskSummaries.size();
LOGGER.debug("exit from getTaskSummariesByWorkbasketId(workbasketId). Returning {} resulting Objects: {} ",
numberOfResultObjects, LoggerUtils.listToString(taskSummaries));
}
}
return taskSummaries;
}
}

25
lib/taskana-core/src/main/java/pro/taskana/impl/TaskServiceImpl.java
View File

@ -26,6 +26,7 @@ import pro.taskana.model.ObjectReference;
import pro.taskana.model.Task;
import pro.taskana.model.TaskState;
import pro.taskana.model.TaskStateCounter;
import pro.taskana.model.TaskSummary;
import pro.taskana.model.WorkbasketAuthorization;
import pro.taskana.model.mappings.ObjectReferenceMapper;
import pro.taskana.model.mappings.TaskMapper;
@ -344,4 +345,28 @@ public class TaskServiceImpl implements TaskService {
task.setPrimaryObjRef(objectReference);
}
}
@Override
public List<TaskSummary> getTaskSummariesByWorkbasketId(String workbasketId) throws WorkbasketNotFoundException {
LOGGER.debug("entry to getTaskSummariesByWorkbasketId(workbasketId = {}", workbasketId);
List<TaskSummary> taskSummaries = new ArrayList<>();
taskanaEngineImpl.getWorkbasketService().getWorkbasket(workbasketId);
try {
taskanaEngineImpl.openConnection();
taskSummaries = taskMapper.findTaskSummariesByWorkbasketId(workbasketId);
} catch (Exception ex) {
LOGGER.error("Getting TASKSUMMARY failed internally.", ex);
} finally {
if (taskSummaries == null) {
taskSummaries = new ArrayList<>();
}
taskanaEngineImpl.returnConnection();
if (LOGGER.isDebugEnabled()) {
int numberOfResultObjects = taskSummaries.size();
LOGGER.debug("exit from getTaskSummariesByWorkbasketId(workbasketId). Returning {} resulting Objects: {} ",
numberOfResultObjects, LoggerUtils.listToString(taskSummaries));
}
}
return taskSummaries;
}
}

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

@ -15,7 +15,6 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.ClassificationService;
import pro.taskana.SummaryService;
import pro.taskana.TaskService;
import pro.taskana.TaskanaEngine;
import pro.taskana.WorkbasketService;
@ -27,7 +26,6 @@ import pro.taskana.model.mappings.ClassificationMapper;
import pro.taskana.model.mappings.DistributionTargetMapper;
import pro.taskana.model.mappings.ObjectReferenceMapper;
import pro.taskana.model.mappings.QueryMapper;
import pro.taskana.model.mappings.SummaryMapper;
import pro.taskana.model.mappings.TaskMapper;
import pro.taskana.model.mappings.WorkbasketAccessMapper;
import pro.taskana.model.mappings.WorkbasketMapper;
@ -70,13 +68,6 @@ public class TaskanaEngineImpl implements TaskanaEngine {
return workbasketServiceImpl;
}
@Override
public SummaryService getSummaryService() {
SqlSession session = this.sessionManager;
SummaryServiceImpl summaryServiceImpl = new SummaryServiceImpl(this, session.getMapper(SummaryMapper.class));
return summaryServiceImpl;
}
@Override
public ClassificationService getClassificationService() {
SqlSession session = this.sessionManager;
@ -225,7 +216,6 @@ public class TaskanaEngineImpl implements TaskanaEngine {
configuration.addMapper(WorkbasketAccessMapper.class);
configuration.addMapper(ObjectReferenceMapper.class);
configuration.addMapper(QueryMapper.class);
configuration.addMapper(SummaryMapper.class);
configuration.getTypeHandlerRegistry().register(MapTypeHandler.class);
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(configuration);
SqlSessionManager sessionManager = SqlSessionManager.newInstance(sessionFactory);

32
lib/taskana-core/src/main/java/pro/taskana/model/mappings/SummaryMapper.java
View File

@ -1,32 +0,0 @@
package pro.taskana.model.mappings;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import pro.taskana.model.TaskSummary;
/**
* This interface is the myBatis mapping of short summaries.
*/
public interface SummaryMapper {
@Select("SELECT TASK.ID AS taskId, TASK.NAME AS taskName, TASK.WORKBASKETID AS workId, TASK.CLASSIFICATION_ID AS classificationId, "
+ "WORKBASKET.NAME AS workName, CLASSIFICATION.NAME AS classificationName "
+ "FROM TASK "
+ "LEFT JOIN WORKBASKET ON WORKBASKET.ID = TASK.WORKBASKETID "
+ "LEFT JOIN CLASSIFICATION ON CLASSIFICATION.ID = TASK.CLASSIFICATION_ID "
+ "WHERE TASK.WORKBASKETID = #{workbasketId}")
@Results({
@Result(property = "taskId", column = "taskId"),
@Result(property = "taskName", column = "taskName"),
@Result(property = "workbasketId", column = "workId"),
@Result(property = "workbasketName", column = "workName"),
@Result(property = "classificationId", column = "classificationId"),
@Result(property = "classificationName", column = "classificationName")
})
List<TaskSummary> findTasksummariesByWorkbasketId(@Param("workbasketId") String workbasketId);
}

16
lib/taskana-core/src/main/java/pro/taskana/model/mappings/TaskMapper.java
View File

@ -133,4 +133,20 @@ public interface TaskMapper {
@Result(property = "custom10", column = "CUSTOM_10")
})
List<Task> findTasksByWorkbasketIdAndState(@Param("workbasketId") String workbasketId, @Param("taskState") TaskState taskState);
@Select("SELECT TASK.ID AS taskId, TASK.NAME AS taskName, TASK.WORKBASKETID AS workId, TASK.CLASSIFICATION_ID AS classificationId, "
+ "WORKBASKET.NAME AS workName, CLASSIFICATION.NAME AS classificationName "
+ "FROM TASK "
+ "LEFT JOIN WORKBASKET ON WORKBASKET.ID = TASK.WORKBASKETID "
+ "LEFT JOIN CLASSIFICATION ON CLASSIFICATION.ID = TASK.CLASSIFICATION_ID "
+ "WHERE TASK.WORKBASKETID = #{workbasketId}")
@Results({
@Result(property = "taskId", column = "taskId"),
@Result(property = "taskName", column = "taskName"),
@Result(property = "workbasketId", column = "workId"),
@Result(property = "workbasketName", column = "workName"),
@Result(property = "classificationId", column = "classificationId"),
@Result(property = "classificationName", column = "classificationName")
})
List<TaskSummary> findTaskSummariesByWorkbasketId(@Param("workbasketId") String workbasketId);
}

115
lib/taskana-core/src/test/java/pro/taskana/impl/SummaryServiceImplTest.java
View File

@ -1,115 +0,0 @@
package pro.taskana.impl;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.model.TaskSummary;
import pro.taskana.model.Workbasket;
import pro.taskana.model.mappings.SummaryMapper;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.*;
/**
* Testing the {@link SummaryServiceImpl} component.
* Mocks are initialized before each Method by @Runner-Annotation.
*/
@RunWith(MockitoJUnitRunner.class)
public class SummaryServiceImplTest {
@InjectMocks
private SummaryServiceImpl cut;
@Mock
private SummaryMapper summaryMapperMock;
@Mock
private TaskanaEngineImpl taskanaEngineImplMock;
@Mock
private SqlSession sqlSessionMock;
@Mock
private WorkbasketServiceImpl workbasketServiceMock;
@Test
public void testGetTaskSummariesByWorkbasketIdWithInternalException() throws WorkbasketNotFoundException {
// given - set behaviour and expected result
String workbasketId = "1";
List<TaskSummary> expectedResultList = new ArrayList<>();
doNothing().when(taskanaEngineImplMock).openConnection();
doThrow(new IllegalArgumentException("Invalid ID: " + workbasketId)).when(summaryMapperMock).findTasksummariesByWorkbasketId(workbasketId);
doNothing().when(taskanaEngineImplMock).returnConnection();
doReturn(workbasketServiceMock).when(taskanaEngineImplMock).getWorkbasketService();
doReturn(new Workbasket()).when(workbasketServiceMock).getWorkbasket(any());
// when - make the call
List<TaskSummary> actualResultList = cut.getTaskSummariesByWorkbasketId(workbasketId);
// then - verify external communications and assert result
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(summaryMapperMock, times(1)).findTasksummariesByWorkbasketId(workbasketId);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verify(taskanaEngineImplMock, times(1)).getWorkbasketService();
verify(workbasketServiceMock, times(1)).getWorkbasket(any());
verifyNoMoreInteractions(summaryMapperMock, taskanaEngineImplMock, sqlSessionMock,
workbasketServiceMock);
assertThat(actualResultList, equalTo(expectedResultList));
}
@Test
public void testGetTaskSummariesByWorkbasketIdGettingResults() throws WorkbasketNotFoundException {
String workbasketId = "1";
List<TaskSummary> expectedResultList = Arrays.asList(new TaskSummary(), new TaskSummary());
doNothing().when(taskanaEngineImplMock).openConnection();
doNothing().when(taskanaEngineImplMock).returnConnection();
doReturn(workbasketServiceMock).when(taskanaEngineImplMock).getWorkbasketService();
doReturn(new Workbasket()).when(workbasketServiceMock).getWorkbasket(any());
doReturn(expectedResultList).when(summaryMapperMock).findTasksummariesByWorkbasketId(workbasketId);
List<TaskSummary> actualResultList = cut.getTaskSummariesByWorkbasketId(workbasketId);
verify(taskanaEngineImplMock, times(1)).getWorkbasketService();
verify(workbasketServiceMock, times(1)).getWorkbasket(any());
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(summaryMapperMock, times(1)).findTasksummariesByWorkbasketId(workbasketId);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verifyNoMoreInteractions(summaryMapperMock, taskanaEngineImplMock, sqlSessionMock, workbasketServiceMock);
assertThat(actualResultList, equalTo(expectedResultList));
assertThat(actualResultList.size(), equalTo(expectedResultList.size()));
}
@Test
public void testGetTaskSummariesByWorkbasketIdGettingNull() throws WorkbasketNotFoundException {
String workbasketId = "1";
List<TaskSummary> expectedResultList = new ArrayList<>();
doNothing().when(taskanaEngineImplMock).openConnection();
doNothing().when(taskanaEngineImplMock).returnConnection();
doReturn(null).when(summaryMapperMock).findTasksummariesByWorkbasketId(workbasketId);
doReturn(workbasketServiceMock).when(taskanaEngineImplMock).getWorkbasketService();
doReturn(new Workbasket()).when(workbasketServiceMock).getWorkbasket(any());
List<TaskSummary> actualResultList = cut.getTaskSummariesByWorkbasketId(workbasketId);
verify(taskanaEngineImplMock, times(1)).openConnection();
verify(summaryMapperMock, times(1)).findTasksummariesByWorkbasketId(workbasketId);
verify(taskanaEngineImplMock, times(1)).returnConnection();
verify(taskanaEngineImplMock, times(1)).getWorkbasketService();
verify(workbasketServiceMock, times(1)).getWorkbasket(any());
verifyNoMoreInteractions(summaryMapperMock, taskanaEngineImplMock, sqlSessionMock,
workbasketServiceMock);
assertThat(actualResultList, equalTo(expectedResultList));
assertThat(actualResultList.size(), equalTo(expectedResultList.size()));
}
}

71
lib/taskana-core/src/test/java/pro/taskana/impl/TaskServiceImplTest.java
View File

@ -44,6 +44,7 @@ import pro.taskana.model.ObjectReference;
import pro.taskana.model.Task;
import pro.taskana.model.TaskState;
import pro.taskana.model.TaskStateCounter;
import pro.taskana.model.TaskSummary;
import pro.taskana.model.Workbasket;
import pro.taskana.model.WorkbasketAuthorization;
import pro.taskana.model.mappings.ObjectReferenceMapper;
@ -672,6 +673,76 @@ public class TaskServiceImplTest {
}
}
@Test
public void testGetTaskSummariesByWorkbasketIdWithInternalException() throws WorkbasketNotFoundException {
// given - set behaviour and expected result
String workbasketId = "1";
List<TaskSummary> expectedResultList = new ArrayList<>();
doNothing().when(taskanaEngineImpl).openConnection();
doThrow(new IllegalArgumentException("Invalid ID: " + workbasketId)).when(taskMapperMock).findTaskSummariesByWorkbasketId(workbasketId);
doNothing().when(taskanaEngineImpl).returnConnection();
doReturn(workbasketServiceMock).when(taskanaEngineImpl).getWorkbasketService();
doReturn(new Workbasket()).when(workbasketServiceMock).getWorkbasket(any());
// when - make the call
List<TaskSummary> actualResultList = cut.getTaskSummariesByWorkbasketId(workbasketId);
// then - verify external communications and assert result
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskMapperMock, times(1)).findTaskSummariesByWorkbasketId(workbasketId);
verify(taskanaEngineImpl, times(1)).returnConnection();
verify(taskanaEngineImpl, times(1)).getWorkbasketService();
verify(workbasketServiceMock, times(1)).getWorkbasket(any());
verifyNoMoreInteractions(taskMapperMock, taskanaEngineImpl, workbasketServiceMock);
assertThat(actualResultList, equalTo(expectedResultList));
}
@Test
public void testGetTaskSummariesByWorkbasketIdGettingResults() throws WorkbasketNotFoundException {
String workbasketId = "1";
List<TaskSummary> expectedResultList = Arrays.asList(new TaskSummary(), new TaskSummary());
doNothing().when(taskanaEngineImpl).openConnection();
doNothing().when(taskanaEngineImpl).returnConnection();
doReturn(workbasketServiceMock).when(taskanaEngineImpl).getWorkbasketService();
doReturn(new Workbasket()).when(workbasketServiceMock).getWorkbasket(any());
doReturn(expectedResultList).when(taskMapperMock).findTaskSummariesByWorkbasketId(workbasketId);
List<TaskSummary> actualResultList = cut.getTaskSummariesByWorkbasketId(workbasketId);
verify(taskanaEngineImpl, times(1)).getWorkbasketService();
verify(workbasketServiceMock, times(1)).getWorkbasket(any());
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskMapperMock, times(1)).findTaskSummariesByWorkbasketId(workbasketId);
verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskMapperMock, taskanaEngineImpl, workbasketServiceMock);
assertThat(actualResultList, equalTo(expectedResultList));
assertThat(actualResultList.size(), equalTo(expectedResultList.size()));
}
@Test
public void testGetTaskSummariesByWorkbasketIdGettingNull() throws WorkbasketNotFoundException {
String workbasketId = "1";
List<TaskSummary> expectedResultList = new ArrayList<>();
doNothing().when(taskanaEngineImpl).openConnection();
doNothing().when(taskanaEngineImpl).returnConnection();
doReturn(null).when(taskMapperMock).findTaskSummariesByWorkbasketId(workbasketId);
doReturn(workbasketServiceMock).when(taskanaEngineImpl).getWorkbasketService();
doReturn(new Workbasket()).when(workbasketServiceMock).getWorkbasket(any());
List<TaskSummary> actualResultList = cut.getTaskSummariesByWorkbasketId(workbasketId);
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskMapperMock, times(1)).findTaskSummariesByWorkbasketId(workbasketId);
verify(taskanaEngineImpl, times(1)).returnConnection();
verify(taskanaEngineImpl, times(1)).getWorkbasketService();
verify(workbasketServiceMock, times(1)).getWorkbasket(any());
verifyNoMoreInteractions(taskMapperMock, taskanaEngineImpl, workbasketServiceMock);
assertThat(actualResultList, equalTo(expectedResultList));
assertThat(actualResultList.size(), equalTo(expectedResultList.size()));
}
private Task createUnitTestTask(String id, String name, String workbasketId) throws ClassificationAlreadyExistException {
Task task = new Task();
task.setId(id);

136
lib/taskana-core/src/test/java/pro/taskana/impl/integration/SummaryServiceImplIntAutoCommitTest.java
View File

@ -1,136 +0,0 @@
package pro.taskana.impl.integration;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertThat;
import java.io.FileNotFoundException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import javax.security.auth.login.LoginException;
import javax.sql.DataSource;
import org.h2.store.fs.FileUtils;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import pro.taskana.Classification;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.impl.ClassificationServiceImpl;
import pro.taskana.impl.SummaryServiceImpl;
import pro.taskana.impl.TaskServiceImpl;
import pro.taskana.impl.TaskanaEngineImpl;
import pro.taskana.impl.WorkbasketServiceImpl;
import pro.taskana.impl.configuration.DBCleaner;
import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest;
import pro.taskana.model.ClassificationImpl;
import pro.taskana.model.Task;
import pro.taskana.model.TaskSummary;
import pro.taskana.model.Workbasket;
/**
* Testing {@link SummaryServiceImpl} with real DB-Connection and
* real results.
*/
public class SummaryServiceImplIntAutoCommitTest {
private DataSource dataSource;
private TaskanaEngineConfiguration taskanaEngineConfiguration;
private TaskanaEngine taskanaEngine;
private TaskanaEngineImpl taskanaEngineImpl;
private WorkbasketServiceImpl workbasketServiceImpl;
private TaskServiceImpl taskServiceImpl;
private ClassificationServiceImpl classificationServiceImpl;
private SummaryServiceImpl summaryServiceImp;
private Task dummyTask;
private Classification dummyClassification;
private Workbasket dummyWorkbasket;
@BeforeClass
public static void resetDb() throws SQLException {
DataSource ds = TaskanaEngineConfigurationTest.getDataSource();
DBCleaner cleaner = new DBCleaner();
cleaner.clearDb(ds, true);
}
@Before
public void setup() throws FileNotFoundException, SQLException, LoginException {
dataSource = TaskanaEngineConfigurationTest.getDataSource();
taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false, false);
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;
taskanaEngineImpl.setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT);
workbasketServiceImpl = (WorkbasketServiceImpl) taskanaEngine.getWorkbasketService();
taskServiceImpl = (TaskServiceImpl) taskanaEngine.getTaskService();
classificationServiceImpl = (ClassificationServiceImpl) taskanaEngine.getClassificationService();
summaryServiceImp = (SummaryServiceImpl) taskanaEngine.getSummaryService();
DBCleaner cleaner = new DBCleaner();
cleaner.clearDb(dataSource, false);
}
@Test
public void shouldReturnTaskSummaryListWithValues() throws Exception {
generateDummyData();
List<TaskSummary> expectedTaskSumamries = new ArrayList<>();
TaskSummary taskSummary = new TaskSummary();
taskSummary.setTaskId(dummyTask.getId());
taskSummary.setTaskName(dummyTask.getName());
taskSummary.setWorkbasketId(dummyWorkbasket.getId());
taskSummary.setWorkbasketName(dummyWorkbasket.getName());
taskSummary.setClassificationId(dummyClassification.getId());
taskSummary.setClassificationName(dummyClassification.getName());
expectedTaskSumamries.add(taskSummary);
List<TaskSummary> actualTaskSumamryResult = summaryServiceImp.getTaskSummariesByWorkbasketId(dummyWorkbasket.getId());
assertThat(actualTaskSumamryResult.size(), equalTo(expectedTaskSumamries.size()));
}
@Test(expected = WorkbasketNotFoundException.class)
public void shouldThrowWorkbasketNotFoundExceptionByNullParameter() throws WorkbasketNotFoundException {
summaryServiceImp.getTaskSummariesByWorkbasketId(null);
}
@Test(expected = WorkbasketNotFoundException.class)
public void shouldThrowWorkbasketNotFoundExceptionByInvalidWorkbasketParameter() throws WorkbasketNotFoundException {
Workbasket wb = new Workbasket();
wb.setName("wb");
workbasketServiceImpl.createWorkbasket(wb);
summaryServiceImp.getTaskSummariesByWorkbasketId("1");
}
private void generateDummyData() throws Exception {
dummyWorkbasket = new Workbasket();
dummyWorkbasket.setId("1");
dummyWorkbasket.setName("Dummy-Basket");
dummyWorkbasket = workbasketServiceImpl.createWorkbasket(dummyWorkbasket);
dummyClassification = new ClassificationImpl();
dummyClassification.setId("1");
dummyClassification.setName("Dummy-Classification");
classificationServiceImpl.createClassification(dummyClassification);
dummyTask = new Task();
dummyTask.setId("1");
dummyTask.setName("Dummy-Task");
dummyTask.setClassification(dummyClassification);
dummyTask.setWorkbasketId(dummyWorkbasket.getId());
dummyTask = taskServiceImpl.createTask(dummyTask);
}
@AfterClass
public static void cleanUpClass() {
FileUtils.deleteRecursive("~/data", true);
}
}

56
lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntAutocommitTest.java
View File

@ -1,7 +1,11 @@
package pro.taskana.impl.integration;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertThat;
import java.io.FileNotFoundException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import javax.security.auth.login.LoginException;
@ -20,6 +24,7 @@ import pro.taskana.ClassificationService;
import pro.taskana.ObjectReferenceQuery;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.WorkbasketService;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
@ -34,6 +39,7 @@ import pro.taskana.impl.configuration.DBCleaner;
import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest;
import pro.taskana.model.Task;
import pro.taskana.model.TaskState;
import pro.taskana.model.TaskSummary;
import pro.taskana.model.Workbasket;
/**
@ -48,6 +54,7 @@ public class TaskServiceImplIntAutocommitTest {
private TaskanaEngine taskanaEngine;
private TaskanaEngineImpl taskanaEngineImpl;
private ClassificationService classificationService;
private WorkbasketService workbasketService;
@BeforeClass
public static void resetDb() throws SQLException {
@ -66,6 +73,7 @@ public class TaskServiceImplIntAutocommitTest {
taskanaEngineImpl.setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT);
taskServiceImpl = (TaskServiceImpl) taskanaEngine.getTaskService();
classificationService = taskanaEngine.getClassificationService();
workbasketService = taskanaEngine.getWorkbasketService();
DBCleaner cleaner = new DBCleaner();
cleaner.clearDb(dataSource, false);
}
@ -164,6 +172,54 @@ public class TaskServiceImplIntAutocommitTest {
Assert.assertEquals(0, results.size());
}
@Test
public void shouldReturnTaskSummaryListWithValues() throws Exception {
Workbasket dummyWorkbasket = new Workbasket();
dummyWorkbasket.setId("1");
dummyWorkbasket.setName("Dummy-Basket");
dummyWorkbasket = workbasketService.createWorkbasket(dummyWorkbasket);
Classification dummyClassification = classificationService.newClassification();
dummyClassification.setId("1");
dummyClassification.setName("Dummy-Classification");
classificationService.createClassification(dummyClassification);
Task dummyTask = new Task();
dummyTask.setId("1");
dummyTask.setName("Dummy-Task");
dummyTask.setClassification(dummyClassification);
dummyTask.setWorkbasketId(dummyWorkbasket.getId());
dummyTask = taskServiceImpl.createTask(dummyTask);
List<TaskSummary> expectedTaskSumamries = new ArrayList<>();
TaskSummary taskSummary = new TaskSummary();
taskSummary.setTaskId(dummyTask.getId());
taskSummary.setTaskName(dummyTask.getName());
taskSummary.setWorkbasketId(dummyWorkbasket.getId());
taskSummary.setWorkbasketName(dummyWorkbasket.getName());
taskSummary.setClassificationId(dummyClassification.getId());
taskSummary.setClassificationName(dummyClassification.getName());
expectedTaskSumamries.add(taskSummary);
List<TaskSummary> actualTaskSumamryResult = taskServiceImpl.getTaskSummariesByWorkbasketId(dummyWorkbasket.getId());
assertThat(actualTaskSumamryResult.size(), equalTo(expectedTaskSumamries.size()));
}
@Test(expected = WorkbasketNotFoundException.class)
public void shouldThrowWorkbasketNotFoundExceptionByNullParameter() throws WorkbasketNotFoundException {
taskServiceImpl.getTaskSummariesByWorkbasketId(null);
}
@Test(expected = WorkbasketNotFoundException.class)
public void shouldThrowWorkbasketNotFoundExceptionByInvalidWorkbasketParameter() throws WorkbasketNotFoundException {
Workbasket wb = new Workbasket();
wb.setName("wb");
workbasketService.createWorkbasket(wb);
taskServiceImpl.getTaskSummariesByWorkbasketId("1");
}
@AfterClass
public static void cleanUpClass() {
FileUtils.deleteRecursive("~/data", true);

17
rest/src/main/java/pro/taskana/rest/RestApplication.java
View File

@ -1,6 +1,9 @@
package pro.taskana.rest;
import com.fasterxml.jackson.databind.cfg.HandlerInstantiator;
import java.sql.SQLException;
import javax.annotation.PostConstruct;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
@ -11,8 +14,10 @@ import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.http.converter.json.SpringHandlerInstantiator;
import com.fasterxml.jackson.databind.cfg.HandlerInstantiator;
import pro.taskana.ClassificationService;
import pro.taskana.SummaryService;
import pro.taskana.TaskService;
import pro.taskana.TaskanaEngine;
import pro.taskana.WorkbasketService;
@ -21,9 +26,6 @@ import pro.taskana.model.Workbasket;
import pro.taskana.rest.serialization.WorkbasketMixIn;
import pro.taskana.sampledata.SampleDataGenerator;
import javax.annotation.PostConstruct;
import java.sql.SQLException;
@SpringBootApplication
public class RestApplication {
@ -48,11 +50,6 @@ public class RestApplication {
return getTaskanaEngine().getWorkbasketService();
}
@Bean
public SummaryService getSummaryService() throws Exception {
return getTaskanaEngine().getSummaryService();
}
@Bean
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
public TaskanaEngine getTaskanaEngine() throws SQLException {

38
rest/src/main/java/pro/taskana/rest/SummaryController.java
View File

@ -1,38 +0,0 @@
package pro.taskana.rest;
import java.util.Collections;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import pro.taskana.SummaryService;
import pro.taskana.model.TaskSummary;
@RestController
@RequestMapping(path = "/v1/summary", produces = { MediaType.APPLICATION_JSON_VALUE })
public class SummaryController {
@Autowired
private SummaryService summaryService;
@RequestMapping(value = "/{workbasketId}/tasks", method = RequestMethod.GET)
public ResponseEntity<List<TaskSummary>> getTasksummariesByWorkbasketId(@PathVariable(value="workbasketId") String workbasketId) {
List<TaskSummary> taskSummaries = null;
try {
taskSummaries = summaryService.getTaskSummariesByWorkbasketId(workbasketId);
return ResponseEntity.status(HttpStatus.OK).body(taskSummaries);
} catch(Exception ex) {
if (taskSummaries == null) {
taskSummaries = Collections.emptyList();
}
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
}

15
rest/src/main/java/pro/taskana/rest/TaskController.java
View File

@ -1,5 +1,6 @@
package pro.taskana.rest;
import java.util.Collections;
import java.util.List;
import javax.security.auth.login.LoginException;
@ -24,6 +25,7 @@ import pro.taskana.exceptions.TaskNotFoundException;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.model.Task;
import pro.taskana.model.TaskState;
import pro.taskana.model.TaskSummary;
import pro.taskana.rest.query.TaskFilter;
@RestController
@ -125,4 +127,17 @@ public class TaskController {
}
}
@RequestMapping(value = "/workbasket/{workbasketId}", method = RequestMethod.GET)
public ResponseEntity<List<TaskSummary>> getTasksummariesByWorkbasketId(@PathVariable(value="workbasketId") String workbasketId) {
List<TaskSummary> taskSummaries = null;
try {
taskSummaries = taskService.getTaskSummariesByWorkbasketId(workbasketId);
return ResponseEntity.status(HttpStatus.OK).body(taskSummaries);
} catch(Exception ex) {
if (taskSummaries == null) {
taskSummaries = Collections.emptyList();
}
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
}