diff --git a/goofy-client/apps/goofy-e2e/src/fixtures/kommentar/kommentar.json b/goofy-client/apps/goofy-e2e/src/fixtures/kommentar/kommentar.json index 99e43ec177555457ce0641f2986e54a577c51a93..3e0833b92c89f5e1b0b878a1d15aeb436fdc15bf 100644 --- a/goofy-client/apps/goofy-e2e/src/fixtures/kommentar/kommentar.json +++ b/goofy-client/apps/goofy-e2e/src/fixtures/kommentar/kommentar.json @@ -2,7 +2,6 @@ "createdAt": { "$date": "2021-03-17T08:43:52.741Z" }, - "createdBy": "", - "createdByName": "Karl Kommentar", + "createdBy": "Karl Kommentar", "text": "Test text to test the test text test" } \ No newline at end of file diff --git a/goofy-client/apps/goofy-e2e/src/model/kommentar.ts b/goofy-client/apps/goofy-e2e/src/model/kommentar.ts index 9efe8cf5188a92da9ddcae5204dc92ff20943fc6..5ce513a6c91f1a9aa4309eed0c0719b2d75b7d61 100644 --- a/goofy-client/apps/goofy-e2e/src/model/kommentar.ts +++ b/goofy-client/apps/goofy-e2e/src/model/kommentar.ts @@ -3,6 +3,5 @@ import { DateE2E } from './util'; export class KommentarE2E { createdAt: DateE2E; createdBy: string; - createdByName: string; text: string; } \ No newline at end of file diff --git a/goofy-client/libs/kommentar-shared/src/lib/kommentar.model.ts b/goofy-client/libs/kommentar-shared/src/lib/kommentar.model.ts index 940a89aac893fddb11bf28bbff6b3126900d443a..f220ad1714a2a0b10e1c1169f7dc80ad74d35f89 100644 --- a/goofy-client/libs/kommentar-shared/src/lib/kommentar.model.ts +++ b/goofy-client/libs/kommentar-shared/src/lib/kommentar.model.ts @@ -3,7 +3,7 @@ import { ListResource } from '@goofy-client/tech-shared'; import { Resource } from '@ngxp/rest'; export interface Kommentar { - createdByName: string; + createdBy: string; createdAt: Date; text: string; } diff --git a/goofy-client/libs/kommentar-shared/test/kommentar.ts b/goofy-client/libs/kommentar-shared/test/kommentar.ts index 820b8d9a047e169d96891431bc41c8290a2a2210..5d45e4904fd1fd630a401e3a15a4865af3220491 100644 --- a/goofy-client/libs/kommentar-shared/test/kommentar.ts +++ b/goofy-client/libs/kommentar-shared/test/kommentar.ts @@ -8,7 +8,7 @@ export function createKommentar(): Kommentar { return { text: faker.random.words(10), createdAt: faker.date.past(), - createdByName: faker.random.words(2) + createdBy: faker.random.words(2) } } diff --git a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandBody.java b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandBody.java index b3c47e8af27ec615e88062f22399c48dbf7563e4..f8e2c4cf1f1bde9745c1a9bac2a2caf4b595777e 100644 --- a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandBody.java +++ b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandBody.java @@ -3,6 +3,7 @@ package de.itvsh.goofy.common.command; import com.fasterxml.jackson.annotation.JsonSubTypes; import com.fasterxml.jackson.annotation.JsonSubTypes.Type; +import de.itvsh.goofy.kommentar.Kommentar; import de.itvsh.goofy.postfach.PostfachMail; import de.itvsh.goofy.vorgang.AssignUserCommandBody; import de.itvsh.goofy.vorgang.RedirectRequest; @@ -12,7 +13,8 @@ import de.itvsh.goofy.wiedervorlage.Wiedervorlage; @Type(value = PostfachMail.class, name = "SEND_POSTFACH_MAIL"), @Type(value = AssignUserCommandBody.class, name = "ASSIGN_USER"), @Type(value = RedirectRequest.class, name = "REDIRECT_VORGANG"), - @Type(value = Wiedervorlage.class, name = "WIEDERVORLAGE") + @Type(value = Wiedervorlage.class, name = "WIEDERVORLAGE"), + @Type(value = Kommentar.class, name = "KOMMENTAR") }) public interface CommandBody { diff --git a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandOrder.java b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandOrder.java index dfb37d8f12b20ba1ae0ebc65d7b16f332fb79612..136cf4ea625bb8e60c4cdb2e07b0da5ae29551ab 100644 --- a/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandOrder.java +++ b/goofy-server/src/main/java/de/itvsh/goofy/common/command/CommandOrder.java @@ -15,13 +15,13 @@ public enum CommandOrder { VORGANG_ZURUECKSTELLEN(true, Type.VORGANG), VORGANG_ABSCHLIESSEN(true, Type.VORGANG), VORGANG_WIEDEREROEFFNEN(true, Type.VORGANG), - // + ASSIGN_USER(false, Type.VORGANG), - // + REDIRECT_VORGANG(false, Type.FORWARDING), FORWARD_SUCCESSFULL(false, Type.FORWARDING), FORWARD_FAILED(false, Type.FORWARDING), - // + CREATE_KOMMENTAR(false, Type.KOMMENTAR), EDIT_KOMMENTAR(false, Type.KOMMENTAR), diff --git a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/Kommentar.java b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/Kommentar.java index 078b94223b11cfe8d625f8c7ae20a27127921a32..89eb1615fb6c468455689c949429c01e664907e6 100644 --- a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/Kommentar.java +++ b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/Kommentar.java @@ -12,6 +12,7 @@ import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonProperty.Access; import de.itvsh.goofy.common.LinkedResource; +import de.itvsh.goofy.common.command.CommandBody; import de.itvsh.goofy.common.user.UserProfileController; import lombok.AccessLevel; import lombok.AllArgsConstructor; @@ -25,17 +26,18 @@ import lombok.ToString; @NoArgsConstructor(access = AccessLevel.PRIVATE) @AllArgsConstructor(access = AccessLevel.PACKAGE) @ToString -public class Kommentar { +public class Kommentar implements CommandBody { @JsonIgnore private String id; + @JsonIgnore + private String vorgangId; + @JsonProperty(access = Access.READ_ONLY) @LinkedResource(controllerClass = UserProfileController.class) private String createdBy; @JsonProperty(access = Access.READ_ONLY) - private String createdByName; - @JsonProperty(access = Access.READ_ONLY) private ZonedDateTime createdAt; @NotNull(message = FIELD_IS_EMPTY) diff --git a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarCommandController.java b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarCommandController.java index 764eead15d4c09eb1918a9ab6b2f7309554b6d14..b9040667714e68b01695b0ee0290d02d29e6b3cf 100644 --- a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarCommandController.java +++ b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarCommandController.java @@ -2,6 +2,8 @@ package de.itvsh.goofy.kommentar; import static org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.*; +import java.time.ZonedDateTime; + import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.PathVariable; @@ -10,26 +12,50 @@ import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; +import de.itvsh.goofy.common.command.Command; import de.itvsh.goofy.common.command.CommandController; +import de.itvsh.goofy.common.command.CommandController.CommandByRelationController; +import de.itvsh.goofy.common.command.CommandOrder; +import de.itvsh.goofy.common.command.CreateCommand; +import de.itvsh.goofy.common.user.CurrentUserService; @RestController @RequestMapping(KommentarCommandController.KOMMENTAR_COMMANDS) public class KommentarCommandController { static final String KOMMENTAR_COMMANDS = "/api/kommentars/{kommentarId}/commands"; + static final String NOT_SET = "-1"; @Autowired private KommentarService service; + @Autowired + private CommandByRelationController commandByRelationController; + @PostMapping - public ResponseEntity<Void> createCommand(@RequestBody KommentarCommand command, @PathVariable String kommentarId) { - return buildResponseLink(service.createCommand(kommentarId, command)); + public ResponseEntity<Void> createCommand(@RequestBody KommentarCommand kommentarCommand, @PathVariable String kommentarId) { + var command = commandByRelationController.createCommand(buildCommand(service.getById(kommentarId), kommentarCommand), + KommentarRemoteService.ITEM_NAME); + return buildResponseLink(command); } - private ResponseEntity<Void> buildResponseLink(KommentarCommand createdKommentarCommand) { + private ResponseEntity<Void> buildResponseLink(Command createdKommentarCommand) { return ResponseEntity.created(linkTo(CommandController.class).slash(createdKommentarCommand.getId()).toUri()).build(); } + CreateCommand buildCommand(Kommentar kommentar, KommentarCommand command) { + var commandBuilder = CreateCommand.builder() + .order(CommandOrder.UPDATE_ATTACHED_ITEM) + .relationId(NOT_SET) + .vorgangId(kommentar.getVorgangId()); + + return commandBuilder.body(updateKommandByCommand(kommentar, command)).build(); + } + + private Kommentar updateKommandByCommand(Kommentar kommentar, KommentarCommand command) { + return kommentar.toBuilder().text(command.getKommentar().getText()).build(); + } + @RestController @RequestMapping(KommentarCommandByVorgangController.KOMMENTAR_COMMANDS_BY_VORGANG) public static class KommentarCommandByVorgangController { @@ -37,13 +63,33 @@ public class KommentarCommandController { static final String KOMMENTAR_COMMANDS_BY_VORGANG = "/api/vorgangs/{vorgangId}/kommentarCommands"; @Autowired - private KommentarService service; + private CommandByRelationController commandByRelationController; + + @Autowired + private CurrentUserService userService; @PostMapping() public ResponseEntity<Void> createCommand(@RequestBody KommentarCommand command, @PathVariable String vorgangId) { - var created = service.createCommand(vorgangId, command); + var createdCommand = commandByRelationController.createCommand(buildCommand(vorgangId, command), KommentarRemoteService.ITEM_NAME); + + return ResponseEntity.created(linkTo(CommandController.class).slash(createdCommand.getId()).toUri()).build(); + } - return ResponseEntity.created(linkTo(CommandController.class).slash(created.getId()).toUri()).build(); + CreateCommand buildCommand(String vorgangId, KommentarCommand command) { + return CreateCommand.builder() + .vorgangId(vorgangId) + .order(CommandOrder.CREATE_ATTACHED_ITEM) + .relationId(NOT_SET) + .body(buildBody(command.getKommentar())) + .build(); } + + Kommentar buildBody(Kommentar kommentar) { + return kommentar.toBuilder() + .createdAt(ZonedDateTime.now().withNano(0)) + .createdBy(userService.getUserId().toString()) + .build(); + } + } } diff --git a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarMapper.java b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarMapper.java index 23263f80c3f20a7b8314a5658843a8ad0e25e58e..c36561d38afa4080e10c69b1782aa37e57095400 100644 --- a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarMapper.java +++ b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarMapper.java @@ -1,5 +1,8 @@ package de.itvsh.goofy.kommentar; +import java.time.ZonedDateTime; +import java.util.Map; + import org.mapstruct.Mapper; import org.mapstruct.Mapping; import org.mapstruct.MappingConstants; @@ -7,21 +10,27 @@ import org.mapstruct.NullValueCheckStrategy; import org.mapstruct.ReportingPolicy; import org.mapstruct.ValueMapping; -import de.itvsh.goofy.common.IgnoreGrpcFields; import de.itvsh.ozg.pluto.grpc.command.GrpcCommand; -import de.itvsh.ozg.pluto.kommentar.GrpcKommentar; @Mapper(unmappedTargetPolicy = ReportingPolicy.ERROR, nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS) public interface KommentarMapper { - @Mapping(target = "textBytes", ignore = true) - @IgnoreGrpcFields - GrpcKommentar toGrpcKommentar(Kommentar kommentar); - - Kommentar toKommentar(GrpcKommentar grpcKommentar); + static final String ID = "id"; + static final String TEXT = "text"; + static final String CREATED_BY = "createdBy"; + static final String CREATED_AT = "createdAt"; @Mapping(target = "kommentar", ignore = true) @ValueMapping(source = "UNRECOGNIZED", target = MappingConstants.NULL) @ValueMapping(source = "UNDEFINED", target = MappingConstants.NULL) KommentarCommand toKommentarCommand(GrpcCommand command); + + default Kommentar fromItemMap(Map<String, Object> map) { + return Kommentar.builder() + .id((String) map.get(ID)) + .createdAt(ZonedDateTime.parse((String) map.get(CREATED_AT))) + .createdBy((String) map.get(CREATED_BY)) + .text((String) map.get(TEXT)) + .build(); + } } diff --git a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarRemoteService.java b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarRemoteService.java index ae337b684cfd9d475ace5e633f217364c2514092..11ee02a8f99dc649ec533afcafbb1a75a32c4299 100644 --- a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarRemoteService.java +++ b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarRemoteService.java @@ -5,60 +5,48 @@ import java.util.stream.Stream; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; -import de.itvsh.goofy.common.callcontext.ContextService; -import de.itvsh.ozg.pluto.grpc.command.GrpcCreateCommandRequest; -import de.itvsh.ozg.pluto.grpc.command.GrpcOrder; -import de.itvsh.ozg.pluto.kommentar.GrpcFindKommentarsByVorgangIdRequest; -import de.itvsh.ozg.pluto.kommentar.GrpcFindKommentarsByVorgangIdResponse; -import de.itvsh.ozg.pluto.kommentar.GrpcGetKommentarRequest; -import de.itvsh.ozg.pluto.kommentar.GrpcGetKommentarResponse; -import de.itvsh.ozg.pluto.kommentar.KommentarServiceGrpc.KommentarServiceBlockingStub; +import de.itvsh.goofy.GoofyServerApplication; +import de.itvsh.ozg.pluto.common.GrpcObjectMapper; +import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcFindVorgangAttachedItemRequest; +import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcFindVorgangAttachedItemResponse; +import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcVorgangAttachedItemRequest; +import de.itvsh.ozg.pluto.vorgangAttachedItem.VorgangAttachedItemServiceGrpc.VorgangAttachedItemServiceBlockingStub; import net.devh.boot.grpc.client.inject.GrpcClient; @Service class KommentarRemoteService { + static final String ITEM_NAME = "Kommentar"; - @GrpcClient("pluto") - private KommentarServiceBlockingStub serviceStub; - @Autowired - private ContextService contextService; + @GrpcClient(GoofyServerApplication.GRPC_CLIENT) + private VorgangAttachedItemServiceBlockingStub vorgangAttachedItemServiceStub; @Autowired private KommentarMapper mapper; + @Autowired + private GrpcObjectMapper grpcObjectMapper; public Stream<Kommentar> findByVorgangId(String vorgangId) { - GrpcFindKommentarsByVorgangIdResponse response = serviceStub - .findKommentarsByVorgangId(buildFindKommentarsByVorgangRequest(vorgangId)); + GrpcFindVorgangAttachedItemResponse response = vorgangAttachedItemServiceStub + .find(buildFindRequest(vorgangId)); - return response.getKommentarsList().stream().map(mapper::toKommentar); + return response.getVorgangAttachedItemsList().stream() + .map(item -> grpcObjectMapper.mapFromGrpc(item.getItem())) + .map(mapper::fromItemMap); } - private GrpcFindKommentarsByVorgangIdRequest buildFindKommentarsByVorgangRequest(String vorgangId) { - return GrpcFindKommentarsByVorgangIdRequest.newBuilder().setVorgangId(vorgangId).build(); + GrpcFindVorgangAttachedItemRequest buildFindRequest(String vorgangId) { + return GrpcFindVorgangAttachedItemRequest.newBuilder() + .setVorgangId(vorgangId) + .setItemName(ITEM_NAME) + .build(); } public Kommentar getById(String kommentarId) { - GrpcGetKommentarResponse response = serviceStub.getKommentar(buildGetKommentarRequest(kommentarId)); - - return mapper.toKommentar(response.getKommentar()); - } - - private GrpcGetKommentarRequest buildGetKommentarRequest(String kommentarId) { - return GrpcGetKommentarRequest.newBuilder().setId(kommentarId).build(); + var response = vorgangAttachedItemServiceStub.getById(buildRequest(kommentarId)); + var kommentar = mapper.fromItemMap(grpcObjectMapper.mapFromGrpc(response.getVorgangAttachedItem().getItem())); + return kommentar.toBuilder().vorgangId(response.getVorgangAttachedItem().getVorgangId()).build(); } - public KommentarCommand sendKommentarCommand(String relationId, KommentarCommand command) { - var request = buildCreateCommandRequest(relationId, command); - var response = serviceStub.createCommand(request); - - return mapper.toKommentarCommand(response.getCommand()); - } - - GrpcCreateCommandRequest buildCreateCommandRequest(String relationId, KommentarCommand command) { - return GrpcCreateCommandRequest.newBuilder() - .setCallContext(contextService.createCallContext()) - .setRelationId(relationId) - .setOrder(GrpcOrder.valueOf(command.getOrder().name())) - .setKommentar(mapper.toGrpcKommentar(command.getKommentar())) - .build(); + private GrpcVorgangAttachedItemRequest buildRequest(String kommentarId) { + return GrpcVorgangAttachedItemRequest.newBuilder().setId(kommentarId).build(); } } diff --git a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarService.java b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarService.java index 84b0c3fa3d435b273887d916c533f5e6f774e031..8b14e5f2262ef7a7628d9c2526f3704fa9654707 100644 --- a/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarService.java +++ b/goofy-server/src/main/java/de/itvsh/goofy/kommentar/KommentarService.java @@ -2,8 +2,6 @@ package de.itvsh.goofy.kommentar; import java.util.stream.Stream; -import javax.validation.Valid; - import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.validation.annotation.Validated; @@ -22,8 +20,4 @@ class KommentarService { public Kommentar getById(String kommentarId) { return remoteService.getById(kommentarId); } - - public KommentarCommand createCommand(String relationId, @Valid KommentarCommand command) { - return remoteService.sendKommentarCommand(relationId, command); - } } diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/GrpcKommentarTestFactory.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/GrpcKommentarTestFactory.java deleted file mode 100644 index 6064c182ae49773e18bd7a6b57a612bfca5e9041..0000000000000000000000000000000000000000 --- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/GrpcKommentarTestFactory.java +++ /dev/null @@ -1,25 +0,0 @@ -package de.itvsh.goofy.kommentar; - -import de.itvsh.ozg.pluto.kommentar.GrpcKommentar; - -public class GrpcKommentarTestFactory { - - final static String ID = KommentarTestFactory.ID; - final static String CREATED_BY = KommentarTestFactory.CREATED_BY; - final static String CREATED_BY_NAME = KommentarTestFactory.CREATED_BY_NAME; - final static String CREATED_AT_STR = KommentarTestFactory.CREATED_AT_STR; - final static String TEXT = KommentarTestFactory.TEXT; - - public static GrpcKommentar create() { - return createBuilder().build(); - } - - public static GrpcKommentar.Builder createBuilder() { - return GrpcKommentar.newBuilder() - .setId(ID) - .setCreatedBy(CREATED_BY) - .setCreatedByName(CREATED_BY_NAME) - .setCreatedAt(CREATED_AT_STR) - .setText(TEXT); - } -} diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandControllerTest.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandControllerTest.java index 2f67bba4bd69e06282af0f8d3519439c3c6616d1..3eb84c3ec6ae60f487ba067875086369004b81bc 100644 --- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandControllerTest.java +++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandControllerTest.java @@ -7,6 +7,8 @@ import static org.mockito.Mockito.*; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*; +import java.util.UUID; + import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -19,14 +21,19 @@ import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.ResultActions; import org.springframework.test.web.servlet.setup.MockMvcBuilders; +import de.itvsh.goofy.common.command.CommandController.CommandByRelationController; import de.itvsh.goofy.common.command.CommandOrder; +import de.itvsh.goofy.common.command.CommandTestFactory; +import de.itvsh.goofy.common.command.CreateCommand; +import de.itvsh.goofy.common.user.CurrentUserService; +import de.itvsh.goofy.common.user.UserId; import de.itvsh.goofy.kommentar.KommentarCommandController.KommentarCommandByVorgangController; import de.itvsh.goofy.vorgang.VorgangHeaderTestFactory; class KommentarCommandControllerTest { @Captor - private ArgumentCaptor<KommentarCommand> commandCaptor; + private ArgumentCaptor<CreateCommand> commandCaptor; @Nested class TestCreateKommentarCommandByVorgang { @@ -35,13 +42,18 @@ class KommentarCommandControllerTest { private KommentarCommandByVorgangController controller; @Mock private KommentarService service; + @Mock + private CommandByRelationController commandByRelationController; + @Mock + private CurrentUserService userService; private MockMvc mockMvc; @BeforeEach void init() { mockMvc = MockMvcBuilders.standaloneSetup(controller).build(); - when(service.createCommand(anyString(), any())).thenReturn(KommentarCommandTestFactory.create()); + when(userService.getUserId()).thenReturn(UserId.from(UUID.randomUUID())); + when(commandByRelationController.createCommand(any(), anyString())).thenReturn(CommandTestFactory.create()); } @Test @@ -53,19 +65,21 @@ class KommentarCommandControllerTest { void shouldCallService() throws Exception { doRequest(); - verify(service).createCommand(eq(VorgangHeaderTestFactory.ID), notNull()); + verify(commandByRelationController).createCommand(any(), eq(KommentarRemoteService.ITEM_NAME)); } @Test void shouldGiveCommandToService() throws Exception { doRequest(); - verify(service).createCommand(eq(VorgangHeaderTestFactory.ID), commandCaptor.capture()); + verify(commandByRelationController).createCommand(commandCaptor.capture(), anyString()); var command = commandCaptor.getValue(); assertThat(command).usingRecursiveComparison() - .ignoringFields("kommentar.id", "kommentar.createdBy", "kommentar.createdByName", "kommentar.createdAt") - .isEqualTo(KommentarCommandTestFactory.createBuilder().id(null).build()); + .ignoringFields("body", "status") + .isEqualTo(CommandTestFactory.createBuilder().order(CommandOrder.CREATE_ATTACHED_ITEM) + .relationId(KommentarCommandController.NOT_SET) + .id(null).build()); } private ResultActions doRequest() throws Exception { @@ -83,6 +97,8 @@ class KommentarCommandControllerTest { @InjectMocks private KommentarCommandController controller; @Mock + private CommandByRelationController commandByRelationController; + @Mock private KommentarService service; private MockMvc mockMvc; @@ -90,8 +106,8 @@ class KommentarCommandControllerTest { @BeforeEach void init() { mockMvc = MockMvcBuilders.standaloneSetup(controller).build(); - when(service.createCommand(anyString(), any())).thenReturn(KommentarCommandTestFactory.createBuilder() - .order(CommandOrder.EDIT_KOMMENTAR).build()); + when(commandByRelationController.createCommand(any(), anyString())).thenReturn(CommandTestFactory.create()); + when(service.getById(any())).thenReturn(KommentarTestFactory.createBuilder().vorgangId(VorgangHeaderTestFactory.ID).build()); } @Test @@ -103,19 +119,21 @@ class KommentarCommandControllerTest { void shouldCallService() throws Exception { doRequest(); - verify(service).createCommand(anyString(), notNull()); + verify(service).getById(any()); } @Test void shouldGiveCommandToService() throws Exception { doRequest(); - verify(service).createCommand(anyString(), commandCaptor.capture()); + verify(commandByRelationController).createCommand(commandCaptor.capture(), anyString()); var command = commandCaptor.getValue(); assertThat(command).usingRecursiveComparison() - .ignoringFields("kommentar.id", "kommentar.createdBy", "kommentar.createdByName", "kommentar.createdAt") - .isEqualTo(KommentarCommandTestFactory.createBuilder().id(null).build()); + .ignoringFields("body", "status") + .isEqualTo(CommandTestFactory.createBuilder().order(CommandOrder.UPDATE_ATTACHED_ITEM) + .relationId(KommentarCommandController.NOT_SET).id(null) + .build()); } @Test diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandITCase.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandITCase.java index 000d82d4797926a848d0445e598241f7148f7d74..37c96c2c937358f455fab7fcc967503267cf42ab 100644 --- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandITCase.java +++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarCommandITCase.java @@ -22,6 +22,8 @@ import org.springframework.test.web.servlet.ResultActions; import de.itvsh.goofy.common.ValidationMessageCodes; import de.itvsh.goofy.common.command.CommandOrder; +import de.itvsh.goofy.common.command.CommandRemoteService; +import de.itvsh.goofy.common.command.CommandTestFactory; import de.itvsh.goofy.kommentar.KommentarCommandController.KommentarCommandByVorgangController; import de.itvsh.goofy.vorgang.VorgangHeaderTestFactory; @@ -34,6 +36,8 @@ class KommentarCommandITCase { private MockMvc mockMvc; @MockBean private KommentarRemoteService remoteService; + @MockBean + private CommandRemoteService commandRemoteService; @WithMockUser @Nested @@ -41,14 +45,15 @@ class KommentarCommandITCase { @BeforeEach void initTest() { - when(remoteService.sendKommentarCommand(anyString(), any())).thenReturn(KommentarCommandTestFactory.create()); + when(remoteService.getById(any())).thenReturn(KommentarTestFactory.create()); + when(commandRemoteService.createCommand(any(), anyString())).thenReturn(CommandTestFactory.create()); } @Test void shouldCreateCommand() throws Exception { doRequestByKommentarId(createValidRequestContent()).andExpect(status().isCreated()); - verify(remoteService).sendKommentarCommand(eq(KommentarTestFactory.ID), any()); + verify(commandRemoteService).createCommand(any(), eq(KommentarRemoteService.ITEM_NAME)); } @WithMockUser @@ -63,7 +68,7 @@ class KommentarCommandITCase { doRequestByKommentarId(content).andExpect(status().isUnprocessableEntity()) .andExpect(jsonPath("$.issues.length()").value(1)) - .andExpect(jsonPath("$.issues.[0].field").value("command.kommentar.text")) + .andExpect(jsonPath("$.issues.[0].field").value("command.body.text")) .andExpect(jsonPath("$.issues.[0].messageCode").value(ValidationMessageCodes.FIELD_IS_EMPTY)); } @@ -73,7 +78,7 @@ class KommentarCommandITCase { String content = buildContentWithText(StringUtils.EMPTY); doRequestByKommentarId(content).andExpect(status().isUnprocessableEntity()) - .andExpect(jsonPath("$.issues.[0].field").value("command.kommentar.text")); + .andExpect(jsonPath("$.issues.[0].field").value("command.body.text")); } @@ -88,7 +93,7 @@ class KommentarCommandITCase { private String buildContentWithText(String text) { return createRequestContent(KommentarCommandTestFactory.createBuilder() - .order(CommandOrder.EDIT_KOMMENTAR) + .order(CommandOrder.CREATE_ATTACHED_ITEM) .kommentar(KommentarTestFactory.createBuilder().text(text).build()) .build()); } @@ -107,14 +112,15 @@ class KommentarCommandITCase { @BeforeEach void initTest() { - when(remoteService.sendKommentarCommand(anyString(), any())).thenReturn(KommentarCommandTestFactory.create()); + when(remoteService.getById(any())).thenReturn(KommentarTestFactory.create()); + when(commandRemoteService.createCommand(any(), anyString())).thenReturn(CommandTestFactory.create()); } @Test void shouldCreateCommand() throws Exception { doRequestByVorgangId(createValidRequestContent()).andExpect(status().isCreated()); - verify(remoteService).sendKommentarCommand(eq(VorgangHeaderTestFactory.ID), any()); + verify(commandRemoteService).createCommand(any(), eq(KommentarRemoteService.ITEM_NAME)); } @WithMockUser @@ -129,7 +135,7 @@ class KommentarCommandITCase { doRequestByVorgangId(content).andExpect(status().isUnprocessableEntity()) .andExpect(jsonPath("$.issues.length()").value(1)) - .andExpect(jsonPath("$.issues.[0].field").value("command.kommentar.text")) + .andExpect(jsonPath("$.issues.[0].field").value("command.body.text")) .andExpect(jsonPath("$.issues.[0].messageCode").value(ValidationMessageCodes.FIELD_IS_EMPTY)); } @@ -139,7 +145,7 @@ class KommentarCommandITCase { String content = buildContentWithText(StringUtils.EMPTY); doRequestByVorgangId(content).andExpect(status().isUnprocessableEntity()) - .andExpect(jsonPath("$.issues.[0].field").value("command.kommentar.text")); + .andExpect(jsonPath("$.issues.[0].field").value("command.body.text")); } diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarMapperTest.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarMapperTest.java index 379f512ecf1106daa56f4fcdc075dfa559db6642..74380e47bbbb5e6315f72c9cac7853d6aaf961a2 100644 --- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarMapperTest.java +++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarMapperTest.java @@ -11,39 +11,37 @@ class KommentarMapperTest { private KommentarMapper mapper = Mappers.getMapper(KommentarMapper.class); @Nested - class TestFromGrpc { - + class TestFromItemMap { @Test - void shouldMap() { - var kommentar = mapper.toKommentar(GrpcKommentarTestFactory.create()); + void shouldMapId() { + var kommentar = map(); - assertThat(kommentar).isNotNull().usingRecursiveComparison().isEqualTo(KommentarTestFactory.create()); + assertThat(kommentar.getId()).isEqualTo(KommentarTestFactory.ID); } @Test - void shouldHandleNull() { - var grpcKommentar = mapper.toKommentar(null); + void shouldMapCreatedBy() { + var kommentar = map(); - assertThat(grpcKommentar).isNull(); + assertThat(kommentar.getCreatedBy()).isEqualTo(KommentarTestFactory.CREATED_BY); } - } - - @Nested - class TestToGrpc { @Test - void shouldMap() { - var grpcKommentar = mapper.toGrpcKommentar(KommentarTestFactory.createBuilder().id(null).build()); + void shouldMapCreatedAt() { + var kommentar = map(); - assertThat(grpcKommentar).isNotNull().usingRecursiveComparison().ignoringFields("id_", "memoizedHashCode") - .isEqualTo(GrpcKommentarTestFactory.create()); + assertThat(kommentar.getCreatedAt()).isEqualTo(KommentarTestFactory.CREATED_AT); } @Test - void shouldHandleNull() { - var grpcKommentar = mapper.toGrpcKommentar(null); + void shouldMapText() { + var kommentar = map(); - assertThat(grpcKommentar).isNull(); + assertThat(kommentar.getText()).isEqualTo(KommentarTestFactory.TEXT); } } + + private Kommentar map() { + return mapper.fromItemMap(KommentarTestFactory.createAsMap()); + } } diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarRemoteServiceTest.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarRemoteServiceTest.java index 4e30b113e9e504fd110bda0daf2a9cdca21a1440..45ad4afbbbfec175aceb96ebc97e9c367875affa 100644 --- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarRemoteServiceTest.java +++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarRemoteServiceTest.java @@ -3,28 +3,24 @@ package de.itvsh.goofy.kommentar; import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.*; -import java.util.stream.Collectors; import java.util.stream.Stream; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.Spy; -import de.itvsh.goofy.common.callcontext.ContextService; -import de.itvsh.goofy.common.command.GrpcCommandResponseTestFactory; +import de.itvsh.goofy.vorgang.GrpcVorgangAttachedItemTestFactory; import de.itvsh.goofy.vorgang.VorgangHeaderTestFactory; -import de.itvsh.ozg.pluto.grpc.command.GrpcCallContext; -import de.itvsh.ozg.pluto.grpc.command.GrpcCommandResponse; -import de.itvsh.ozg.pluto.kommentar.GrpcFindKommentarsByVorgangIdRequest; -import de.itvsh.ozg.pluto.kommentar.GrpcFindKommentarsByVorgangIdResponse; -import de.itvsh.ozg.pluto.kommentar.GrpcGetKommentarRequest; -import de.itvsh.ozg.pluto.kommentar.GrpcGetKommentarResponse; -import de.itvsh.ozg.pluto.kommentar.GrpcKommentar; -import de.itvsh.ozg.pluto.kommentar.KommentarServiceGrpc.KommentarServiceBlockingStub; +import de.itvsh.ozg.pluto.common.GrpcObjectMapper; +import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcFindVorgangAttachedItemRequest; +import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcFindVorgangAttachedItemResponse; +import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcVorgangAttachedItem; +import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcVorgangAttachedItemRequest; +import de.itvsh.ozg.pluto.vorgangAttachedItem.GrpcVorgangAttachedItemResponse; +import de.itvsh.ozg.pluto.vorgangAttachedItem.VorgangAttachedItemServiceGrpc.VorgangAttachedItemServiceBlockingStub; class KommentarRemoteServiceTest { @@ -33,33 +29,34 @@ class KommentarRemoteServiceTest { private KommentarRemoteService service; @Mock - private KommentarMapper mapper; + private VorgangAttachedItemServiceBlockingStub vorgangAttachedItemServiceStub; @Mock - private KommentarServiceBlockingStub serviceStub; + private KommentarMapper mapper; @Mock - private ContextService contextService; + private GrpcObjectMapper grpcObjectMapper; - private GrpcKommentar kommentar = GrpcKommentarTestFactory.create(); + private GrpcVorgangAttachedItem kommentar = GrpcVorgangAttachedItemTestFactory.create(); @Nested class TestFindByVorgangId { - private GrpcFindKommentarsByVorgangIdRequest request = GrpcFindKommentarsByVorgangIdRequest.newBuilder() - .setVorgangId(VorgangHeaderTestFactory.ID).build(); - private GrpcFindKommentarsByVorgangIdResponse response = GrpcFindKommentarsByVorgangIdResponse.newBuilder() - .addKommentars(kommentar) - .addKommentars(kommentar).build(); + private GrpcFindVorgangAttachedItemRequest request = GrpcFindVorgangAttachedItemRequest.newBuilder() + .setVorgangId(VorgangHeaderTestFactory.ID).setItemName(KommentarRemoteService.ITEM_NAME).build(); + private GrpcFindVorgangAttachedItemResponse response = GrpcFindVorgangAttachedItemResponse.newBuilder() + .clearVorgangAttachedItems() + .addVorgangAttachedItems(kommentar) + .addVorgangAttachedItems(kommentar).build(); @BeforeEach void mockStub() { - when(serviceStub.findKommentarsByVorgangId(any())).thenReturn(response); + when(vorgangAttachedItemServiceStub.find(any())).thenReturn(response); } @Test void shouldCallStub() { service.findByVorgangId(VorgangHeaderTestFactory.ID); - verify(serviceStub).findKommentarsByVorgangId(request); + verify(vorgangAttachedItemServiceStub).find(request); } @Test @@ -67,78 +64,39 @@ class KommentarRemoteServiceTest { Stream<Kommentar> result = service.findByVorgangId(VorgangHeaderTestFactory.ID); collectStreamElementsToTriggerLazyStream(result); - verify(mapper, times(2)).toKommentar(kommentar); + verify(mapper, times(2)).fromItemMap(any()); } private void collectStreamElementsToTriggerLazyStream(Stream<Kommentar> stream) { - stream.collect(Collectors.toList()); + stream.toList(); } } @Nested class TestGetById { - - private GrpcGetKommentarRequest request = GrpcGetKommentarRequest.newBuilder().setId(KommentarTestFactory.ID).build(); - private GrpcGetKommentarResponse response = GrpcGetKommentarResponse.newBuilder().setKommentar(kommentar).build(); + GrpcVorgangAttachedItemResponse response = GrpcVorgangAttachedItemResponse.newBuilder() + .setVorgangAttachedItem(GrpcVorgangAttachedItemTestFactory.create()).build(); + GrpcVorgangAttachedItemRequest request = GrpcVorgangAttachedItemRequest.newBuilder().setId(KommentarTestFactory.ID).build(); @BeforeEach void mockStub() { - when(serviceStub.getKommentar(any())).thenReturn(response); + when(vorgangAttachedItemServiceStub.getById(any())).thenReturn(response); + when(grpcObjectMapper.mapFromGrpc(any())).thenReturn(KommentarTestFactory.createAsMap()); + when(mapper.fromItemMap(any())).thenReturn(KommentarTestFactory.create()); } @Test void shouldCallStub() { service.getById(KommentarTestFactory.ID); - verify(serviceStub).getKommentar(request); + verify(vorgangAttachedItemServiceStub).getById(request); } @Test void shouldCallMapper() { service.getById(KommentarTestFactory.ID); - verify(mapper).toKommentar(kommentar); - } - } - - @Nested - class TestSendKommentarCommand { - - private GrpcCallContext callContext = GrpcCallContext.newBuilder().build(); - private GrpcCommandResponse response = GrpcCommandResponseTestFactory.createBuilder().build(); - - @BeforeEach - void initTest() { - when(serviceStub.createCommand(any())).thenReturn(response); - when(contextService.createCallContext()).thenReturn(callContext); - when(mapper.toGrpcKommentar(any())).thenReturn(GrpcKommentarTestFactory.create()); - when(mapper.toKommentarCommand(any())).thenReturn(KommentarCommandTestFactory.create()); - } - - @Test - @DisplayName("Should call buildCreateCommandRequest with VorgangId") - void shouldCallCreateRequestWithVorgangId() { - doRequest(); - - verify(service).buildCreateCommandRequest(eq(VorgangHeaderTestFactory.ID), any()); - } - - @Test - void shouldCallStub() { - doRequest(); - - verify(serviceStub).createCommand(any()); - } - - @Test - void shouldMapResult() { - doRequest(); - - verify(mapper).toKommentarCommand(any()); - } - - private void doRequest() { - service.sendKommentarCommand(VorgangHeaderTestFactory.ID, KommentarCommandTestFactory.create()); + verify(mapper).fromItemMap(any()); } } } diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarServiceTest.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarServiceTest.java index 7d9853445c31029cbb39aace9a9e75a4bfb5937b..d7193d38b9d8ba7ae8385d7e2414f0e42a2d45e8 100644 --- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarServiceTest.java +++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarServiceTest.java @@ -1,7 +1,5 @@ package de.itvsh.goofy.kommentar; -import static org.assertj.core.api.Assertions.*; -import static org.mockito.ArgumentMatchers.*; import static org.mockito.Mockito.*; import org.junit.jupiter.api.Nested; @@ -40,27 +38,4 @@ class KommentarServiceTest { verify(remoteService).findByVorgangId(VorgangHeaderTestFactory.ID); } } - - @Nested - class TestCreateCommand { - - @Test - void shouldCallRemoteService() { - KommentarCommand command = KommentarCommandTestFactory.create(); - - service.createCommand(VorgangHeaderTestFactory.ID, command); - - verify(remoteService).sendKommentarCommand(VorgangHeaderTestFactory.ID, command); - } - - @Test - void shouldReturnCorrectResult() { - KommentarCommand resultFromRemoteService = KommentarCommandTestFactory.create(); - when(remoteService.sendKommentarCommand(anyString(), any())).thenReturn(resultFromRemoteService); - - KommentarCommand resultFromService = service.createCommand(VorgangHeaderTestFactory.ID, KommentarCommandTestFactory.create()); - - assertThat(resultFromService).isSameAs(resultFromRemoteService); - } - } } diff --git a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarTestFactory.java b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarTestFactory.java index 2d7b464ec849994bd06cb7b89214ff491b7dd3bf..99abb0b24b22ca5ab6743ae4de507409dfdf0995 100644 --- a/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarTestFactory.java +++ b/goofy-server/src/test/java/de/itvsh/goofy/kommentar/KommentarTestFactory.java @@ -1,6 +1,7 @@ package de.itvsh.goofy.kommentar; import java.time.ZonedDateTime; +import java.util.Map; import java.util.UUID; import com.thedeanda.lorem.Lorem; @@ -15,7 +16,6 @@ public class KommentarTestFactory { public static final String ID = UUID.randomUUID().toString(); public static final String CREATED_BY = UserProfileTestFactory.ID.toString(); - public static final String CREATED_BY_NAME = lorem.getName(); public static final String CREATED_AT_STR = "2021-01-10T10:30:00Z"; public static final ZonedDateTime CREATED_AT = ZonedDateTime.parse(CREATED_AT_STR); @@ -30,7 +30,14 @@ public class KommentarTestFactory { .id(ID) .text(TEXT) .createdBy(CREATED_BY) - .createdByName(CREATED_BY_NAME) .createdAt(CREATED_AT); } + + public static Map<String, Object> createAsMap() { + return Map.of( + KommentarMapper.ID, ID, + KommentarMapper.TEXT, TEXT, + KommentarMapper.CREATED_BY, CREATED_BY, + KommentarMapper.CREATED_AT, CREATED_AT_STR); + } }