TSK-110: Generate workbasket level report for total count

- Add Report, ReportLine, ReportLineItem and ReportLineItemDefintion
- Create Report in TaskMonitorService by workbaskets and states
- Add unit test and integration tests
- Enable JAAS for the integration tests
This commit is contained in:
Konstantin Kläger 2017-12-18 16:08:31 +01:00 committed by Holger Hagen
parent 429b2327e4
commit 29fccd25e6
10 changed files with 909 additions and 328 deletions

View File

@ -1,51 +1,64 @@
package pro.taskana; package pro.taskana;
import java.util.List; import java.util.List;
import pro.taskana.model.DueWorkbasketCounter; import pro.taskana.model.DueWorkbasketCounter;
import pro.taskana.model.TaskState; import pro.taskana.model.Report;
import pro.taskana.model.TaskStateCounter; import pro.taskana.model.TaskState;
import pro.taskana.model.TaskStateCounter;
/**
* The Task Monitor Service manages operations on tasks regarding the monitoring. /**
*/ * The Task Monitor Service manages operations on tasks regarding the monitoring.
public interface TaskMonitorService { */
public interface TaskMonitorService {
/**
* This method counts all tasks with a given state. /**
* * This method counts all tasks with a given state.
* @param states *
* the countable states * @param states
* @return a List of {@link TaskStateCounter} objects that specifies how many tasks in the specified states exist in * the countable states
* the available work baskets * @return a List of {@link TaskStateCounter} objects that specifies how many tasks in the specified states exist in
*/ * the available work baskets
List<TaskStateCounter> getTaskCountForState(List<TaskState> states); */
List<TaskStateCounter> getTaskCountForState(List<TaskState> states);
/**
* Count all Tasks in a given work basket where the due date is after "daysInPast" days from today in the past and /**
* the tasks are in specified states. * Count all Tasks in a given work basket where the due date is after "daysInPast" days from today in the past and
* * the tasks are in specified states.
* @param workbasketId *
* the id of the work basket * @param workbasketId
* @param daysInPast * the id of the work basket
* identifies the days in the past from today * @param daysInPast
* @param states * identifies the days in the past from today
* {@link List} of {@link TaskState} that identifies the states of the tasks to be searched for * @param states
* @return the number of Task objects in the given work basket that match the query parameters * {@link List} of {@link TaskState} that identifies the states of the tasks to be searched for
*/ * @return the number of Task objects in the given work basket that match the query parameters
long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast, List<TaskState> states); */
long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast, List<TaskState> states);
/**
* Count all Tasks for all work basket objects where the due date is after "daysInPast" days from today in the past /**
* and the tasks are in specified states. * Count all Tasks for all work basket objects where the due date is after "daysInPast" days from today in the past
* * and the tasks are in specified states.
* @param daysInPast *
* identifies the days in the past from today * @param daysInPast
* @param states * identifies the days in the past from today
* {@link List} of {@link TaskState} objects that identifies the states of the tasks searched * @param states
* @return a list of of {@link DueWorkbasketCounter} objects that specifies how many tasks in the requested states * {@link List} of {@link TaskState} objects that identifies the states of the tasks searched
* with appropriate due date exist in the various work baskets * @return a list of of {@link DueWorkbasketCounter} objects that specifies how many tasks in the requested states
*/ * with appropriate due date exist in the various work baskets
List<DueWorkbasketCounter> getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast, List<TaskState> states); */
List<DueWorkbasketCounter> getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast, List<TaskState> states);
}
/**
* Returns a {@link Report} for a given list of {@link Workbasket} objects and for a given list of {@link TaskState}
* objects.
*
* @param workbaskets
* a list of {@link Workbasket} objects
* @param states
* a list of {@link TaskState} objects
* @return a {@link Report} object
*/
Report getWorkbasketLevelReport(List<Workbasket> workbaskets, List<TaskState> states);
}

View File

@ -1,103 +1,131 @@
package pro.taskana.impl; package pro.taskana.impl;
import java.sql.Date; import java.sql.Date;
import java.time.LocalDate; import java.time.LocalDate;
import java.util.List; import java.util.List;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import pro.taskana.TaskMonitorService; import pro.taskana.TaskMonitorService;
import pro.taskana.TaskanaEngine; import pro.taskana.TaskanaEngine;
import pro.taskana.impl.util.LoggerUtils; import pro.taskana.Workbasket;
import pro.taskana.model.DueWorkbasketCounter; import pro.taskana.impl.util.LoggerUtils;
import pro.taskana.model.TaskState; import pro.taskana.model.DueWorkbasketCounter;
import pro.taskana.model.TaskStateCounter; import pro.taskana.model.Report;
import pro.taskana.model.mappings.TaskMonitorMapper; import pro.taskana.model.ReportLine;
import pro.taskana.model.TaskState;
/** import pro.taskana.model.TaskStateCounter;
* This is the implementation of TaskMonitorService. import pro.taskana.model.mappings.TaskMonitorMapper;
*/
public class TaskMonitorServiceImpl implements TaskMonitorService { /**
* This is the implementation of TaskMonitorService.
private static final Logger LOGGER = LoggerFactory.getLogger(TaskMonitorServiceImpl.class); */
public class TaskMonitorServiceImpl implements TaskMonitorService {
private TaskanaEngineImpl taskanaEngineImpl;
private static final Logger LOGGER = LoggerFactory.getLogger(TaskMonitorServiceImpl.class);
private TaskMonitorMapper taskMonitorMapper; private TaskanaEngineImpl taskanaEngineImpl;
private TaskMonitorMapper taskMonitorMapper;
public TaskMonitorServiceImpl(TaskanaEngine taskanaEngine, TaskMonitorMapper taskMonitorMapper) {
super(); public TaskMonitorServiceImpl(TaskanaEngine taskanaEngine, TaskMonitorMapper taskMonitorMapper) {
this.taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine; super();
this.taskMonitorMapper = taskMonitorMapper; this.taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;
} this.taskMonitorMapper = taskMonitorMapper;
}
@Override
public List<TaskStateCounter> getTaskCountForState(List<TaskState> states) { @Override
if (LOGGER.isDebugEnabled()) { public List<TaskStateCounter> getTaskCountForState(List<TaskState> states) {
LOGGER.debug("entry to getTaskCountForState(states = {})", LoggerUtils.listToString(states)); if (LOGGER.isDebugEnabled()) {
} LOGGER.debug("entry to getTaskCountForState(states = {})", LoggerUtils.listToString(states));
List<TaskStateCounter> result = null; }
try { List<TaskStateCounter> result = null;
taskanaEngineImpl.openConnection(); try {
result = taskMonitorMapper.getTaskCountForState(states); taskanaEngineImpl.openConnection();
return result; result = taskMonitorMapper.getTaskCountForState(states);
} finally { return result;
taskanaEngineImpl.returnConnection(); } finally {
if (LOGGER.isDebugEnabled()) { taskanaEngineImpl.returnConnection();
int numberOfResultObjects = result == null ? 0 : result.size(); if (LOGGER.isDebugEnabled()) {
LOGGER.debug("exit from getTaskCountForState(). Returning {} resulting Objects: {} ", int numberOfResultObjects = result == null ? 0 : result.size();
numberOfResultObjects, LoggerUtils.listToString(result)); LOGGER.debug("exit from getTaskCountForState(). Returning {} resulting Objects: {} ",
} numberOfResultObjects, LoggerUtils.listToString(result));
} }
} }
}
@Override
public long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast, @Override
List<TaskState> states) { public long getTaskCountForWorkbasketByDaysInPastAndState(String workbasketId, long daysInPast,
if (LOGGER.isDebugEnabled()) { List<TaskState> states) {
LOGGER.debug( if (LOGGER.isDebugEnabled()) {
"entry to getTaskCountForWorkbasketByDaysInPastAndState(workbasketId {}, daysInPast={}, states = {})", LOGGER.debug(
workbasketId, daysInPast, LoggerUtils.listToString(states)); "entry to getTaskCountForWorkbasketByDaysInPastAndState(workbasketId {}, daysInPast={}, states = {})",
} workbasketId, daysInPast, LoggerUtils.listToString(states));
long result = -1; }
try { long result = -1;
taskanaEngineImpl.openConnection(); try {
LocalDate time = LocalDate.now(); taskanaEngineImpl.openConnection();
time = time.minusDays(daysInPast); LocalDate time = LocalDate.now();
Date fromDate = Date.valueOf(time); time = time.minusDays(daysInPast);
result = taskMonitorMapper.getTaskCountForWorkbasketByDaysInPastAndState(workbasketId, fromDate, states); Date fromDate = Date.valueOf(time);
return result; result = taskMonitorMapper.getTaskCountForWorkbasketByDaysInPastAndState(workbasketId, fromDate, states);
} finally { return result;
taskanaEngineImpl.returnConnection(); } finally {
LOGGER.debug("exit from getTaskCountForWorkbasketByDaysInPastAndState(). Returning result {} ", result); taskanaEngineImpl.returnConnection();
} LOGGER.debug("exit from getTaskCountForWorkbasketByDaysInPastAndState(). Returning result {} ", result);
} }
}
@Override
public List<DueWorkbasketCounter> getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast, @Override
List<TaskState> states) { public List<DueWorkbasketCounter> getTaskCountByWorkbasketAndDaysInPastAndState(long daysInPast,
if (LOGGER.isDebugEnabled()) { List<TaskState> states) {
LOGGER.debug("entry to getTaskCountByWorkbasketAndDaysInPastAndState(daysInPast = {}, states = {})", if (LOGGER.isDebugEnabled()) {
daysInPast, LoggerUtils.listToString(states)); LOGGER.debug("entry to getTaskCountByWorkbasketAndDaysInPastAndState(daysInPast = {}, states = {})",
} daysInPast, LoggerUtils.listToString(states));
List<DueWorkbasketCounter> result = null; }
try { List<DueWorkbasketCounter> result = null;
taskanaEngineImpl.openConnection(); try {
LocalDate time = LocalDate.now(); taskanaEngineImpl.openConnection();
time = time.minusDays(daysInPast); LocalDate time = LocalDate.now();
Date fromDate = Date.valueOf(time); time = time.minusDays(daysInPast);
result = taskMonitorMapper.getTaskCountByWorkbasketIdAndDaysInPastAndState(fromDate, states); Date fromDate = Date.valueOf(time);
return result; result = taskMonitorMapper.getTaskCountByWorkbasketIdAndDaysInPastAndState(fromDate, states);
} finally { return result;
taskanaEngineImpl.returnConnection(); } finally {
if (LOGGER.isDebugEnabled()) { taskanaEngineImpl.returnConnection();
int numberOfResultObjects = result == null ? 0 : result.size(); if (LOGGER.isDebugEnabled()) {
LOGGER.debug( int numberOfResultObjects = result == null ? 0 : result.size();
"exit from getTaskCountByWorkbasketAndDaysInPastAndState(daysInPast,states). Returning {} resulting Objects: {} ", LOGGER.debug(
numberOfResultObjects, LoggerUtils.listToString(result)); "exit from getTaskCountByWorkbasketAndDaysInPastAndState(daysInPast,states). Returning {} resulting Objects: {} ",
} numberOfResultObjects, LoggerUtils.listToString(result));
} }
} }
}
}
@Override
public Report getWorkbasketLevelReport(List<Workbasket> workbaskets, List<TaskState> states) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("entry to getWorkbasketLevelReport(workbaskets = {})", LoggerUtils.listToString(workbaskets));
}
try {
taskanaEngineImpl.openConnection();
Report report = new Report();
report.setDetailLines(taskMonitorMapper.getDetailLinesByWorkbasketIdsAndStates(workbaskets, states));
int sumLineTotalCount = 0;
for (ReportLine reportLine : report.getDetailLines()) {
sumLineTotalCount += reportLine.getTotalCount();
}
ReportLine sumLine = new ReportLine();
sumLine.setName("SumLine");
sumLine.setTotalCount(sumLineTotalCount);
report.setSumLine(sumLine);
return report;
} finally {
taskanaEngineImpl.returnConnection();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("exit from getTaskCountByWorkbaskets().");
}
}
}
}

View File

@ -0,0 +1,35 @@
package pro.taskana.model;
import java.util.ArrayList;
import java.util.List;
/**
* A Report represents a table that consists of {@link ReportLine} objects.
*/
public class Report {
private List<ReportLine> detailLines;
private ReportLine sumLine;
public Report() {
this.detailLines = new ArrayList<>();
this.sumLine = new ReportLine();
}
public List<ReportLine> getDetailLines() {
return detailLines;
}
public void setDetailLines(List<ReportLine> detailLines) {
this.detailLines = detailLines;
}
public ReportLine getSumLine() {
return sumLine;
}
public void setSumLine(ReportLine sumLine) {
this.sumLine = sumLine;
}
}

View File

@ -0,0 +1,44 @@
package pro.taskana.model;
import java.util.ArrayList;
import java.util.List;
/**
* Each ReportLine consists of a name, a list of {@link ReportLineItem} objects and a totalCount that represents the
* count of all tasks.
*/
public class ReportLine {
private String name;
private List<ReportLineItem> lineItems;
private int totalCount;
public ReportLine() {
this.lineItems = new ArrayList<>();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<ReportLineItem> getLineItems() {
return lineItems;
}
public void setLineItems(List<ReportLineItem> lineItems) {
this.lineItems = lineItems;
}
public int getTotalCount() {
return totalCount;
}
public void setTotalCount(int totalCount) {
this.totalCount = totalCount;
}
}

View File

@ -0,0 +1,28 @@
package pro.taskana.model;
/**
* Each ReportLineItem consists of a {@link ReportLineItemDefinition} that defines the upper and lower limits of this
* item and a count value that represents the count of tasks of this item.
*/
public class ReportLineItem {
private ReportLineItemDefinition reportLineItemDefinition;
private int count;
public ReportLineItemDefinition getReportLineItemDefinition() {
return reportLineItemDefinition;
}
public void setReportLineItemDefinition(ReportLineItemDefinition reportLineItemDefinition) {
this.reportLineItemDefinition = reportLineItemDefinition;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}

View File

@ -0,0 +1,28 @@
package pro.taskana.model;
/**
* A ReportLineItemDefinition has a lower and an upper limit which subdivide the count of tasks in a workbasket into
* different sections.
*/
public class ReportLineItemDefinition {
private int lowerLimit;
private int upperLimit;
public int getLowerLimit() {
return lowerLimit;
}
public void setLowerLimit(int lowerLimit) {
this.lowerLimit = lowerLimit;
}
public int getUpperLimit() {
return upperLimit;
}
public void setUpperLimit(int upperLimit) {
this.upperLimit = upperLimit;
}
}

View File

@ -1,52 +1,66 @@
package pro.taskana.model.mappings; package pro.taskana.model.mappings;
import java.sql.Date; import java.sql.Date;
import java.util.List; import java.util.List;
import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Result; import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results; import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select; import org.apache.ibatis.annotations.Select;
import pro.taskana.model.DueWorkbasketCounter; import pro.taskana.Workbasket;
import pro.taskana.model.TaskState; import pro.taskana.model.DueWorkbasketCounter;
import pro.taskana.model.TaskStateCounter; import pro.taskana.model.ReportLine;
import pro.taskana.model.TaskState;
/** import pro.taskana.model.TaskStateCounter;
* This class is the mybatis mapping of task monitoring.
*/ /**
public interface TaskMonitorMapper { * This class is the mybatis mapping of task monitoring.
*/
@Select("<script>" public interface TaskMonitorMapper {
+ "SELECT STATE, COUNT (STATE) as counter "
+ "FROM TASK " @Select("<script>"
+ "WHERE STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>) " + "SELECT STATE, COUNT (STATE) as counter "
+ "GROUP BY STATE" + "FROM TASK "
+ "</script>") + "WHERE STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>) "
@Results({ @Result(column = "STATE", property = "state"), @Result(column = "counter", property = "counter") }) + "GROUP BY STATE"
List<TaskStateCounter> getTaskCountForState(@Param("status") List<TaskState> status); + "</script>")
@Results({ @Result(column = "STATE", property = "state"), @Result(column = "counter", property = "counter") })
@Select("<script>" List<TaskStateCounter> getTaskCountForState(@Param("status") List<TaskState> status);
+ "SELECT COUNT (*) "
+ "FROM TASK " @Select("<script>"
+ "WHERE WORKBASKETID = #{workbasketId} " + "SELECT COUNT (*) "
+ "AND DUE >= #{fromDate} " + "FROM TASK "
+ "AND STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>)" + "WHERE WORKBASKETID = #{workbasketId} "
+ "</script>") + "AND DUE >= #{fromDate} "
long getTaskCountForWorkbasketByDaysInPastAndState(@Param("workbasketId") String workbasketId, + "AND STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>)"
@Param("fromDate") Date fromDate, @Param("status") List<TaskState> states); + "</script>")
long getTaskCountForWorkbasketByDaysInPastAndState(@Param("workbasketId") String workbasketId,
@Select("<script>" @Param("fromDate") Date fromDate, @Param("status") List<TaskState> states);
+ "SELECT CAST(DUE AS DATE) as DUE_DATE, WORKBASKETID, COUNT (*) as counter "
+ "FROM TASK " @Select("<script>"
+ "WHERE DUE >= #{fromDate} " + "SELECT CAST(DUE AS DATE) as DUE_DATE, WORKBASKETID, COUNT (*) as counter "
+ "AND STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>) " + "FROM TASK "
+ "GROUP BY DUE_DATE, WORKBASKETID" + "WHERE DUE >= #{fromDate} "
+ "</script>") + "AND STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>) "
@Results({ @Result(column = "DUE_DATE", property = "due"), + "GROUP BY DUE_DATE, WORKBASKETID"
@Result(column = "WORKBASKETID", property = "workbasketId"), + "</script>")
@Result(column = "counter", property = "taskCounter") }) @Results({ @Result(column = "DUE_DATE", property = "due"),
List<DueWorkbasketCounter> getTaskCountByWorkbasketIdAndDaysInPastAndState(@Param("fromDate") Date fromDate, @Result(column = "WORKBASKETID", property = "workbasketId"),
@Param("status") List<TaskState> states); @Result(column = "counter", property = "taskCounter") })
List<DueWorkbasketCounter> getTaskCountByWorkbasketIdAndDaysInPastAndState(@Param("fromDate") Date fromDate,
} @Param("status") List<TaskState> states);
@Select("<script>"
+ "SELECT WORKBASKET_KEY, COUNT(WORKBASKET_KEY) as counter "
+ "FROM TASK "
+ "WHERE WORKBASKET_KEY IN (<foreach collection='workbaskets' item='workbasket' separator=','>#{workbasket.key}</foreach>) "
+ "AND STATE IN (<foreach collection='status' item='state' separator=','>#{state}</foreach>) "
+ "GROUP BY WORKBASKET_KEY"
+ "</script>")
@Results({ @Result(column = "WORKBASKET_KEY", property = "name"),
@Result(column = "counter", property = "totalCount") })
List<ReportLine> getDetailLinesByWorkbasketIdsAndStates(@Param("workbaskets") List<Workbasket> workbaskets,
@Param("status") List<TaskState> states);
}

View File

@ -1,122 +1,146 @@
package pro.taskana.impl; package pro.taskana.impl;
import static org.hamcrest.core.IsEqual.equalTo; import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.Assert.assertThat; import static org.junit.Assert.assertThat;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times; import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.verifyNoMoreInteractions;
import java.sql.Date; import java.sql.Date;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.List; import java.util.List;
import org.junit.Before; import org.junit.Assert;
import org.junit.Test; import org.junit.Before;
import org.junit.runner.RunWith; import org.junit.Test;
import org.mockito.InjectMocks; import org.junit.runner.RunWith;
import org.mockito.Mock; import org.mockito.InjectMocks;
import org.mockito.Mockito; import org.mockito.Mock;
import org.mockito.MockitoAnnotations; import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner; import org.mockito.MockitoAnnotations;
import org.mockito.junit.MockitoJUnitRunner;
import pro.taskana.WorkbasketService;
import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.Workbasket;
import pro.taskana.model.DueWorkbasketCounter; import pro.taskana.WorkbasketService;
import pro.taskana.model.TaskState; import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.model.TaskStateCounter; import pro.taskana.model.DueWorkbasketCounter;
import pro.taskana.model.mappings.ObjectReferenceMapper; import pro.taskana.model.Report;
import pro.taskana.model.mappings.TaskMonitorMapper; import pro.taskana.model.ReportLine;
import pro.taskana.model.TaskState;
/** import pro.taskana.model.TaskStateCounter;
* Unit Test for TaskMonitorServiceImpl. import pro.taskana.model.mappings.ObjectReferenceMapper;
*/ import pro.taskana.model.mappings.TaskMonitorMapper;
@RunWith(MockitoJUnitRunner.class)
public class TaskMonitorServiceImplTest { /**
* Unit Test for TaskMonitorServiceImpl.
@InjectMocks */
private TaskMonitorServiceImpl cut; @RunWith(MockitoJUnitRunner.class)
public class TaskMonitorServiceImplTest {
@Mock
private TaskanaEngineConfiguration taskanaEngineConfigurationMock; @InjectMocks
private TaskMonitorServiceImpl cut;
@Mock
private TaskanaEngineImpl taskanaEngineMock; @Mock
private TaskanaEngineConfiguration taskanaEngineConfigurationMock;
@Mock
private TaskanaEngineImpl taskanaEngineImpl; @Mock
private TaskanaEngineImpl taskanaEngineMock;
@Mock
private TaskMonitorMapper taskMonitorMapperMock; @Mock
private TaskanaEngineImpl taskanaEngineImpl;
@Mock
private ObjectReferenceMapper objectReferenceMapperMock; @Mock
private TaskMonitorMapper taskMonitorMapperMock;
@Mock
private WorkbasketService workbasketServiceMock; @Mock
private ObjectReferenceMapper objectReferenceMapperMock;
@Before
public void setup() { @Mock
MockitoAnnotations.initMocks(this); private WorkbasketService workbasketServiceMock;
Mockito.doNothing().when(taskanaEngineImpl).openConnection();
Mockito.doNothing().when(taskanaEngineImpl).returnConnection(); @Before
} public void setup() {
MockitoAnnotations.initMocks(this);
@Test Mockito.doNothing().when(taskanaEngineImpl).openConnection();
public void testGetTaskCountForState() { Mockito.doNothing().when(taskanaEngineImpl).returnConnection();
List<TaskState> taskStates = Arrays.asList(TaskState.CLAIMED, TaskState.COMPLETED); }
List<TaskStateCounter> expectedResult = new ArrayList<>();
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountForState(taskStates); @Test
public void testGetTaskCountForState() {
List<TaskStateCounter> actualResult = cut.getTaskCountForState(taskStates); List<TaskState> taskStates = Arrays.asList(TaskState.CLAIMED, TaskState.COMPLETED);
List<TaskStateCounter> expectedResult = new ArrayList<>();
verify(taskanaEngineImpl, times(1)).openConnection(); doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountForState(taskStates);
verify(taskMonitorMapperMock, times(1)).getTaskCountForState(taskStates);
verify(taskanaEngineImpl, times(1)).returnConnection(); List<TaskStateCounter> actualResult = cut.getTaskCountForState(taskStates);
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock); verify(taskanaEngineImpl, times(1)).openConnection();
assertThat(actualResult, equalTo(expectedResult)); verify(taskMonitorMapperMock, times(1)).getTaskCountForState(taskStates);
} verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
@Test taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
public void testGetTaskCountForWorkbasketByDaysInPastAndState() { assertThat(actualResult, equalTo(expectedResult));
List<TaskState> taskStates = Arrays.asList(TaskState.CLAIMED, TaskState.COMPLETED); }
final long daysInPast = 10L;
final long expectedResult = 5L; @Test
String workbasketId = "1"; public void testGetTaskCountForWorkbasketByDaysInPastAndState() {
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountForWorkbasketByDaysInPastAndState(any(), any(), List<TaskState> taskStates = Arrays.asList(TaskState.CLAIMED, TaskState.COMPLETED);
any()); final long daysInPast = 10L;
final long expectedResult = 5L;
long actualResult = cut.getTaskCountForWorkbasketByDaysInPastAndState(workbasketId, daysInPast, taskStates); String workbasketId = "1";
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountForWorkbasketByDaysInPastAndState(any(), any(),
verify(taskanaEngineImpl, times(1)).openConnection(); any());
verify(taskMonitorMapperMock, times(1)).getTaskCountForWorkbasketByDaysInPastAndState(any(), any(), any());
verify(taskanaEngineImpl, times(1)).returnConnection(); long actualResult = cut.getTaskCountForWorkbasketByDaysInPastAndState(workbasketId, daysInPast, taskStates);
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock); verify(taskanaEngineImpl, times(1)).openConnection();
assertThat(actualResult, equalTo(expectedResult)); verify(taskMonitorMapperMock, times(1)).getTaskCountForWorkbasketByDaysInPastAndState(any(), any(), any());
} verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
@Test taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
public void testGetTaskCountByWorkbasketAndDaysInPastAndState() { assertThat(actualResult, equalTo(expectedResult));
final long daysInPast = 10L; }
List<TaskState> taskStates = Arrays.asList(TaskState.CLAIMED, TaskState.COMPLETED);
List<DueWorkbasketCounter> expectedResult = new ArrayList<>(); @Test
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountByWorkbasketIdAndDaysInPastAndState( public void testGetTaskCountByWorkbasketAndDaysInPastAndState() {
any(Date.class), final long daysInPast = 10L;
any()); List<TaskState> taskStates = Arrays.asList(TaskState.CLAIMED, TaskState.COMPLETED);
List<DueWorkbasketCounter> expectedResult = new ArrayList<>();
List<DueWorkbasketCounter> actualResult = cut.getTaskCountByWorkbasketAndDaysInPastAndState(daysInPast, doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountByWorkbasketIdAndDaysInPastAndState(
taskStates); any(Date.class),
any());
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskMonitorMapperMock, times(1)).getTaskCountByWorkbasketIdAndDaysInPastAndState(any(Date.class), any()); List<DueWorkbasketCounter> actualResult = cut.getTaskCountByWorkbasketAndDaysInPastAndState(daysInPast,
verify(taskanaEngineImpl, times(1)).returnConnection(); taskStates);
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock); verify(taskanaEngineImpl, times(1)).openConnection();
assertThat(actualResult, equalTo(expectedResult)); verify(taskMonitorMapperMock, times(1)).getTaskCountByWorkbasketIdAndDaysInPastAndState(any(Date.class), any());
} verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
} taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
assertThat(actualResult, equalTo(expectedResult));
}
@Test
public void testGetWorkbasketLevelReport() {
List<Workbasket> workbaskets = Arrays.asList(new WorkbasketImpl(), new WorkbasketImpl());
List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
Report expectedResult = new Report();
List<ReportLine> expectedDetailLines = new ArrayList<>();
doReturn(expectedDetailLines).when(taskMonitorMapperMock).getDetailLinesByWorkbasketIdsAndStates(any(), any());
Report actualResult = cut.getWorkbasketLevelReport(workbaskets, states);
verify(taskanaEngineImpl, times(1)).openConnection();
verify(taskMonitorMapperMock, times(1)).getDetailLinesByWorkbasketIdsAndStates(any(), any());
verify(taskanaEngineImpl, times(1)).returnConnection();
verifyNoMoreInteractions(taskanaEngineConfigurationMock, taskanaEngineMock, taskanaEngineImpl,
taskMonitorMapperMock, objectReferenceMapperMock, workbasketServiceMock);
Assert.assertNotNull(actualResult);
assertThat(actualResult.getDetailLines(), equalTo(expectedResult.getDetailLines()));
}
}

View File

@ -0,0 +1,179 @@
package pro.taskana.impl.integration;
import java.io.FileNotFoundException;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import javax.security.auth.login.LoginException;
import javax.sql.DataSource;
import org.h2.store.fs.FileUtils;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import pro.taskana.Classification;
import pro.taskana.ClassificationService;
import pro.taskana.TaskMonitorService;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.Workbasket;
import pro.taskana.WorkbasketService;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.InvalidOwnerException;
import pro.taskana.exceptions.InvalidStateException;
import pro.taskana.exceptions.InvalidWorkbasketException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.exceptions.TaskAlreadyExistException;
import pro.taskana.exceptions.TaskNotFoundException;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.impl.JunitHelper;
import pro.taskana.impl.TaskImpl;
import pro.taskana.impl.TaskServiceImpl;
import pro.taskana.impl.TaskanaEngineImpl;
import pro.taskana.impl.WorkbasketImpl;
import pro.taskana.impl.configuration.DBCleaner;
import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest;
import pro.taskana.impl.util.IdGenerator;
import pro.taskana.model.Report;
import pro.taskana.model.TaskState;
import pro.taskana.model.WorkbasketAccessItem;
import pro.taskana.model.WorkbasketType;
import pro.taskana.security.JAASRunner;
import pro.taskana.security.WithAccessId;
/**
* Integration Test for TaskMonitorServiceImpl transactions with connection management mode AUTOCOMMIT.
*/
@RunWith(JAASRunner.class)
public class TaskMonitorServiceImplIntAutocommitTest {
private DataSource dataSource;
private TaskServiceImpl taskServiceImpl;
private TaskanaEngineConfiguration taskanaEngineConfiguration;
private TaskanaEngine taskanaEngine;
private TaskanaEngineImpl taskanaEngineImpl;
private ClassificationService classificationService;
private WorkbasketService workBasketService;
private TaskMonitorService taskMonitorService;
@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);
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
taskServiceImpl = (TaskServiceImpl) taskanaEngine.getTaskService();
taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;
classificationService = taskanaEngine.getClassificationService();
taskanaEngineImpl.setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT);
workBasketService = taskanaEngine.getWorkbasketService();
taskMonitorService = taskanaEngine.getTaskMonitorService();
DBCleaner cleaner = new DBCleaner();
cleaner.clearDb(dataSource, false);
}
@WithAccessId(userName = "Elena")
@Test
public void testGetWorkbasketLevelReport() throws ClassificationAlreadyExistException, WorkbasketNotFoundException,
ClassificationNotFoundException, NotAuthorizedException, TaskAlreadyExistException, InvalidWorkbasketException,
InvalidArgumentException, TaskNotFoundException, InvalidStateException, InvalidOwnerException {
generateSampleAccessItems();
WorkbasketImpl workbasket1 = (WorkbasketImpl) workBasketService.newWorkbasket();
workbasket1.setName("wb1");
workbasket1.setId("1");
workbasket1.setKey("1");
workbasket1.setDomain("novatec");
workbasket1.setType(WorkbasketType.GROUP);
workBasketService.createWorkbasket(workbasket1);
WorkbasketImpl workbasket2 = (WorkbasketImpl) workBasketService.newWorkbasket();
workbasket2.setName("wb2");
workbasket2.setId("2");
workbasket2.setKey("2");
workbasket2.setDomain("novatec");
workbasket2.setType(WorkbasketType.GROUP);
workBasketService.createWorkbasket(workbasket2);
Classification classification = classificationService.newClassification();
classification.setKey("TEST");
classification.setDomain("novatec");
classificationService.createClassification(classification);
TaskImpl task1 = (TaskImpl) taskServiceImpl.newTask();
task1.setWorkbasketKey(workbasket1.getKey());
task1.setClassificationKey(classification.getKey());
task1.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
task1 = (TaskImpl) taskServiceImpl.createTask(task1);
TaskImpl task2 = (TaskImpl) taskServiceImpl.newTask();
task2.setWorkbasketKey(workbasket2.getKey());
task2.setClassificationKey(classification.getKey());
task2.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
task2 = (TaskImpl) taskServiceImpl.createTask(task2);
TaskImpl task3 = (TaskImpl) taskServiceImpl.newTask();
task3.setWorkbasketKey(workbasket2.getKey());
task3.setClassificationKey(classification.getKey());
task3.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
task3 = (TaskImpl) taskServiceImpl.createTask(task3);
List<Workbasket> workbaskets = Arrays.asList(workbasket1, workbasket2);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
Report report = taskMonitorService.getWorkbasketLevelReport(workbaskets, states);
int countWorkbasket1 = report.getDetailLines().get(0).getTotalCount();
int countWorkbasket2 = report.getDetailLines().get(1).getTotalCount();
int totalCount = report.getSumLine().getTotalCount();
Assert.assertNotNull(report);
Assert.assertEquals(countWorkbasket1, 1);
Assert.assertEquals(countWorkbasket2, 2);
Assert.assertEquals(countWorkbasket1 + countWorkbasket2, totalCount);
}
private void generateSampleAccessItems() {
WorkbasketAccessItem accessItem = new WorkbasketAccessItem();
accessItem.setId(IdGenerator.generateWithPrefix("WAI"));
accessItem.setWorkbasketKey("1");
accessItem.setAccessId("Elena");
accessItem.setPermAppend(true);
accessItem.setPermRead(true);
workBasketService.createWorkbasketAuthorization(accessItem);
WorkbasketAccessItem accessItem2 = new WorkbasketAccessItem();
accessItem2.setId(IdGenerator.generateWithPrefix("WAI"));
accessItem2.setWorkbasketKey("2");
accessItem2.setAccessId("Elena");
accessItem2.setPermAppend(true);
accessItem2.setPermRead(true);
workBasketService.createWorkbasketAuthorization(accessItem2);
}
@After
public void cleanUp() {
taskanaEngineImpl.setConnection(null);
}
@AfterClass
public static void cleanUpClass() {
FileUtils.deleteRecursive("~/data", true);
}
}

View File

@ -0,0 +1,188 @@
package pro.taskana.impl.integration;
import java.io.FileNotFoundException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import javax.security.auth.login.LoginException;
import javax.sql.DataSource;
import org.h2.store.fs.FileUtils;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import pro.taskana.Classification;
import pro.taskana.ClassificationService;
import pro.taskana.TaskMonitorService;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.Workbasket;
import pro.taskana.WorkbasketService;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.InvalidOwnerException;
import pro.taskana.exceptions.InvalidStateException;
import pro.taskana.exceptions.InvalidWorkbasketException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.exceptions.TaskAlreadyExistException;
import pro.taskana.exceptions.TaskNotFoundException;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.impl.JunitHelper;
import pro.taskana.impl.TaskImpl;
import pro.taskana.impl.TaskServiceImpl;
import pro.taskana.impl.TaskanaEngineImpl;
import pro.taskana.impl.WorkbasketImpl;
import pro.taskana.impl.configuration.DBCleaner;
import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest;
import pro.taskana.impl.util.IdGenerator;
import pro.taskana.model.Report;
import pro.taskana.model.TaskState;
import pro.taskana.model.WorkbasketAccessItem;
import pro.taskana.model.WorkbasketType;
import pro.taskana.security.JAASRunner;
import pro.taskana.security.WithAccessId;
/**
* Integration Test for TaskMonitorServiceImpl transactions with connection management mode EXPLICIT.
*/
@RunWith(JAASRunner.class)
public class TaskMonitorServiceImplIntExplicitTest {
private DataSource dataSource;
private TaskServiceImpl taskServiceImpl;
private TaskanaEngineConfiguration taskanaEngineConfiguration;
private TaskanaEngine taskanaEngine;
private TaskanaEngineImpl taskanaEngineImpl;
private ClassificationService classificationService;
private WorkbasketService workBasketService;
private TaskMonitorService taskMonitorService;
@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);
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
taskServiceImpl = (TaskServiceImpl) taskanaEngine.getTaskService();
taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;
classificationService = taskanaEngine.getClassificationService();
taskanaEngineImpl.setConnectionManagementMode(ConnectionManagementMode.EXPLICIT);
workBasketService = taskanaEngine.getWorkbasketService();
DBCleaner cleaner = new DBCleaner();
cleaner.clearDb(dataSource, false);
}
@WithAccessId(userName = "Elena")
@Test
public void testGetWorkbasketLevelReport() throws SQLException, ClassificationAlreadyExistException,
WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException, TaskNotFoundException,
TaskAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException, InvalidOwnerException,
InvalidStateException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
taskMonitorService = taskanaEngine.getTaskMonitorService();
generateSampleAccessItems();
WorkbasketImpl workbasket1 = (WorkbasketImpl) workBasketService.newWorkbasket();
workbasket1.setName("wb1");
workbasket1.setId("1");
workbasket1.setKey("1");
workbasket1.setDomain("novatec");
workbasket1.setType(WorkbasketType.GROUP);
workBasketService.createWorkbasket(workbasket1);
WorkbasketImpl workbasket2 = (WorkbasketImpl) workBasketService.newWorkbasket();
workbasket2.setName("wb2");
workbasket2.setId("2");
workbasket2.setKey("2");
workbasket2.setDomain("novatec");
workbasket2.setType(WorkbasketType.GROUP);
workBasketService.createWorkbasket(workbasket2);
Classification classification = classificationService.newClassification();
classification.setKey("TEST");
classification.setDomain("novatec");
classificationService.createClassification(classification);
TaskImpl task1 = (TaskImpl) taskServiceImpl.newTask();
task1.setWorkbasketKey(workbasket1.getKey());
task1.setClassificationKey(classification.getKey());
task1.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
task1 = (TaskImpl) taskServiceImpl.createTask(task1);
connection.commit();
TaskImpl task2 = (TaskImpl) taskServiceImpl.newTask();
task2.setWorkbasketKey(workbasket2.getId());
task2.setClassificationKey(classification.getKey());
task2.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
task2 = (TaskImpl) taskServiceImpl.createTask(task2);
connection.commit();
TaskImpl task3 = (TaskImpl) taskServiceImpl.newTask();
task3.setWorkbasketKey(workbasket2.getId());
task3.setClassificationKey(classification.getKey());
task3.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
task3 = (TaskImpl) taskServiceImpl.createTask(task3);
connection.commit();
List<Workbasket> workbaskets = Arrays.asList(workbasket1, workbasket2);
List<TaskState> states = Arrays.asList(TaskState.READY, TaskState.CLAIMED);
Report report = taskMonitorService.getWorkbasketLevelReport(workbaskets, states);
int countWorkbasket1 = report.getDetailLines().get(0).getTotalCount();
int countWorkbasket2 = report.getDetailLines().get(1).getTotalCount();
int totalCount = report.getSumLine().getTotalCount();
Assert.assertNotNull(report);
Assert.assertEquals(countWorkbasket1, 1);
Assert.assertEquals(countWorkbasket2, 2);
Assert.assertEquals(countWorkbasket1 + countWorkbasket2, totalCount);
connection.commit();
}
private void generateSampleAccessItems() {
WorkbasketAccessItem accessItem = new WorkbasketAccessItem();
accessItem.setId(IdGenerator.generateWithPrefix("WAI"));
accessItem.setWorkbasketKey("1");
accessItem.setAccessId("Elena");
accessItem.setPermAppend(true);
accessItem.setPermRead(true);
workBasketService.createWorkbasketAuthorization(accessItem);
WorkbasketAccessItem accessItem2 = new WorkbasketAccessItem();
accessItem2.setId(IdGenerator.generateWithPrefix("WAI"));
accessItem2.setWorkbasketKey("2");
accessItem2.setAccessId("Elena");
accessItem2.setPermAppend(true);
accessItem2.setPermRead(true);
workBasketService.createWorkbasketAuthorization(accessItem2);
}
@After
public void cleanUp() {
taskanaEngineImpl.setConnection(null);
}
@AfterClass
public static void cleanUpClass() {
FileUtils.deleteRecursive("~/data", true);
}
}