maece/HSG-MCS-HS21_tapas
1
0
Fork 0
Code Issues 14 Pull Requests Packages Projects Releases 6 Wiki Activity

Merge pull request #11 from SCS-ASSE-FS21-Tutors/test

Browse Source 
Test
This commit is contained in:
Ronny Seiger 2021-11-21 11:32:13 +01:00 committed by GitHub
commit b027a83aad
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 684 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
tapas-tasks/pom.xml
View File

@ -37,6 +37,16 @@
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>chaos-monkey-spring-boot</artifactId>
<version>2.5.4</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
@ -47,6 +57,17 @@
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>2.21.0</version>
</dependency>
<dependency>
<groupId>com.tngtech.archunit</groupId>
<artifactId>archunit-junit4</artifactId>
<version>0.22.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
@ -74,6 +95,10 @@
<artifactId>org.eclipse.paho.client.mqttv3</artifactId>
<version>1.2.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-test</artifactId>
</dependency>
</dependencies>
<build>

3
tapas-tasks/src/main/java/ch/unisg/tapastasks/tasks/application/service/AddNewTaskToTaskListService.java
View File

@ -11,11 +11,14 @@ import ch.unisg.tapastasks.tasks.domain.NewTaskAddedEvent;
import ch.unisg.tapastasks.tasks.domain.TaskList;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import javax.transaction.Transactional;
@RequiredArgsConstructor
@Component
@Transactional
@Service("AddNewTaskToTaskList")
public class AddNewTaskToTaskListService implements AddNewTaskToTaskListUseCase {
private final NewTaskAddedEventPort newTaskAddedEventPort;

2
tapas-tasks/src/main/java/ch/unisg/tapastasks/tasks/application/service/RetrieveTaskFromTaskListService.java
View File

@ -7,6 +7,7 @@ import ch.unisg.tapastasks.tasks.domain.Task;
import ch.unisg.tapastasks.tasks.domain.TaskList;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import javax.transaction.Transactional;
import java.util.Optional;
@ -14,6 +15,7 @@ import java.util.Optional;
@RequiredArgsConstructor
@Component
@Transactional
@Service("RetrieveTaskFromTaskList")
public class RetrieveTaskFromTaskListService implements RetrieveTaskFromTaskListUseCase {
private final LoadTaskPort loadTaskFromRepositoryPort;

35
tapas-tasks/src/main/resources/application.properties
View File

@ -1,7 +1,38 @@
server.port=8081
//spring.data.mongodb.uri=mongodb://127.0.0.1:27017
spring.data.mongodb.uri=mongodb://root:8nP7s0a@mongodb:27017/
spring.data.mongodb.uri=mongodb://127.0.0.1:27017
#spring.data.mongodb.uri=mongodb://root:8nP7s0a@mongodb:27017/
spring.data.mongodb.database=tapas-tasks
baseuri=https://tapas-tasks.86-119-34-23.nip.io/
spring.profiles.active=chaos-monkey
chaos.monkey.enabled=true
management.endpoint.chaosmonkey.enabled=true
management.endpoint.chaosmonkeyjmx.enabled=true
# include specific endpoints
management.endpoints.web.exposure.include=health,info,chaosmonkey
chaos.monkey.watcher.controller=true
chaos.monkey.watcher.restController=true
chaos.monkey.watcher.service=true
chaos.monkey.watcher.repository=true
chaos.monkey.watcher.component=true
#Chaos Monkey configs taken from here: https://www.baeldung.com/spring-boot-chaos-monkey
#Latency Assault
#chaos.monkey.assaults.latencyActive=true
#chaos.monkey.assaults.latencyRangeStart=3000
#chaos.monkey.assaults.latencyRangeEnd=15000
#Exception Assault
#chaos.monkey.assaults.latencyActive=false
#chaos.monkey.assaults.exceptionsActive=true
#chaos.monkey.assaults.killApplicationActive=false
#AppKiller Assault
#chaos.monkey.assaults.latencyActive=false
#chaos.monkey.assaults.exceptionsActive=false
#chaos.monkey.assaults.killApplicationActive=true
#Chaos Monkey assaults via REST to endpoint /actuator/chaosmonkey/assaults/
#https://softwarehut.com/blog/tech/chaos-monkey
#https://codecentric.github.io/chaos-monkey-spring-boot/latest/

76
tapas-tasks/src/test/java/ch/unisg/tapastasks/AddNewTaskToTaskListSystemTest.java Normal file
View File

@ -0,0 +1,76 @@
package ch.unisg.tapastasks;
import ch.unisg.tapastasks.tasks.adapter.in.formats.TaskJsonRepresentation;
import ch.unisg.tapastasks.tasks.application.port.out.AddTaskPort;
import ch.unisg.tapastasks.tasks.domain.Task;
import ch.unisg.tapastasks.tasks.domain.TaskList;
import org.json.JSONException;
import org.json.JSONObject;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.*;
import static org.assertj.core.api.BDDAssertions.*;
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class AddNewTaskToTaskListSystemTest {
@Autowired
private TestRestTemplate restTemplate;
@Autowired
private AddTaskPort addTaskPort;
@Test
void addNewTaskToTaskList() throws JSONException {
Task.TaskName taskName = new Task.TaskName("system-integration-test-task");
Task.TaskType taskType = new Task.TaskType("system-integration-test-type");
Task.OriginalTaskUri originalTaskUri = new Task.OriginalTaskUri("example.org");
ResponseEntity response = whenAddNewTaskToEmptyList(taskName, taskType, originalTaskUri);
JSONObject responseJson = new JSONObject(response.getBody().toString());
String respTaskId = responseJson.getString("taskId");
String respTaskName = responseJson.getString("taskName");
String respTaskType = responseJson.getString("taskType");
then(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
then(respTaskId).isNotEmpty();
then(respTaskName).isEqualTo(taskName.getValue());
then(respTaskType).isEqualTo(taskType.getValue());
then(TaskList.getTapasTaskList().getListOfTasks().getValue()).hasSize(1);
}
private ResponseEntity whenAddNewTaskToEmptyList(
Task.TaskName taskName,
Task.TaskType taskType,
Task.OriginalTaskUri originalTaskUri) throws JSONException {
TaskList.getTapasTaskList().getListOfTasks().getValue().clear();
HttpHeaders headers = new HttpHeaders();
headers.add("Content-Type", TaskJsonRepresentation.MEDIA_TYPE);
String jsonPayLoad = new JSONObject()
.put("taskName", taskName.getValue() )
.put("taskType", taskType.getValue())
.put("originalTaskUri",originalTaskUri.getValue())
.toString();
HttpEntity<String> request = new HttpEntity<>(jsonPayLoad,headers);
return restTemplate.exchange(
"/tasks/",
HttpMethod.POST,
request,
Object.class
);
}
}

24
tapas-tasks/src/test/java/ch/unisg/tapastasks/DependencyRuleTests.java Normal file
View File

@ -0,0 +1,24 @@
package ch.unisg.tapastasks;
import ch.unisg.tapastasks.archunit.HexagonalArchitecture;
import com.tngtech.archunit.core.importer.ClassFileImporter;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
class DependencyRuleTests {
@Test
void testPackageDependencies() {
noClasses()
.that()
.resideInAPackage("ch.unisg.tapastasks.tasks.domain..")
.should()
.dependOnClassesThat()
.resideInAnyPackage("ch.unisg.tapastasks.tasks.application..")
.check(new ClassFileImporter()
.importPackages("ch.unisg.tapastasks.tasks.."));
}
}

7
tapas-tasks/src/test/java/ch/unisg/tapastasks/TapasTasksApplicationTests.java
View File

@ -1,13 +1,18 @@
package ch.unisg.tapastasks;
import ch.unisg.tapastasks.tasks.application.port.out.AddTaskPort;
import ch.unisg.tapastasks.tasks.application.port.out.NewTaskAddedEventPort;
import ch.unisg.tapastasks.tasks.application.port.out.TaskListLock;
import ch.unisg.tapastasks.tasks.application.service.AddNewTaskToTaskListService;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class TapasTasksApplicationTests {
@Test
@Test
void contextLoads() {
}
}

62
tapas-tasks/src/test/java/ch/unisg/tapastasks/archunit/Adapters.java Normal file
View File

@ -0,0 +1,62 @@
package ch.unisg.tapastasks.archunit;
import com.tngtech.archunit.core.domain.JavaClasses;
import java.util.ArrayList;
import java.util.List;
public class Adapters extends ArchitectureElement {
private final HexagonalArchitecture parentContext;
private List<String> incomingAdapterPackages = new ArrayList<>();
private List<String> outgoingAdapterPackages = new ArrayList<>();
Adapters(HexagonalArchitecture parentContext, String basePackage) {
super(basePackage);
this.parentContext = parentContext;
}
public Adapters outgoing(String packageName) {
this.incomingAdapterPackages.add(fullQualifiedPackage(packageName));
return this;
}
public Adapters incoming(String packageName) {
this.outgoingAdapterPackages.add(fullQualifiedPackage(packageName));
return this;
}
List<String> allAdapterPackages() {
List<String> allAdapters = new ArrayList<>();
allAdapters.addAll(incomingAdapterPackages);
allAdapters.addAll(outgoingAdapterPackages);
return allAdapters;
}
public HexagonalArchitecture and() {
return parentContext;
}
String getBasePackage() {
return basePackage;
}
void dontDependOnEachOther(JavaClasses classes) {
List<String> allAdapters = allAdapterPackages();
for (String adapter1 : allAdapters) {
for (String adapter2 : allAdapters) {
if (!adapter1.equals(adapter2)) {
denyDependency(adapter1, adapter2, classes);
}
}
}
}
void doesNotDependOn(String packageName, JavaClasses classes) {
denyDependency(this.basePackage, packageName, classes);
}
void doesNotContainEmptyPackages() {
denyEmptyPackages(allAdapterPackages());
}
}

59
tapas-tasks/src/test/java/ch/unisg/tapastasks/archunit/ApplicationLayer.java Normal file
View File

@ -0,0 +1,59 @@
package ch.unisg.tapastasks.archunit;
import com.tngtech.archunit.core.domain.JavaClasses;
import java.util.ArrayList;
import java.util.List;
public class ApplicationLayer extends ArchitectureElement {
private final HexagonalArchitecture parentContext;
private List<String> incomingPortsPackages = new ArrayList<>();
private List<String> outgoingPortsPackages = new ArrayList<>();
private List<String> servicePackages = new ArrayList<>();
public ApplicationLayer(String basePackage, HexagonalArchitecture parentContext) {
super(basePackage);
this.parentContext = parentContext;
}
public ApplicationLayer incomingPorts(String packageName) {
this.incomingPortsPackages.add(fullQualifiedPackage(packageName));
return this;
}
public ApplicationLayer outgoingPorts(String packageName) {
this.outgoingPortsPackages.add(fullQualifiedPackage(packageName));
return this;
}
public ApplicationLayer services(String packageName) {
this.servicePackages.add(fullQualifiedPackage(packageName));
return this;
}
public HexagonalArchitecture and() {
return parentContext;
}
public void doesNotDependOn(String packageName, JavaClasses classes) {
denyDependency(this.basePackage, packageName, classes);
}
public void incomingAndOutgoingPortsDoNotDependOnEachOther(JavaClasses classes) {
denyAnyDependency(this.incomingPortsPackages, this.outgoingPortsPackages, classes);
denyAnyDependency(this.outgoingPortsPackages, this.incomingPortsPackages, classes);
}
private List<String> allPackages() {
List<String> allPackages = new ArrayList<>();
allPackages.addAll(incomingPortsPackages);
allPackages.addAll(outgoingPortsPackages);
allPackages.addAll(servicePackages);
return allPackages;
}
void doesNotContainEmptyPackages() {
denyEmptyPackages(allPackages());
}
}

74
tapas-tasks/src/test/java/ch/unisg/tapastasks/archunit/ArchitectureElement.java Normal file
View File

@ -0,0 +1,74 @@
package ch.unisg.tapastasks.archunit;
import com.tngtech.archunit.core.domain.JavaClasses;
import com.tngtech.archunit.core.importer.ClassFileImporter;
import java.util.List;
import static com.tngtech.archunit.base.DescribedPredicate.*;
import static com.tngtech.archunit.base.DescribedPredicate.greaterThanOrEqualTo;
import static com.tngtech.archunit.lang.conditions.ArchConditions.*;
import static com.tngtech.archunit.lang.conditions.ArchConditions.containNumberOfElements;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.*;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
abstract class ArchitectureElement {
final String basePackage;
public ArchitectureElement(String basePackage) {
this.basePackage = basePackage;
}
String fullQualifiedPackage(String relativePackage) {
return this.basePackage + "." + relativePackage;
}
static void denyDependency(String fromPackageName, String toPackageName, JavaClasses classes) {
noClasses()
.that()
.resideInAPackage("ch.unisg.tapastasks.tasks.domain..")
.should()
.dependOnClassesThat()
.resideInAnyPackage("ch.unisg.tapastasks.tasks.application..")
.check(classes);
}
static void denyAnyDependency(
List<String> fromPackages, List<String> toPackages, JavaClasses classes) {
for (String fromPackage : fromPackages) {
for (String toPackage : toPackages) {
noClasses()
.that()
.resideInAPackage(matchAllClassesInPackage(fromPackage))
.should()
.dependOnClassesThat()
.resideInAnyPackage(matchAllClassesInPackage(toPackage))
.check(classes);
}
}
}
static String matchAllClassesInPackage(String packageName) {
return packageName + "..";
}
void denyEmptyPackage(String packageName) {
classes()
.that()
.resideInAPackage(matchAllClassesInPackage(packageName))
.should(containNumberOfElements(greaterThanOrEqualTo(1)))
.check(classesInPackage(packageName));
}
private JavaClasses classesInPackage(String packageName) {
return new ClassFileImporter().importPackages(packageName);
}
void denyEmptyPackages(List<String> packages) {
for (String packageName : packages) {
denyEmptyPackage(packageName);
}
}
}

61
tapas-tasks/src/test/java/ch/unisg/tapastasks/archunit/HexagonalArchitecture.java Normal file
View File

@ -0,0 +1,61 @@
package ch.unisg.tapastasks.archunit;
import com.tngtech.archunit.core.domain.JavaClasses;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class HexagonalArchitecture extends ArchitectureElement {
private Adapters adapters;
private ApplicationLayer applicationLayer;
private String configurationPackage;
private List<String> domainPackages = new ArrayList<>();
public static HexagonalArchitecture boundedContext(String basePackage) {
return new HexagonalArchitecture(basePackage);
}
public HexagonalArchitecture(String basePackage) {
super(basePackage);
}
public Adapters withAdaptersLayer(String adaptersPackage) {
this.adapters = new Adapters(this, fullQualifiedPackage(adaptersPackage));
return this.adapters;
}
public HexagonalArchitecture withDomainLayer(String domainPackage) {
this.domainPackages.add(fullQualifiedPackage(domainPackage));
return this;
}
public ApplicationLayer withApplicationLayer(String applicationPackage) {
this.applicationLayer = new ApplicationLayer(fullQualifiedPackage(applicationPackage), this);
return this.applicationLayer;
}
public HexagonalArchitecture withConfiguration(String packageName) {
this.configurationPackage = fullQualifiedPackage(packageName);
return this;
}
private void domainDoesNotDependOnOtherPackages(JavaClasses classes) {
denyAnyDependency(
this.domainPackages, Collections.singletonList(adapters.basePackage), classes);
denyAnyDependency(
this.domainPackages, Collections.singletonList(applicationLayer.basePackage), classes);
}
public void check(JavaClasses classes) {
this.adapters.doesNotContainEmptyPackages();
this.adapters.dontDependOnEachOther(classes);
this.adapters.doesNotDependOn(this.configurationPackage, classes);
this.applicationLayer.doesNotContainEmptyPackages();
this.applicationLayer.doesNotDependOn(this.adapters.getBasePackage(), classes);
this.applicationLayer.doesNotDependOn(this.configurationPackage, classes);
this.applicationLayer.incomingAndOutgoingPortsDoNotDependOnEachOther(classes);
this.domainDoesNotDependOnOtherPackages(classes);
}
}

68
tapas-tasks/src/test/java/ch/unisg/tapastasks/tasks/adapter/in/web/AddNewTaskToTaskListWebControllerTest.java Normal file
View File

@ -0,0 +1,68 @@
package ch.unisg.tapastasks.tasks.adapter.in.web;
import ch.unisg.tapastasks.tasks.adapter.in.formats.TaskJsonRepresentation;
import ch.unisg.tapastasks.tasks.adapter.in.web.AddNewTaskToTaskListWebController;
import ch.unisg.tapastasks.tasks.adapter.out.persistence.mongodb.TaskRepository;
import ch.unisg.tapastasks.tasks.application.port.in.AddNewTaskToTaskListCommand;
import ch.unisg.tapastasks.tasks.application.port.in.AddNewTaskToTaskListUseCase;
import ch.unisg.tapastasks.tasks.domain.Task;
import org.json.JSONObject;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.web.servlet.MockMvc;
import java.util.Optional;
import static org.mockito.BDDMockito.eq;
import static org.mockito.BDDMockito.then;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@WebMvcTest(controllers = AddNewTaskToTaskListWebController.class)
public class AddNewTaskToTaskListWebControllerTest {
@Autowired
private MockMvc mockMvc;
@MockBean
private AddNewTaskToTaskListUseCase addNewTaskToTaskListUseCase;
@MockBean
TaskRepository taskRepository;
@Disabled
@Test
void testAddNewTaskToTaskList() throws Exception {
String taskName = "test-request";
String taskType = "test-request-type";
String originalTaskUri = "example.org";
String jsonPayLoad = new JSONObject()
.put("taskName", taskName )
.put("taskType", taskType)
.put("originalTaskUri",originalTaskUri)
.toString();
//This raises a NullPointerException since it tries to build the HTTP response with attributes from
//the domain object (created task), which is mocked --> we need System Tests here!
//See the buckpal example from the lecture for a working integration test for testing the web controller
mockMvc.perform(post("/tasks/")
.contentType(TaskJsonRepresentation.MEDIA_TYPE)
.content(jsonPayLoad))
.andExpect(status().isCreated());
then(addNewTaskToTaskListUseCase).should()
.addNewTaskToTaskList(eq(new AddNewTaskToTaskListCommand(
new Task.TaskName(taskName), new Task.TaskType(taskType),
Optional.of(new Task.OriginalTaskUri(originalTaskUri))
)));
}
}

77
tapas-tasks/src/test/java/ch/unisg/tapastasks/tasks/adapter/out/persistence/mongodb/TaskPersistenceAdapterTest.java Normal file
View File

@ -0,0 +1,77 @@
package ch.unisg.tapastasks.tasks.adapter.out.persistence.mongodb;
import ch.unisg.tapastasks.tasks.domain.Task;
import ch.unisg.tapastasks.tasks.domain.TaskList;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.mongo.AutoConfigureDataMongo;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Import;
import java.util.UUID;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
@AutoConfigureDataMongo
@Import({TaskPersistenceAdapter.class, TaskMapper.class})
public class TaskPersistenceAdapterTest {
@Autowired
private TaskRepository taskRepository;
@Autowired
private TaskPersistenceAdapter adapterUnderTest;
@Test
void addsNewTask() {
String testTaskId = UUID.randomUUID().toString();
String testTaskName = "adds-persistence-task-name";
String testTaskType = "adds-persistence-task-type";
String testTaskOuri = "adds-persistence-test-task-ouri";
String testTaskStatus = Task.Status.OPEN.toString();
String testTaskListName = "tapas-tasks-tutors";
Task testTask = new Task(
new Task.TaskId(testTaskId),
new Task.TaskName(testTaskName),
new Task.TaskType(testTaskType),
new Task.OriginalTaskUri(testTaskOuri),
new Task.TaskStatus(Task.Status.valueOf(testTaskStatus))
);
adapterUnderTest.addTask(testTask);
MongoTaskDocument retrievedDoc = taskRepository.findByTaskId(testTaskId,testTaskListName);
assertThat(retrievedDoc.taskId).isEqualTo(testTaskId);
assertThat(retrievedDoc.taskName).isEqualTo(testTaskName);
assertThat(retrievedDoc.taskListName).isEqualTo(testTaskListName);
}
@Test
void retrievesTask() {
String testTaskId = UUID.randomUUID().toString();
String testTaskName = "reads-persistence-task-name";
String testTaskType = "reads-persistence-task-type";
String testTaskOuri = "reads-persistence-test-task-ouri";
String testTaskStatus = Task.Status.OPEN.toString();
String testTaskListName = "tapas-tasks-tutors";
MongoTaskDocument mongoTask = new MongoTaskDocument(testTaskId, testTaskName, testTaskType, testTaskOuri,
testTaskStatus, testTaskListName);
taskRepository.insert(mongoTask);
Task retrievedTask = adapterUnderTest.loadTask(new Task.TaskId(testTaskId),
new TaskList.TaskListName(testTaskListName));
assertThat(retrievedTask.getTaskName().getValue()).isEqualTo(testTaskName);
assertThat(retrievedTask.getTaskId().getValue()).isEqualTo(testTaskId);
assertThat(retrievedTask.getTaskStatus().getValue()).isEqualTo(Task.Status.valueOf(testTaskStatus));
}
}

63
tapas-tasks/src/test/java/ch/unisg/tapastasks/tasks/application/service/AddNewTaskToTaskListServiceTest.java Normal file
View File

@ -0,0 +1,63 @@
package ch.unisg.tapastasks.tasks.application.service;
import ch.unisg.tapastasks.tasks.application.port.in.AddNewTaskToTaskListCommand;
import ch.unisg.tapastasks.tasks.application.port.out.AddTaskPort;
import ch.unisg.tapastasks.tasks.application.port.out.NewTaskAddedEventPort;
import ch.unisg.tapastasks.tasks.application.port.out.TaskListLock;
import ch.unisg.tapastasks.tasks.domain.NewTaskAddedEvent;
import ch.unisg.tapastasks.tasks.domain.Task;
import ch.unisg.tapastasks.tasks.domain.TaskList;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import java.util.Optional;
import static org.mockito.BDDMockito.*;
import static org.assertj.core.api.Assertions.*;
public class AddNewTaskToTaskListServiceTest {
private final AddTaskPort addTaskPort = Mockito.mock(AddTaskPort.class);
private final TaskListLock taskListLock = Mockito.mock(TaskListLock.class);
private final NewTaskAddedEventPort newTaskAddedEventPort = Mockito.mock(NewTaskAddedEventPort.class);
private final AddNewTaskToTaskListService addNewTaskToTaskListService = new AddNewTaskToTaskListService(
newTaskAddedEventPort, addTaskPort, taskListLock);
@Test
void addingSucceeds() {
Task newTask = givenATaskWithNameAndTypeAndURI(new Task.TaskName("test-task"),
new Task.TaskType("test-type"), Optional.of(new Task.OriginalTaskUri("example.org")));
TaskList taskList = givenAnEmptyTaskList(TaskList.getTapasTaskList());
AddNewTaskToTaskListCommand addNewTaskToTaskListCommand = new AddNewTaskToTaskListCommand(newTask.getTaskName(),
newTask.getTaskType(), Optional.ofNullable(newTask.getOriginalTaskUri()));
Task addedTask = addNewTaskToTaskListService.addNewTaskToTaskList(addNewTaskToTaskListCommand);
assertThat(addedTask).isNotNull();
assertThat(taskList.getListOfTasks().getValue()).hasSize(1);
then(taskListLock).should().lockTaskList(eq(TaskList.getTapasTaskList().getTaskListName()));
then(newTaskAddedEventPort).should(times(1))
.publishNewTaskAddedEvent(any(NewTaskAddedEvent.class));
}
private TaskList givenAnEmptyTaskList(TaskList taskList) {
taskList.getListOfTasks().getValue().clear();
return taskList;
}
private Task givenATaskWithNameAndTypeAndURI(Task.TaskName taskName, Task.TaskType taskType,
Optional<Task.OriginalTaskUri> originalTaskUri) {
Task task = Mockito.mock(Task.class);
given(task.getTaskName()).willReturn(taskName);
given(task.getTaskType()).willReturn(taskType);
given(task.getOriginalTaskUri()).willReturn(originalTaskUri.get());
return task;
}
}

49
tapas-tasks/src/test/java/ch/unisg/tapastasks/tasks/domain/TaskListTest.java Normal file
View File

@ -0,0 +1,49 @@
package ch.unisg.tapastasks.tasks.domain;
import org.junit.jupiter.api.Test;
import java.util.Optional;
import static org.assertj.core.api.Assertions.*;
public class TaskListTest {
@Test
void addNewTaskToTaskListSuccess() {
TaskList taskList = TaskList.getTapasTaskList();
taskList.getListOfTasks().getValue().clear();
Task newTask = taskList.addNewTaskWithNameAndType(new Task.TaskName("My-Test-Task"),
new Task.TaskType("My-Test-Type"));
assertThat(newTask.getTaskName().getValue()).isEqualTo("My-Test-Task");
assertThat(taskList.getListOfTasks().getValue()).hasSize(1);
assertThat(taskList.getListOfTasks().getValue().get(0)).isEqualTo(newTask);
}
@Test
void retrieveTaskSuccess() {
TaskList taskList = TaskList.getTapasTaskList();
Task newTask = taskList.addNewTaskWithNameAndType(new Task.TaskName("My-Test-Task2"),
new Task.TaskType("My-Test-Type2"));
Task retrievedTask = taskList.retrieveTaskById(newTask.getTaskId()).get();
assertThat(retrievedTask).isEqualTo(newTask);
}
@Test
void retrieveTaskFailure() {
TaskList taskList = TaskList.getTapasTaskList();
Task newTask = taskList.addNewTaskWithNameAndType(new Task.TaskName("My-Test-Task3"),
new Task.TaskType("My-Test-Type3"));
Task.TaskId fakeId = new Task.TaskId("fake-id");
Optional<Task> retrievedTask = taskList.retrieveTaskById(fakeId);
assertThat(retrievedTask.isPresent()).isFalse();
}
}

2
tapas-tasks/src/test/resources/application-test.properties Normal file
View File

@ -0,0 +1,2 @@
spring.data.mongodb.uri=mongodb://127.0.0.1:27017
spring.data.mongodb.database=tapas-tasks