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

Change doReturn(...).when(...) to typesafe when(...).thenReturn(...) for mocks

This commit is contained in:
Dennis Pietruck 2019-04-29 09:02:31 +02:00 committed by Mustapha Zorgati
parent 7720baaa2b
commit f433f8e474
11 changed files with 139 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
lib/taskana-core/src/test/java/pro/taskana/impl/CategoryReportBuilderImplTest.java
View File

@ -4,7 +4,6 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.eq;
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;
@ -31,8 +30,8 @@ import pro.taskana.TaskState;
import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.InvalidArgumentException; import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.impl.report.item.MonitorQueryItem;
import pro.taskana.impl.report.header.TimeIntervalColumnHeader; import pro.taskana.impl.report.header.TimeIntervalColumnHeader;
import pro.taskana.impl.report.item.MonitorQueryItem;
import pro.taskana.mappings.TaskMonitorMapper; import pro.taskana.mappings.TaskMonitorMapper;
import pro.taskana.report.CategoryReport; import pro.taskana.report.CategoryReport;
@ -59,9 +58,9 @@ public class CategoryReportBuilderImplTest {
MockitoAnnotations.initMocks(this); MockitoAnnotations.initMocks(this);
Mockito.doNothing().when(taskanaEngineImplMock).openConnection(); Mockito.doNothing().when(taskanaEngineImplMock).openConnection();
Mockito.doNothing().when(taskanaEngineImplMock).returnConnection(); Mockito.doNothing().when(taskanaEngineImplMock).returnConnection();
doReturn(taskanaEngineConfiguration).when(taskanaEngineImplMock).getConfiguration(); when(taskanaEngineImplMock.getConfiguration()).thenReturn(taskanaEngineConfiguration);
doReturn(true).when(taskanaEngineConfiguration).isGermanPublicHolidaysEnabled(); when(taskanaEngineConfiguration.isGermanPublicHolidaysEnabled()).thenReturn(true);
doReturn(null).when(taskanaEngineConfiguration).getCustomHolidays(); when(taskanaEngineConfiguration.getCustomHolidays()).thenReturn(null);
} }
@Test @Test
@ -80,8 +79,8 @@ public class CategoryReportBuilderImplTest {
monitorQueryItem.setKey("EXTERN"); monitorQueryItem.setKey("EXTERN");
monitorQueryItem.setNumberOfTasks(1); monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem); expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfCategories(workbasketIds, states, categories, when(taskMonitorMapperMock.getTaskCountOfCategories(workbasketIds, states, categories, domains,
domains, classificationIds, excludedClassificationIds, customAttributeFilter); classificationIds, excludedClassificationIds, customAttributeFilter)).thenReturn(expectedResult);
CategoryReport actualResult = cut.createCategoryReportBuilder() CategoryReport actualResult = cut.createCategoryReportBuilder()
.workbasketIdIn(workbasketIds) .workbasketIdIn(workbasketIds)
@ -128,8 +127,9 @@ public class CategoryReportBuilderImplTest {
monitorQueryItem.setAgeInDays(0); monitorQueryItem.setAgeInDays(0);
monitorQueryItem.setNumberOfTasks(1); monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem); expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfCategories(workbasketIds, states, categories, when(taskMonitorMapperMock.getTaskCountOfCategories(workbasketIds, states, categories, domains,
domains, classificationIds, excludedClassificationIds, customAttributeFilter); classificationIds,
excludedClassificationIds, customAttributeFilter)).thenReturn(expectedResult);
CategoryReport actualResult = cut.createCategoryReportBuilder() CategoryReport actualResult = cut.createCategoryReportBuilder()
.workbasketIdIn(workbasketIds) .workbasketIdIn(workbasketIds)

23
lib/taskana-core/src/test/java/pro/taskana/impl/ClassificationReportBuilderImplTest.java
View File

@ -4,7 +4,6 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.eq;
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;
@ -62,9 +61,9 @@ public class ClassificationReportBuilderImplTest {
MockitoAnnotations.initMocks(this); MockitoAnnotations.initMocks(this);
Mockito.doNothing().when(taskanaEngineImplMock).openConnection(); Mockito.doNothing().when(taskanaEngineImplMock).openConnection();
Mockito.doNothing().when(taskanaEngineImplMock).returnConnection(); Mockito.doNothing().when(taskanaEngineImplMock).returnConnection();
doReturn(taskanaEngineConfiguration).when(taskanaEngineImplMock).getConfiguration(); when(taskanaEngineImplMock.getConfiguration()).thenReturn(taskanaEngineConfiguration);
doReturn(true).when(taskanaEngineConfiguration).isGermanPublicHolidaysEnabled(); when(taskanaEngineConfiguration.isGermanPublicHolidaysEnabled()).thenReturn(true);
doReturn(null).when(taskanaEngineConfiguration).getCustomHolidays(); when(taskanaEngineConfiguration.getCustomHolidays()).thenReturn(null);
} }
@Test @Test
@ -83,8 +82,8 @@ public class ClassificationReportBuilderImplTest {
monitorQueryItem.setKey("CLI:000000000000000000000000000000000001"); monitorQueryItem.setKey("CLI:000000000000000000000000000000000001");
monitorQueryItem.setNumberOfTasks(1); monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem); expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfClassifications(workbasketIds, states, when(taskMonitorMapperMock.getTaskCountOfClassifications(workbasketIds, states, categories, domains,
categories, domains, classificationIds, excludedClassificationIds, customAttributeFilter); classificationIds, excludedClassificationIds, customAttributeFilter)).thenReturn(expectedResult);
ClassificationReport actualResult = cut.createClassificationReportBuilder() ClassificationReport actualResult = cut.createClassificationReportBuilder()
.workbasketIdIn(workbasketIds) .workbasketIdIn(workbasketIds)
@ -133,8 +132,8 @@ public class ClassificationReportBuilderImplTest {
monitorQueryItem.setAgeInDays(0); monitorQueryItem.setAgeInDays(0);
monitorQueryItem.setNumberOfTasks(1); monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem); expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfClassifications(workbasketIds, states, when(taskMonitorMapperMock.getTaskCountOfClassifications(workbasketIds, states, categories, domains,
categories, domains, classificationIds, excludedClassificationIds, customAttributeFilter); classificationIds, excludedClassificationIds, customAttributeFilter)).thenReturn(expectedResult);
ClassificationReport actualResult = cut.createClassificationReportBuilder() ClassificationReport actualResult = cut.createClassificationReportBuilder()
.workbasketIdIn(workbasketIds) .workbasketIdIn(workbasketIds)
@ -182,8 +181,8 @@ public class ClassificationReportBuilderImplTest {
detailedMonitorQueryItem.setAttachmentKey("CLI:000000000000000000000000000000000006"); detailedMonitorQueryItem.setAttachmentKey("CLI:000000000000000000000000000000000006");
detailedMonitorQueryItem.setNumberOfTasks(1); detailedMonitorQueryItem.setNumberOfTasks(1);
expectedResult.add(detailedMonitorQueryItem); expectedResult.add(detailedMonitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfDetailedClassifications(workbasketIds, when(taskMonitorMapperMock.getTaskCountOfDetailedClassifications(workbasketIds, states, categories, domains,
states, categories, domains, classificationIds, excludedClassificationIds, customAttributeFilter); classificationIds, excludedClassificationIds, customAttributeFilter)).thenReturn(expectedResult);
DetailedClassificationReport actualResult = cut.createClassificationReportBuilder() DetailedClassificationReport actualResult = cut.createClassificationReportBuilder()
.workbasketIdIn(workbasketIds) .workbasketIdIn(workbasketIds)
@ -234,8 +233,8 @@ public class ClassificationReportBuilderImplTest {
detailedMonitorQueryItem.setAgeInDays(0); detailedMonitorQueryItem.setAgeInDays(0);
detailedMonitorQueryItem.setNumberOfTasks(1); detailedMonitorQueryItem.setNumberOfTasks(1);
expectedResult.add(detailedMonitorQueryItem); expectedResult.add(detailedMonitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfDetailedClassifications(workbasketIds, when(taskMonitorMapperMock.getTaskCountOfDetailedClassifications(workbasketIds, states, categories, domains,
states, categories, domains, classificationIds, excludedClassificationIds, customAttributeFilter); classificationIds, excludedClassificationIds, customAttributeFilter)).thenReturn(expectedResult);
DetailedClassificationReport actualResult = cut.createClassificationReportBuilder() DetailedClassificationReport actualResult = cut.createClassificationReportBuilder()
.workbasketIdIn(workbasketIds) .workbasketIdIn(workbasketIds)

4
lib/taskana-core/src/test/java/pro/taskana/impl/ClassificationServiceImplTest.java
View File

@ -3,8 +3,8 @@ package pro.taskana.impl;
import static junit.framework.TestCase.assertEquals; import static junit.framework.TestCase.assertEquals;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import java.util.List; import java.util.List;
@ -67,7 +67,7 @@ public class ClassificationServiceImplTest {
NotAuthorizedException, ClassificationAlreadyExistException { NotAuthorizedException, ClassificationAlreadyExistException {
try { try {
Classification classification = createDummyClassification(); Classification classification = createDummyClassification();
doReturn(true).when(taskanaEngineImplMock).domainExists(any()); when(taskanaEngineImplMock.domainExists(any())).thenReturn(true);
cutSpy.createClassification(classification); cutSpy.createClassification(classification);
} catch (InvalidArgumentException e) { } catch (InvalidArgumentException e) {
assertEquals(e.getMessage(), "ClassificationId should be null on creation"); assertEquals(e.getMessage(), "ClassificationId should be null on creation");

21
lib/taskana-core/src/test/java/pro/taskana/impl/CustomFieldValueReportBuilderImplTest.java
View File

@ -3,7 +3,6 @@ package pro.taskana.impl;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
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;
@ -30,8 +29,8 @@ import pro.taskana.TaskState;
import pro.taskana.configuration.TaskanaEngineConfiguration; import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.InvalidArgumentException; import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.impl.report.item.MonitorQueryItem;
import pro.taskana.impl.report.header.TimeIntervalColumnHeader; import pro.taskana.impl.report.header.TimeIntervalColumnHeader;
import pro.taskana.impl.report.item.MonitorQueryItem;
import pro.taskana.mappings.TaskMonitorMapper; import pro.taskana.mappings.TaskMonitorMapper;
import pro.taskana.report.CustomFieldValueReport; import pro.taskana.report.CustomFieldValueReport;
@ -58,9 +57,9 @@ public class CustomFieldValueReportBuilderImplTest {
MockitoAnnotations.initMocks(this); MockitoAnnotations.initMocks(this);
Mockito.doNothing().when(taskanaEngineImplMock).openConnection(); Mockito.doNothing().when(taskanaEngineImplMock).openConnection();
Mockito.doNothing().when(taskanaEngineImplMock).returnConnection(); Mockito.doNothing().when(taskanaEngineImplMock).returnConnection();
doReturn(taskanaEngineConfiguration).when(taskanaEngineImplMock).getConfiguration(); when(taskanaEngineImplMock.getConfiguration()).thenReturn(taskanaEngineConfiguration);
doReturn(true).when(taskanaEngineConfiguration).isGermanPublicHolidaysEnabled(); when(taskanaEngineConfiguration.isGermanPublicHolidaysEnabled()).thenReturn(true);
doReturn(null).when(taskanaEngineConfiguration).getCustomHolidays(); when(taskanaEngineConfiguration.getCustomHolidays()).thenReturn(null);
} }
@Test @Test
@ -79,9 +78,9 @@ public class CustomFieldValueReportBuilderImplTest {
monitorQueryItem.setKey("Geschaeftsstelle A"); monitorQueryItem.setKey("Geschaeftsstelle A");
monitorQueryItem.setNumberOfTasks(1); monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem); expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock) when(taskMonitorMapperMock.getTaskCountOfCustomFieldValues(CustomField.CUSTOM_1, workbasketIds, states,
.getTaskCountOfCustomFieldValues(CustomField.CUSTOM_1, workbasketIds, states, categories, domains, categories,
classificationIds, excludedClassificationIds, customAttributeFilter); domains, classificationIds, excludedClassificationIds, customAttributeFilter)).thenReturn(expectedResult);
CustomFieldValueReport actualResult = cut.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1) CustomFieldValueReport actualResult = cut.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.workbasketIdIn(workbasketIds) .workbasketIdIn(workbasketIds)
@ -129,9 +128,9 @@ public class CustomFieldValueReportBuilderImplTest {
monitorQueryItem.setAgeInDays(0); monitorQueryItem.setAgeInDays(0);
monitorQueryItem.setNumberOfTasks(1); monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem); expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock) when(taskMonitorMapperMock.getTaskCountOfCustomFieldValues(CustomField.CUSTOM_1, workbasketIds, states,
.getTaskCountOfCustomFieldValues(CustomField.CUSTOM_1, workbasketIds, states, categories, domains, categories,
classificationIds, excludedClassificationIds, customAttributeFilter); domains, classificationIds, excludedClassificationIds, customAttributeFilter)).thenReturn(expectedResult);
CustomFieldValueReport actualResult = cut.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1) CustomFieldValueReport actualResult = cut.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.workbasketIdIn(workbasketIds) .workbasketIdIn(workbasketIds)

1
lib/taskana-core/src/test/java/pro/taskana/impl/ObjectReferenceQueryImplTest.java
View File

@ -15,6 +15,7 @@ import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner; import org.mockito.junit.MockitoJUnitRunner;
import pro.taskana.ObjectReference; import pro.taskana.ObjectReference;
/** /**
* Test for ObjectReferenceQueryImpl. * Test for ObjectReferenceQueryImpl.
* *

30
lib/taskana-core/src/test/java/pro/taskana/impl/TaskQueryImplTest.java
View File

@ -1,7 +1,6 @@
package pro.taskana.impl; package pro.taskana.impl;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
import java.util.ArrayList; import java.util.ArrayList;
@ -29,23 +28,18 @@ import pro.taskana.TaskSummary;
@RunWith(MockitoJUnitRunner.class) @RunWith(MockitoJUnitRunner.class)
public class TaskQueryImplTest { public class TaskQueryImplTest {
@InjectMocks
private TaskQueryImpl taskQueryImpl;
@Mock
private TaskanaEngineImpl taskanaEngine;
@Mock
private SqlSession sqlSession;
@Mock
private SqlSessionManager sqlSessionManager;
@Mock @Mock
ClassificationServiceImpl classificationService; ClassificationServiceImpl classificationService;
@Mock @Mock
TaskServiceImpl taskServiceMock; TaskServiceImpl taskServiceMock;
@InjectMocks
private TaskQueryImpl taskQueryImpl;
@Mock
private TaskanaEngineImpl taskanaEngine;
@Mock
private SqlSession sqlSession;
@Mock
private SqlSessionManager sqlSessionManager;
@Before @Before
public void setup() { public void setup() {
@ -65,7 +59,7 @@ public class TaskQueryImplTest {
when(sqlSession.selectList(any(), any())).thenReturn(new ArrayList<>()); when(sqlSession.selectList(any(), any())).thenReturn(new ArrayList<>());
List<TaskSummary> intermediate = new ArrayList<>(); List<TaskSummary> intermediate = new ArrayList<>();
intermediate.add(new TaskSummaryImpl()); intermediate.add(new TaskSummaryImpl());
doReturn(intermediate).when(taskServiceMock).augmentTaskSummariesByContainedSummaries(any()); when(taskServiceMock.augmentTaskSummariesByContainedSummaries(any())).thenReturn(intermediate);
List<TaskSummary> result = taskQueryImpl.nameIn("test", "asd", "blubber") List<TaskSummary> result = taskQueryImpl.nameIn("test", "asd", "blubber")
.priorityIn(1, 2) .priorityIn(1, 2)
@ -80,7 +74,7 @@ public class TaskQueryImplTest {
when(sqlSession.selectList(any(), any(), any())).thenReturn(new ArrayList<>()); when(sqlSession.selectList(any(), any(), any())).thenReturn(new ArrayList<>());
List<TaskSummary> intermediate = new ArrayList<>(); List<TaskSummary> intermediate = new ArrayList<>();
intermediate.add(new TaskSummaryImpl()); intermediate.add(new TaskSummaryImpl());
doReturn(intermediate).when(taskServiceMock).augmentTaskSummariesByContainedSummaries(any()); when(taskServiceMock.augmentTaskSummariesByContainedSummaries(any())).thenReturn(intermediate);
List<TaskSummary> result = taskQueryImpl.nameIn("test", "asd", "blubber") List<TaskSummary> result = taskQueryImpl.nameIn("test", "asd", "blubber")
.priorityIn(1, 2) .priorityIn(1, 2)
@ -95,8 +89,8 @@ public class TaskQueryImplTest {
when(sqlSession.selectOne(any(), any())).thenReturn(new TaskSummaryImpl()); when(sqlSession.selectOne(any(), any())).thenReturn(new TaskSummaryImpl());
List<TaskSummary> intermediate = new ArrayList<>(); List<TaskSummary> intermediate = new ArrayList<>();
intermediate.add(new TaskSummaryImpl()); intermediate.add(new TaskSummaryImpl());
doReturn(intermediate).when(taskServiceMock).augmentTaskSummariesByContainedSummaries(any());
// when(taskServiceMock.augmentTaskSummariesByContainedSummaries(any())).thenReturn(intermediate); when(taskServiceMock.augmentTaskSummariesByContainedSummaries(any())).thenReturn(intermediate);
TaskSummary result = taskQueryImpl.nameIn("test", "asd", "blubber") TaskSummary result = taskQueryImpl.nameIn("test", "asd", "blubber")
.priorityIn(1, 2) .priorityIn(1, 2)

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

@ -15,6 +15,7 @@ import static org.mockito.Mockito.doThrow;
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 static org.mockito.Mockito.when;
import java.time.Duration; import java.time.Duration;
import java.time.Instant; import java.time.Instant;
@ -111,8 +112,8 @@ public class TaskServiceImplTest {
@Before @Before
public void setup() throws WorkbasketNotFoundException { public void setup() throws WorkbasketNotFoundException {
MockitoAnnotations.initMocks(this); MockitoAnnotations.initMocks(this);
doReturn(workbasketServiceMock).when(taskanaEngineMock).getWorkbasketService(); when(taskanaEngineMock.getWorkbasketService()).thenReturn(workbasketServiceMock);
doReturn(classificationServiceImplMock).when(taskanaEngineMock).getClassificationService(); when(taskanaEngineMock.getClassificationService()).thenReturn(classificationServiceImplMock);
try { try {
Mockito.doNothing().when(workbasketServiceMock).checkAuthorization(any(), any()); Mockito.doNothing().when(workbasketServiceMock).checkAuthorization(any(), any());
} catch (NotAuthorizedException e) { } catch (NotAuthorizedException e) {
@ -134,14 +135,14 @@ public class TaskServiceImplTest {
wb.setName("workbasket"); wb.setName("workbasket");
wb.setDomain(dummyClassification.getDomain()); wb.setDomain(dummyClassification.getDomain());
doThrow(TaskNotFoundException.class).when(cutSpy).getTask(expectedTask.getId()); doThrow(TaskNotFoundException.class).when(cutSpy).getTask(expectedTask.getId());
doReturn(wb).when(workbasketServiceMock).getWorkbasket(wb.getKey(), wb.getDomain()); when(workbasketServiceMock.getWorkbasket(wb.getKey(), wb.getDomain())).thenReturn(wb);
doNothing().when(taskMapperMock).insert(expectedTask); doNothing().when(taskMapperMock).insert(expectedTask);
doReturn(dummyClassification).when( when(classificationServiceImplMock.getClassification(
classificationServiceImplMock) dummyClassification.getKey(),
.getClassification(dummyClassification.getKey(), dummyClassification.getDomain()); dummyClassification.getDomain())).thenReturn(dummyClassification);
expectedTask.setPrimaryObjRef(JunitHelper.createDefaultObjRef()); expectedTask.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
doReturn(taskanaEngineConfigurationMock).when(taskanaEngineMock).getConfiguration(); when(taskanaEngineMock.getConfiguration()).thenReturn(taskanaEngineConfigurationMock);
doReturn(false).when(taskanaEngineConfigurationMock).isSecurityEnabled(); when(taskanaEngineConfigurationMock.isSecurityEnabled()).thenReturn(false);
Task actualTask = cutSpy.createTask(expectedTask); Task actualTask = cutSpy.createTask(expectedTask);
@ -180,14 +181,13 @@ public class TaskServiceImplTest {
wb.setName("workbasket"); wb.setName("workbasket");
wb.setDomain(dummyClassification.getDomain()); wb.setDomain(dummyClassification.getDomain());
doThrow(TaskNotFoundException.class).when(cutSpy).getTask(expectedTask.getId()); doThrow(TaskNotFoundException.class).when(cutSpy).getTask(expectedTask.getId());
doReturn(wb).when(workbasketServiceMock).getWorkbasket(wb.getKey(), wb.getDomain()); when(workbasketServiceMock.getWorkbasket(wb.getKey(), wb.getDomain())).thenReturn(wb);
doNothing().when(taskMapperMock).insert(expectedTask); doNothing().when(taskMapperMock).insert(expectedTask);
doReturn(dummyClassification).when( when(classificationServiceImplMock.getClassification(dummyClassification.getKey(),
classificationServiceImplMock) dummyClassification.getDomain())).thenReturn(dummyClassification);
.getClassification(dummyClassification.getKey(), dummyClassification.getDomain());
expectedTask.setPrimaryObjRef(JunitHelper.createDefaultObjRef()); expectedTask.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
doReturn(taskanaEngineConfigurationMock).when(taskanaEngineMock).getConfiguration(); when(taskanaEngineMock.getConfiguration()).thenReturn(taskanaEngineConfigurationMock);
doReturn(true).when(taskanaEngineConfigurationMock).isSecurityEnabled(); when(taskanaEngineConfigurationMock.isSecurityEnabled()).thenReturn(true);
cutSpy.createTask(expectedTask); cutSpy.createTask(expectedTask);
} }
@ -208,16 +208,15 @@ public class TaskServiceImplTest {
expectedTask.setPrimaryObjRef(expectedObjectReference); expectedTask.setPrimaryObjRef(expectedObjectReference);
ClassificationSummary classification = expectedTask.getClassificationSummary(); ClassificationSummary classification = expectedTask.getClassificationSummary();
doThrow(TaskNotFoundException.class).when(cutSpy).getTask(expectedTask.getId()); doThrow(TaskNotFoundException.class).when(cutSpy).getTask(expectedTask.getId());
doReturn(wb).when(workbasketServiceMock).getWorkbasket(expectedTask.getWorkbasketKey(), when(workbasketServiceMock.getWorkbasket(expectedTask.getWorkbasketKey(),
expectedTask.getDomain()); expectedTask.getDomain())).thenReturn(wb);
doReturn(expectedObjectReference).when(objectReferenceMapperMock) when(objectReferenceMapperMock.findByObjectReference(expectedObjectReference)).thenReturn(
.findByObjectReference(expectedObjectReference); expectedObjectReference);
doReturn(dummyClassification).when( when(classificationServiceImplMock.getClassification(dummyClassification.getKey(),
classificationServiceImplMock) dummyClassification.getDomain())).thenReturn(dummyClassification);
.getClassification(dummyClassification.getKey(), dummyClassification.getDomain());
doNothing().when(taskMapperMock).insert(expectedTask); doNothing().when(taskMapperMock).insert(expectedTask);
doReturn(taskanaEngineConfigurationMock).when(taskanaEngineMock).getConfiguration(); when(taskanaEngineMock.getConfiguration()).thenReturn(taskanaEngineConfigurationMock);
doReturn(false).when(taskanaEngineConfigurationMock).isSecurityEnabled(); when(taskanaEngineConfigurationMock.isSecurityEnabled()).thenReturn(false);
Task actualTask = cutSpy.createTask(expectedTask); Task actualTask = cutSpy.createTask(expectedTask);
verify(taskanaEngineMock, times(1)).openConnection(); verify(taskanaEngineMock, times(1)).openConnection();
@ -256,19 +255,19 @@ public class TaskServiceImplTest {
wb.setName("workbasket"); wb.setName("workbasket");
wb.setDomain("dummy-domain"); wb.setDomain("dummy-domain");
doReturn(wb).when(workbasketServiceMock).getWorkbasket(wb.getKey(), wb.getDomain()); when(workbasketServiceMock.getWorkbasket(wb.getKey(), wb.getDomain())).thenReturn(wb);
Classification dummyClassification = createDummyClassification(); Classification dummyClassification = createDummyClassification();
TaskImpl expectedTask = createUnitTestTask("", "DUMMYTASK", "key1", dummyClassification); TaskImpl expectedTask = createUnitTestTask("", "DUMMYTASK", "key1", dummyClassification);
expectedTask.setPrimaryObjRef(expectedObjectReference); expectedTask.setPrimaryObjRef(expectedObjectReference);
ClassificationSummary classification = expectedTask.getClassificationSummary(); ClassificationSummary classification = expectedTask.getClassificationSummary();
doThrow(TaskNotFoundException.class).when(cutSpy).getTask(expectedTask.getId()); doThrow(TaskNotFoundException.class).when(cutSpy).getTask(expectedTask.getId());
doReturn(dummyClassification).when(classificationServiceImplMock).getClassification(classification.getKey(), when(classificationServiceImplMock.getClassification(classification.getKey(),
classification.getDomain()); classification.getDomain())).thenReturn(dummyClassification);
doNothing().when(taskMapperMock).insert(expectedTask); doNothing().when(taskMapperMock).insert(expectedTask);
doNothing().when(objectReferenceMapperMock).insert(expectedObjectReference); doNothing().when(objectReferenceMapperMock).insert(expectedObjectReference);
doReturn(null).when(objectReferenceMapperMock).findByObjectReference(expectedTask.getPrimaryObjRef()); when(objectReferenceMapperMock.findByObjectReference(expectedTask.getPrimaryObjRef())).thenReturn(null);
doReturn(taskanaEngineConfigurationMock).when(taskanaEngineMock).getConfiguration(); when(taskanaEngineMock.getConfiguration()).thenReturn(taskanaEngineConfigurationMock);
doReturn(false).when(taskanaEngineConfigurationMock).isSecurityEnabled(); when(taskanaEngineConfigurationMock.isSecurityEnabled()).thenReturn(false);
Task actualTask = cutSpy.createTask(expectedTask); Task actualTask = cutSpy.createTask(expectedTask);
expectedTask.getPrimaryObjRef().setId(actualTask.getPrimaryObjRef().getId()); // get only new ID expectedTask.getPrimaryObjRef().setId(actualTask.getPrimaryObjRef().getId()); // get only new ID
@ -321,14 +320,14 @@ public class TaskServiceImplTest {
task.setPrimaryObjRef(expectedObjectReference); task.setPrimaryObjRef(expectedObjectReference);
task.setDescription("simply awesome task"); task.setDescription("simply awesome task");
doThrow(TaskNotFoundException.class).when(cutSpy).getTask(task.getId()); doThrow(TaskNotFoundException.class).when(cutSpy).getTask(task.getId());
doReturn(wb).when(workbasketServiceMock).getWorkbasket(wb.getId()); when(workbasketServiceMock.getWorkbasket(wb.getId())).thenReturn(wb);
doReturn(classification).when(classificationServiceImplMock).getClassification(classification.getKey(), when(classificationServiceImplMock.getClassification(classification.getKey(),
wb.getDomain()); wb.getDomain())).thenReturn(classification);
doReturn(expectedObjectReference).when(objectReferenceMapperMock) when(objectReferenceMapperMock.findByObjectReference(expectedObjectReference)).thenReturn(
.findByObjectReference(expectedObjectReference); expectedObjectReference);
doNothing().when(taskMapperMock).insert(task); doNothing().when(taskMapperMock).insert(task);
doReturn(taskanaEngineConfigurationMock).when(taskanaEngineMock).getConfiguration(); when(taskanaEngineMock.getConfiguration()).thenReturn(taskanaEngineConfigurationMock);
doReturn(false).when(taskanaEngineConfigurationMock).isSecurityEnabled(); when(taskanaEngineConfigurationMock.isSecurityEnabled()).thenReturn(false);
cutSpy.createTask(task); cutSpy.createTask(task);
@ -403,7 +402,7 @@ public class TaskServiceImplTest {
TaskImpl task = createUnitTestTask("", "dummyTask", "1", dummyClassification); TaskImpl task = createUnitTestTask("", "dummyTask", "1", dummyClassification);
Workbasket dummyWorkbasket = createWorkbasket("2", "k1"); Workbasket dummyWorkbasket = createWorkbasket("2", "k1");
task.setWorkbasketSummary(dummyWorkbasket.asSummary()); task.setWorkbasketSummary(dummyWorkbasket.asSummary());
doReturn(dummyWorkbasket).when(workbasketServiceMock).getWorkbasket(any()); when(workbasketServiceMock.getWorkbasket(any())).thenReturn(dummyWorkbasket);
doThrow(TaskNotFoundException.class).when(cutSpy).getTask(task.getId()); doThrow(TaskNotFoundException.class).when(cutSpy).getTask(task.getId());
doThrow(NotAuthorizedException.class).when(workbasketServiceMock).checkAuthorization( doThrow(NotAuthorizedException.class).when(workbasketServiceMock).checkAuthorization(
task.getWorkbasketSummary().getId(), task.getWorkbasketSummary().getId(),
@ -433,7 +432,7 @@ public class TaskServiceImplTest {
Classification dummyClassification = createDummyClassification(); Classification dummyClassification = createDummyClassification();
TaskImpl task = createUnitTestTask("", "dumma-task", "1", dummyClassification); TaskImpl task = createUnitTestTask("", "dumma-task", "1", dummyClassification);
doThrow(TaskNotFoundException.class).when(cutSpy).getTask(task.getId()); doThrow(TaskNotFoundException.class).when(cutSpy).getTask(task.getId());
doThrow(WorkbasketNotFoundException.class).when(workbasketServiceMock).getWorkbasket(any(), any()); when(workbasketServiceMock.getWorkbasket(any(), any())).thenThrow(WorkbasketNotFoundException.class);
try { try {
cutSpy.createTask(task); cutSpy.createTask(task);
} catch (WorkbasketNotFoundException e) { } catch (WorkbasketNotFoundException e) {
@ -494,7 +493,7 @@ public class TaskServiceImplTest {
@Test(expected = TaskNotFoundException.class) @Test(expected = TaskNotFoundException.class)
public void testClaimThrowinTaskNotFoundException() throws Exception { public void testClaimThrowinTaskNotFoundException() throws Exception {
TaskImpl expectedTask = null; TaskImpl expectedTask = null;
Mockito.doReturn(expectedTask).when(taskMapperMock).findById(any()); when(taskMapperMock.findById(any())).thenReturn(expectedTask);
try { try {
cut.forceClaim("1"); cut.forceClaim("1");
@ -686,24 +685,24 @@ public class TaskServiceImplTest {
task.setState(TaskState.CLAIMED); task.setState(TaskState.CLAIMED);
task.setClaimed(Instant.now()); task.setClaimed(Instant.now());
task.setOwner(CurrentUserContext.getUserid()); task.setOwner(CurrentUserContext.getUserid());
doReturn(task).when(taskMapperMock).findById(task.getId()); when(taskMapperMock.findById(task.getId())).thenReturn(task);
doReturn(null).when(attachmentMapperMock).findAttachmentsByTaskId(task.getId()); when(attachmentMapperMock.findAttachmentsByTaskId(task.getId())).thenReturn(null);
doReturn(task).when(cutSpy).completeTask(task.getId()); doReturn(task).when(cutSpy).completeTask(task.getId());
doReturn(classificationQueryImplMock).when(classificationServiceImplMock).createClassificationQuery(); when(classificationServiceImplMock.createClassificationQuery()).thenReturn(classificationQueryImplMock);
doReturn(classificationQueryImplMock).when(classificationQueryImplMock).idIn(any()); when(classificationQueryImplMock.idIn(any())).thenReturn(classificationQueryImplMock);
doReturn(new ArrayList<>()).when(classificationQueryImplMock).list(); when(classificationQueryImplMock.list()).thenReturn(new ArrayList<>());
List<ClassificationSummaryImpl> classificationList = Arrays List<ClassificationSummary> classificationList = Arrays
.asList((ClassificationSummaryImpl) dummyClassification.asSummary()); .asList((ClassificationSummaryImpl) dummyClassification.asSummary());
doReturn(classificationList).when( when(
classificationQueryImplMock) classificationQueryImplMock
.list(); .list()).thenReturn(classificationList);
doReturn(workbasketQueryImplMock).when(workbasketServiceMock).createWorkbasketQuery(); when(workbasketServiceMock.createWorkbasketQuery()).thenReturn(workbasketQueryImplMock);
doReturn(workbasketQueryImplMock).when(workbasketQueryImplMock).idIn(any()); when(workbasketQueryImplMock.idIn(any())).thenReturn(workbasketQueryImplMock);
List<WorkbasketSummary> wbList = new ArrayList<>(); List<WorkbasketSummary> wbList = new ArrayList<>();
WorkbasketSummaryImpl wb = new WorkbasketSummaryImpl(); WorkbasketSummaryImpl wb = new WorkbasketSummaryImpl();
wb.setDomain("dummy-domain"); wb.setDomain("dummy-domain");
wbList.add(wb); wbList.add(wb);
doReturn(wbList).when(workbasketQueryImplMock).list(); when(workbasketQueryImplMock.list()).thenReturn(wbList);
Task actualTask = cut.completeTask(task.getId()); Task actualTask = cut.completeTask(task.getId());
@ -905,10 +904,10 @@ public class TaskServiceImplTest {
TaskImpl task = createUnitTestTask("1", "Unit Test Task 1", "key47", dummyClassification); TaskImpl task = createUnitTestTask("1", "Unit Test Task 1", "key47", dummyClassification);
task.setWorkbasketSummary(sourceWorkbasket.asSummary()); task.setWorkbasketSummary(sourceWorkbasket.asSummary());
task.setRead(true); task.setRead(true);
doReturn(destinationWorkbasket).when(workbasketServiceMock).getWorkbasket(destinationWorkbasket.getId()); when(workbasketServiceMock.getWorkbasket(destinationWorkbasket.getId())).thenReturn(destinationWorkbasket);
doReturn(sourceWorkbasket).when(workbasketServiceMock).getWorkbasket(sourceWorkbasket.getId()); when(workbasketServiceMock.getWorkbasket(sourceWorkbasket.getId())).thenReturn(sourceWorkbasket);
doReturn(taskanaEngineConfigurationMock).when(taskanaEngineMock).getConfiguration(); when(taskanaEngineMock.getConfiguration()).thenReturn(taskanaEngineConfigurationMock);
doReturn(false).when(taskanaEngineConfigurationMock).isSecurityEnabled(); when(taskanaEngineConfigurationMock.isSecurityEnabled()).thenReturn(false);
doReturn(task).when(cutSpy).getTask(task.getId()); doReturn(task).when(cutSpy).getTask(task.getId());
doNothing().when(taskMapperMock).update(any()); doNothing().when(taskMapperMock).update(any());
doNothing().when(workbasketServiceMock).checkAuthorization(destinationWorkbasket.getId(), doNothing().when(workbasketServiceMock).checkAuthorization(destinationWorkbasket.getId(),
@ -944,10 +943,10 @@ public class TaskServiceImplTest {
Classification dummyClassification = createDummyClassification(); Classification dummyClassification = createDummyClassification();
TaskImpl task = createUnitTestTask("1", "Unit Test Task 1", "k1", dummyClassification); TaskImpl task = createUnitTestTask("1", "Unit Test Task 1", "k1", dummyClassification);
task.setRead(true); task.setRead(true);
doReturn(taskanaEngineConfigurationMock).when(taskanaEngineMock).getConfiguration(); when(taskanaEngineMock.getConfiguration()).thenReturn(taskanaEngineConfigurationMock);
doReturn(true).when(taskanaEngineConfigurationMock).isSecurityEnabled(); when(taskanaEngineConfigurationMock.isSecurityEnabled()).thenReturn(true);
doReturn(task).when(cutSpy).getTask(task.getId()); doReturn(task).when(cutSpy).getTask(task.getId());
doReturn(destinationWorkbasket).when(workbasketServiceMock).getWorkbasket(destinationWorkbasket.getId()); when(workbasketServiceMock.getWorkbasket(destinationWorkbasket.getId())).thenReturn(destinationWorkbasket);
doNothing().when(taskMapperMock).update(any()); doNothing().when(taskMapperMock).update(any());
doNothing().when(workbasketServiceMock).checkAuthorization(any(), any()); doNothing().when(workbasketServiceMock).checkAuthorization(any(), any());
// doNothing().when(workbasketServiceMock).checkAuthorizationById(any(), WorkbasketAuthorization.TRANSFER); // doNothing().when(workbasketServiceMock).checkAuthorizationById(any(), WorkbasketAuthorization.TRANSFER);
@ -1124,25 +1123,25 @@ public class TaskServiceImplTest {
public void testGetTaskByIdWithExistingTask() public void testGetTaskByIdWithExistingTask()
throws TaskNotFoundException, NotAuthorizedException { throws TaskNotFoundException, NotAuthorizedException {
Classification dummyClassification = createDummyClassification(); Classification dummyClassification = createDummyClassification();
Task expectedTask = createUnitTestTask("1", "DUMMY-TASK", "1", dummyClassification); TaskImpl expectedTask = createUnitTestTask("1", "DUMMY-TASK", "1", dummyClassification);
doReturn(expectedTask).when(taskMapperMock).findById(expectedTask.getId()); when(taskMapperMock.findById(expectedTask.getId())).thenReturn(expectedTask);
doReturn(null).when(attachmentMapperMock).findAttachmentsByTaskId(expectedTask.getId()); when(attachmentMapperMock.findAttachmentsByTaskId(expectedTask.getId())).thenReturn(null);
doReturn(classificationQueryImplMock).when(classificationServiceImplMock).createClassificationQuery(); when(classificationServiceImplMock.createClassificationQuery()).thenReturn(classificationQueryImplMock);
doReturn(classificationQueryImplMock).when(classificationQueryImplMock).idIn(any()); when(classificationQueryImplMock.idIn(any())).thenReturn(classificationQueryImplMock);
doReturn(workbasketQueryImplMock).when(workbasketServiceMock).createWorkbasketQuery(); when(workbasketServiceMock.createWorkbasketQuery()).thenReturn(workbasketQueryImplMock);
doReturn(workbasketQueryImplMock).when(workbasketQueryImplMock).idIn(any()); when(workbasketQueryImplMock.idIn(any())).thenReturn(workbasketQueryImplMock);
List<WorkbasketSummary> wbList = new ArrayList<>(); List<WorkbasketSummary> wbList = new ArrayList<>();
WorkbasketSummaryImpl wb = new WorkbasketSummaryImpl(); WorkbasketSummaryImpl wb = new WorkbasketSummaryImpl();
wb.setDomain("dummy-domain"); wb.setDomain("dummy-domain");
wbList.add(wb); wbList.add(wb);
doReturn(wbList).when(workbasketQueryImplMock).list(); when(workbasketQueryImplMock.list()).thenReturn(wbList);
List<ClassificationSummaryImpl> classificationList = Arrays List<ClassificationSummary> classificationList = Arrays
.asList((ClassificationSummaryImpl) dummyClassification.asSummary()); .asList((ClassificationSummaryImpl) dummyClassification.asSummary());
doReturn(classificationList).when( when(
classificationQueryImplMock) classificationQueryImplMock
.list(); .list()).thenReturn(classificationList);
Task actualTask = cut.getTask(expectedTask.getId()); Task actualTask = cut.getTask(expectedTask.getId());
verify(taskanaEngineMock, times(1)).openConnection(); verify(taskanaEngineMock, times(1)).openConnection();
@ -1166,7 +1165,7 @@ public class TaskServiceImplTest {
public void testGetTaskByIdWhereTaskDoesNotExist() throws Exception { public void testGetTaskByIdWhereTaskDoesNotExist() throws Exception {
Classification dummyClassification = createDummyClassification(); Classification dummyClassification = createDummyClassification();
Task task = createUnitTestTask("1", "DUMMY-TASK", "1", dummyClassification); Task task = createUnitTestTask("1", "DUMMY-TASK", "1", dummyClassification);
doThrow(TaskNotFoundException.class).when(taskMapperMock).findById(task.getId()); when(taskMapperMock.findById(task.getId())).thenThrow(TaskNotFoundException.class);
try { try {
cut.getTask(task.getId()); cut.getTask(task.getId());
@ -1337,7 +1336,7 @@ public class TaskServiceImplTest {
} }
@Test @Test
public void testTaskSummaryEqualsHashCode() throws InterruptedException { public void testTaskSummaryEqualsHashCode() throws InterruptedException {
Classification classification = createDummyClassification(); Classification classification = createDummyClassification();
Workbasket wb = createWorkbasket("WB-ID", "WB-Key"); Workbasket wb = createWorkbasket("WB-ID", "WB-Key");
Attachment attachment = JunitHelper.createDefaultAttachment(); Attachment attachment = JunitHelper.createDefaultAttachment();
@ -1368,7 +1367,7 @@ public class TaskServiceImplTest {
summaryAfter = taskAfter.asSummary(); summaryAfter = taskAfter.asSummary();
assertEquals(summaryBefore, summaryAfter); assertEquals(summaryBefore, summaryAfter);
assertEquals(summaryBefore.hashCode(), summaryAfter.hashCode()); assertEquals(summaryBefore.hashCode(), summaryAfter.hashCode());
} }
private TaskImpl createUnitTestTask(String id, String name, String workbasketKey, Classification classification) { private TaskImpl createUnitTestTask(String id, String name, String workbasketKey, Classification classification) {
TaskImpl task = new TaskImpl(); TaskImpl task = new TaskImpl();

2
lib/taskana-core/src/test/java/pro/taskana/impl/WorkbasketAccessItemQueryImplTest.java
View File

@ -53,7 +53,7 @@ public class WorkbasketAccessItemQueryImplTest {
when(sqlSession.selectList(any(), any(), any())).thenReturn(new ArrayList<>()); when(sqlSession.selectList(any(), any(), any())).thenReturn(new ArrayList<>());
List<WorkbasketAccessItem> result = workbasketAccessItemQueryImpl.accessIdIn("test", "asd") List<WorkbasketAccessItem> result = workbasketAccessItemQueryImpl.accessIdIn("test", "asd")
.list(1, 1); .list(1, 1);
Assert.assertNotNull(result); Assert.assertNotNull(result);
} }

18
lib/taskana-core/src/test/java/pro/taskana/impl/WorkbasketQueryImplTest.java
View File

@ -43,9 +43,9 @@ public class WorkbasketQueryImplTest {
when(sqlSession.selectList(any(), any())).thenReturn(new ArrayList<>()); when(sqlSession.selectList(any(), any())).thenReturn(new ArrayList<>());
List<WorkbasketSummary> result = workbasketQueryImpl List<WorkbasketSummary> result = workbasketQueryImpl
.nameIn("Gruppenpostkorb KSC 1", "Gruppenpostkorb KSC 2") .nameIn("Gruppenpostkorb KSC 1", "Gruppenpostkorb KSC 2")
.keyLike("GPK_%") .keyLike("GPK_%")
.list(); .list();
Assert.assertNotNull(result); Assert.assertNotNull(result);
} }
@ -55,9 +55,9 @@ public class WorkbasketQueryImplTest {
when(sqlSession.selectList(any(), any(), any())).thenReturn(new ArrayList<>()); when(sqlSession.selectList(any(), any(), any())).thenReturn(new ArrayList<>());
List<WorkbasketSummary> result = workbasketQueryImpl List<WorkbasketSummary> result = workbasketQueryImpl
.nameIn("Gruppenpostkorb KSC 1", "Gruppenpostkorb KSC 2") .nameIn("Gruppenpostkorb KSC 1", "Gruppenpostkorb KSC 2")
.keyLike("GPK_%") .keyLike("GPK_%")
.list(1, 1); .list(1, 1);
Assert.assertNotNull(result); Assert.assertNotNull(result);
} }
@ -67,9 +67,9 @@ public class WorkbasketQueryImplTest {
when(sqlSession.selectOne(any(), any())).thenReturn(new WorkbasketSummaryImpl()); when(sqlSession.selectOne(any(), any())).thenReturn(new WorkbasketSummaryImpl());
WorkbasketSummary result = workbasketQueryImpl WorkbasketSummary result = workbasketQueryImpl
.nameIn("Gruppenpostkorb KSC 1", "Gruppenpostkorb KSC 2") .nameIn("Gruppenpostkorb KSC 1", "Gruppenpostkorb KSC 2")
.keyLike("GPK_%") .keyLike("GPK_%")
.single(); .single();
Assert.assertNotNull(result); Assert.assertNotNull(result);
} }
} }

17
lib/taskana-core/src/test/java/pro/taskana/impl/WorkbasketReportBuilderImplTest.java
View File

@ -4,7 +4,6 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.eq;
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;
@ -33,8 +32,8 @@ import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.InvalidArgumentException; import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.NotAuthorizedException; import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.impl.report.CombinedClassificationFilter; import pro.taskana.impl.report.CombinedClassificationFilter;
import pro.taskana.impl.report.item.MonitorQueryItem;
import pro.taskana.impl.report.header.TimeIntervalColumnHeader; import pro.taskana.impl.report.header.TimeIntervalColumnHeader;
import pro.taskana.impl.report.item.MonitorQueryItem;
import pro.taskana.mappings.TaskMonitorMapper; import pro.taskana.mappings.TaskMonitorMapper;
import pro.taskana.report.WorkbasketReport; import pro.taskana.report.WorkbasketReport;
@ -61,9 +60,9 @@ public class WorkbasketReportBuilderImplTest {
MockitoAnnotations.initMocks(this); MockitoAnnotations.initMocks(this);
Mockito.doNothing().when(taskanaEngineImplMock).openConnection(); Mockito.doNothing().when(taskanaEngineImplMock).openConnection();
Mockito.doNothing().when(taskanaEngineImplMock).returnConnection(); Mockito.doNothing().when(taskanaEngineImplMock).returnConnection();
doReturn(taskanaEngineConfiguration).when(taskanaEngineImplMock).getConfiguration(); when(taskanaEngineImplMock.getConfiguration()).thenReturn(taskanaEngineConfiguration);
doReturn(true).when(taskanaEngineConfiguration).isGermanPublicHolidaysEnabled(); when(taskanaEngineConfiguration.isGermanPublicHolidaysEnabled()).thenReturn(true);
doReturn(null).when(taskanaEngineConfiguration).getCustomHolidays(); when(taskanaEngineConfiguration.getCustomHolidays()).thenReturn(null);
} }
@Test @Test
@ -86,9 +85,9 @@ public class WorkbasketReportBuilderImplTest {
monitorQueryItem.setKey("WBI:000000000000000000000000000000000001"); monitorQueryItem.setKey("WBI:000000000000000000000000000000000001");
monitorQueryItem.setNumberOfTasks(1); monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem); expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfWorkbaskets(workbasketIds, states, when(taskMonitorMapperMock.getTaskCountOfWorkbaskets(workbasketIds, states,
categories, domains, classificationIds, excludedClassificationIds, customAttributeFilter, categories, domains, classificationIds, excludedClassificationIds, customAttributeFilter,
combinedClassificationFilter); combinedClassificationFilter)).thenReturn(expectedResult);
WorkbasketReport actualResult = cut.createWorkbasketReportBuilder() WorkbasketReport actualResult = cut.createWorkbasketReportBuilder()
.workbasketIdIn(workbasketIds) .workbasketIdIn(workbasketIds)
@ -141,9 +140,9 @@ public class WorkbasketReportBuilderImplTest {
monitorQueryItem.setAgeInDays(0); monitorQueryItem.setAgeInDays(0);
monitorQueryItem.setNumberOfTasks(1); monitorQueryItem.setNumberOfTasks(1);
expectedResult.add(monitorQueryItem); expectedResult.add(monitorQueryItem);
doReturn(expectedResult).when(taskMonitorMapperMock).getTaskCountOfWorkbaskets(workbasketIds, states, when(taskMonitorMapperMock.getTaskCountOfWorkbaskets(workbasketIds, states,
categories, domains, classificationIds, excludedClassificationIds, customAttributeFilter, categories, domains, classificationIds, excludedClassificationIds, customAttributeFilter,
combinedClassificationFilter); combinedClassificationFilter)).thenReturn(expectedResult);
WorkbasketReport actualResult = cut.createWorkbasketReportBuilder() WorkbasketReport actualResult = cut.createWorkbasketReportBuilder()
.workbasketIdIn(workbasketIds) .workbasketIdIn(workbasketIds)

7
lib/taskana-core/src/test/java/pro/taskana/impl/WorkbasketServiceImplTest.java
View File

@ -11,6 +11,7 @@ import static org.mockito.Mockito.doThrow;
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 static org.mockito.Mockito.when;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
@ -97,7 +98,7 @@ public class WorkbasketServiceImplTest {
WorkbasketImpl expectedWb = createTestWorkbasket(null, "Key-1"); WorkbasketImpl expectedWb = createTestWorkbasket(null, "Key-1");
doNothing().when(workbasketMapperMock).insert(expectedWb); doNothing().when(workbasketMapperMock).insert(expectedWb);
doReturn(expectedWb).when(cutSpy).getWorkbasket(any()); doReturn(expectedWb).when(cutSpy).getWorkbasket(any());
doReturn(true).when(taskanaEngineImplMock).domainExists(any()); when(taskanaEngineImplMock.domainExists(any())).thenReturn(true);
Workbasket actualWb = cutSpy.createWorkbasket(expectedWb); Workbasket actualWb = cutSpy.createWorkbasket(expectedWb);
cutSpy.setDistributionTargets(expectedWb.getId(), createTestDistributionTargets(distTargetAmount)); cutSpy.setDistributionTargets(expectedWb.getId(), createTestDistributionTargets(distTargetAmount));
@ -127,7 +128,7 @@ public class WorkbasketServiceImplTest {
WorkbasketAlreadyExistException, DomainNotFoundException { WorkbasketAlreadyExistException, DomainNotFoundException {
WorkbasketImpl expectedWb = createTestWorkbasket("ID-1", "Key-1"); WorkbasketImpl expectedWb = createTestWorkbasket("ID-1", "Key-1");
doNothing().when(workbasketMapperMock).insert(expectedWb); doNothing().when(workbasketMapperMock).insert(expectedWb);
doReturn(true).when(taskanaEngineImplMock).domainExists(any()); when(taskanaEngineImplMock.domainExists(any())).thenReturn(true);
try { try {
cutSpy.createWorkbasket(expectedWb); cutSpy.createWorkbasket(expectedWb);
@ -159,7 +160,7 @@ public class WorkbasketServiceImplTest {
throws Exception { throws Exception {
WorkbasketImpl expectedWb = createTestWorkbasket(null, "Key-1"); WorkbasketImpl expectedWb = createTestWorkbasket(null, "Key-1");
doNothing().when(workbasketMapperMock).insert(expectedWb); doNothing().when(workbasketMapperMock).insert(expectedWb);
doThrow(WorkbasketNotFoundException.class).when(workbasketMapperMock).findById(any()); when(workbasketMapperMock.findById(any())).thenThrow(WorkbasketNotFoundException.class);
try { try {
cutSpy.createWorkbasket(expectedWb); cutSpy.createWorkbasket(expectedWb);