From 72d59b4948fdbc81d08fb7a6dbed2b245ec0de69 Mon Sep 17 00:00:00 2001 From: Sebastian Frick Date: Wed, 25 Feb 2026 21:41:45 +0100 Subject: [PATCH] =?UTF-8?q?feat(production):=20Produktionsauftrag=20abschl?= =?UTF-8?q?ie=C3=9Fen=20und=20stornieren=20(US-P16)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Complete: IN_PROGRESS → COMPLETED (nur wenn Batch COMPLETED) Cancel: PLANNED/RELEASED → CANCELLED (nicht aus IN_PROGRESS) Domain-, UseCase-, Integration- und Lasttests ergänzt. --- .../production/CancelProductionOrder.java | 60 ++++ .../production/CompleteProductionOrder.java | 86 +++++ .../command/CancelProductionOrderCommand.java | 4 + .../CompleteProductionOrderCommand.java | 4 + .../domain/production/ProductionOrder.java | 20 ++ .../production/ProductionOrderError.java | 5 + .../ProductionUseCaseConfiguration.java | 17 + .../controller/ProductionOrderController.java | 50 ++- .../web/dto/CancelProductionOrderRequest.java | 6 + .../ProductionErrorHttpStatusMapper.java | 1 + .../production/CancelProductionOrderTest.java | 180 ++++++++++ .../CompleteProductionOrderTest.java | 255 ++++++++++++++ .../production/ProductionOrderTest.java | 174 ++++++++++ ...ductionOrderControllerIntegrationTest.java | 317 +++++++++++++++++- .../loadtest/scenario/ProductionScenario.java | 32 ++ .../simulation/FullWorkloadSimulation.java | 2 + .../loadtest/util/JsonBodyBuilder.java | 5 + 17 files changed, 1216 insertions(+), 2 deletions(-) create mode 100644 backend/src/main/java/de/effigenix/application/production/CancelProductionOrder.java create mode 100644 backend/src/main/java/de/effigenix/application/production/CompleteProductionOrder.java create mode 100644 backend/src/main/java/de/effigenix/application/production/command/CancelProductionOrderCommand.java create mode 100644 backend/src/main/java/de/effigenix/application/production/command/CompleteProductionOrderCommand.java create mode 100644 backend/src/main/java/de/effigenix/infrastructure/production/web/dto/CancelProductionOrderRequest.java create mode 100644 backend/src/test/java/de/effigenix/application/production/CancelProductionOrderTest.java create mode 100644 backend/src/test/java/de/effigenix/application/production/CompleteProductionOrderTest.java diff --git a/backend/src/main/java/de/effigenix/application/production/CancelProductionOrder.java b/backend/src/main/java/de/effigenix/application/production/CancelProductionOrder.java new file mode 100644 index 0000000..fa5b019 --- /dev/null +++ b/backend/src/main/java/de/effigenix/application/production/CancelProductionOrder.java @@ -0,0 +1,60 @@ +package de.effigenix.application.production; + +import de.effigenix.application.production.command.CancelProductionOrderCommand; +import de.effigenix.domain.production.*; +import de.effigenix.shared.common.Result; +import de.effigenix.shared.persistence.UnitOfWork; +import de.effigenix.shared.security.ActorId; +import de.effigenix.shared.security.AuthorizationPort; + +public class CancelProductionOrder { + + private final ProductionOrderRepository productionOrderRepository; + private final AuthorizationPort authorizationPort; + private final UnitOfWork unitOfWork; + + public CancelProductionOrder( + ProductionOrderRepository productionOrderRepository, + AuthorizationPort authorizationPort, + UnitOfWork unitOfWork + ) { + this.productionOrderRepository = productionOrderRepository; + this.authorizationPort = authorizationPort; + this.unitOfWork = unitOfWork; + } + + public Result execute(CancelProductionOrderCommand cmd, ActorId performedBy) { + if (!authorizationPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)) { + return Result.failure(new ProductionOrderError.Unauthorized("Not authorized to cancel production orders")); + } + + var orderId = ProductionOrderId.of(cmd.productionOrderId()); + ProductionOrder order; + switch (productionOrderRepository.findById(orderId)) { + case Result.Failure(var err) -> { + return Result.failure(new ProductionOrderError.RepositoryFailure(err.message())); + } + case Result.Success(var opt) -> { + if (opt.isEmpty()) { + return Result.failure(new ProductionOrderError.ProductionOrderNotFound(orderId)); + } + order = opt.get(); + } + } + + switch (order.cancel()) { + case Result.Failure(var err) -> { return Result.failure(err); } + case Result.Success(var ignored) -> { } + } + + return unitOfWork.executeAtomically(() -> { + switch (productionOrderRepository.save(order)) { + case Result.Failure(var err) -> { + return Result.failure(new ProductionOrderError.RepositoryFailure(err.message())); + } + case Result.Success(var ignored) -> { } + } + return Result.success(order); + }); + } +} diff --git a/backend/src/main/java/de/effigenix/application/production/CompleteProductionOrder.java b/backend/src/main/java/de/effigenix/application/production/CompleteProductionOrder.java new file mode 100644 index 0000000..af9eed3 --- /dev/null +++ b/backend/src/main/java/de/effigenix/application/production/CompleteProductionOrder.java @@ -0,0 +1,86 @@ +package de.effigenix.application.production; + +import de.effigenix.application.production.command.CompleteProductionOrderCommand; +import de.effigenix.domain.production.*; +import de.effigenix.shared.common.Result; +import de.effigenix.shared.persistence.UnitOfWork; +import de.effigenix.shared.security.ActorId; +import de.effigenix.shared.security.AuthorizationPort; + +public class CompleteProductionOrder { + + private final ProductionOrderRepository productionOrderRepository; + private final BatchRepository batchRepository; + private final AuthorizationPort authorizationPort; + private final UnitOfWork unitOfWork; + + public CompleteProductionOrder( + ProductionOrderRepository productionOrderRepository, + BatchRepository batchRepository, + AuthorizationPort authorizationPort, + UnitOfWork unitOfWork + ) { + this.productionOrderRepository = productionOrderRepository; + this.batchRepository = batchRepository; + this.authorizationPort = authorizationPort; + this.unitOfWork = unitOfWork; + } + + public Result execute(CompleteProductionOrderCommand cmd, ActorId performedBy) { + if (!authorizationPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)) { + return Result.failure(new ProductionOrderError.Unauthorized("Not authorized to complete production orders")); + } + + var orderId = ProductionOrderId.of(cmd.productionOrderId()); + ProductionOrder order; + switch (productionOrderRepository.findById(orderId)) { + case Result.Failure(var err) -> { + return Result.failure(new ProductionOrderError.RepositoryFailure(err.message())); + } + case Result.Success(var opt) -> { + if (opt.isEmpty()) { + return Result.failure(new ProductionOrderError.ProductionOrderNotFound(orderId)); + } + order = opt.get(); + } + } + + // Batch must be COMPLETED (defense in depth – domain checks status transition) + var batchId = order.batchId(); + if (batchId == null) { + return Result.failure(new ProductionOrderError.ValidationFailure("Production order has no batch assigned")); + } + + Batch batch; + switch (batchRepository.findById(batchId)) { + case Result.Failure(var err) -> { + return Result.failure(new ProductionOrderError.RepositoryFailure(err.message())); + } + case Result.Success(var opt) -> { + if (opt.isEmpty()) { + return Result.failure(new ProductionOrderError.ValidationFailure("Batch '" + batchId.value() + "' not found")); + } + batch = opt.get(); + } + } + + if (batch.status() != BatchStatus.COMPLETED) { + return Result.failure(new ProductionOrderError.BatchNotCompleted(batchId)); + } + + switch (order.complete()) { + case Result.Failure(var err) -> { return Result.failure(err); } + case Result.Success(var ignored) -> { } + } + + return unitOfWork.executeAtomically(() -> { + switch (productionOrderRepository.save(order)) { + case Result.Failure(var err) -> { + return Result.failure(new ProductionOrderError.RepositoryFailure(err.message())); + } + case Result.Success(var ignored) -> { } + } + return Result.success(order); + }); + } +} diff --git a/backend/src/main/java/de/effigenix/application/production/command/CancelProductionOrderCommand.java b/backend/src/main/java/de/effigenix/application/production/command/CancelProductionOrderCommand.java new file mode 100644 index 0000000..127bfe3 --- /dev/null +++ b/backend/src/main/java/de/effigenix/application/production/command/CancelProductionOrderCommand.java @@ -0,0 +1,4 @@ +package de.effigenix.application.production.command; + +public record CancelProductionOrderCommand(String productionOrderId, String reason) { +} diff --git a/backend/src/main/java/de/effigenix/application/production/command/CompleteProductionOrderCommand.java b/backend/src/main/java/de/effigenix/application/production/command/CompleteProductionOrderCommand.java new file mode 100644 index 0000000..7adf96c --- /dev/null +++ b/backend/src/main/java/de/effigenix/application/production/command/CompleteProductionOrderCommand.java @@ -0,0 +1,4 @@ +package de.effigenix.application.production.command; + +public record CompleteProductionOrderCommand(String productionOrderId) { +} diff --git a/backend/src/main/java/de/effigenix/domain/production/ProductionOrder.java b/backend/src/main/java/de/effigenix/domain/production/ProductionOrder.java index 54c8853..bca54ac 100644 --- a/backend/src/main/java/de/effigenix/domain/production/ProductionOrder.java +++ b/backend/src/main/java/de/effigenix/domain/production/ProductionOrder.java @@ -22,6 +22,8 @@ import java.time.ZoneOffset; * 7. Only RELEASED → IN_PROGRESS transition allowed via startProduction(BatchId) * 8. BatchId is set exactly once (null → non-null) during startProduction() * 9. BatchId must not already be assigned (BatchAlreadyAssigned) + * 10. Only IN_PROGRESS → COMPLETED transition allowed via complete() (Batch must be COMPLETED – enforced by Use Case) + * 11. Only PLANNED or RELEASED → CANCELLED transition allowed via cancel() */ public class ProductionOrder { @@ -174,4 +176,22 @@ public class ProductionOrder { this.updatedAt = OffsetDateTime.now(ZoneOffset.UTC); return Result.success(null); } + + public Result complete() { + if (status != ProductionOrderStatus.IN_PROGRESS) { + return Result.failure(new ProductionOrderError.InvalidStatusTransition(status, ProductionOrderStatus.COMPLETED)); + } + this.status = ProductionOrderStatus.COMPLETED; + this.updatedAt = OffsetDateTime.now(ZoneOffset.UTC); + return Result.success(null); + } + + public Result cancel() { + if (status != ProductionOrderStatus.PLANNED && status != ProductionOrderStatus.RELEASED) { + return Result.failure(new ProductionOrderError.InvalidStatusTransition(status, ProductionOrderStatus.CANCELLED)); + } + this.status = ProductionOrderStatus.CANCELLED; + this.updatedAt = OffsetDateTime.now(ZoneOffset.UTC); + return Result.success(null); + } } diff --git a/backend/src/main/java/de/effigenix/domain/production/ProductionOrderError.java b/backend/src/main/java/de/effigenix/domain/production/ProductionOrderError.java index 8c375f1..30a429b 100644 --- a/backend/src/main/java/de/effigenix/domain/production/ProductionOrderError.java +++ b/backend/src/main/java/de/effigenix/domain/production/ProductionOrderError.java @@ -45,6 +45,11 @@ public sealed interface ProductionOrderError { @Override public String message() { return "Production order already has batch '" + batchId.value() + "' assigned"; } } + record BatchNotCompleted(BatchId batchId) implements ProductionOrderError { + @Override public String code() { return "PRODUCTION_ORDER_BATCH_NOT_COMPLETED"; } + @Override public String message() { return "Batch '" + batchId.value() + "' is not in COMPLETED status"; } + } + record ValidationFailure(String message) implements ProductionOrderError { @Override public String code() { return "PRODUCTION_ORDER_VALIDATION_ERROR"; } } diff --git a/backend/src/main/java/de/effigenix/infrastructure/config/ProductionUseCaseConfiguration.java b/backend/src/main/java/de/effigenix/infrastructure/config/ProductionUseCaseConfiguration.java index 7efec41..f34255b 100644 --- a/backend/src/main/java/de/effigenix/infrastructure/config/ProductionUseCaseConfiguration.java +++ b/backend/src/main/java/de/effigenix/infrastructure/config/ProductionUseCaseConfiguration.java @@ -4,6 +4,8 @@ import de.effigenix.application.production.ActivateRecipe; import de.effigenix.application.production.ArchiveRecipe; import de.effigenix.application.production.AddProductionStep; import de.effigenix.application.production.AddRecipeIngredient; +import de.effigenix.application.production.CancelProductionOrder; +import de.effigenix.application.production.CompleteProductionOrder; import de.effigenix.application.production.CreateProductionOrder; import de.effigenix.application.production.ReleaseProductionOrder; import de.effigenix.application.production.StartProductionOrder; @@ -160,4 +162,19 @@ public class ProductionUseCaseConfiguration { UnitOfWork unitOfWork) { return new StartProductionOrder(productionOrderRepository, batchRepository, authorizationPort, unitOfWork); } + + @Bean + public CompleteProductionOrder completeProductionOrder(ProductionOrderRepository productionOrderRepository, + BatchRepository batchRepository, + AuthorizationPort authorizationPort, + UnitOfWork unitOfWork) { + return new CompleteProductionOrder(productionOrderRepository, batchRepository, authorizationPort, unitOfWork); + } + + @Bean + public CancelProductionOrder cancelProductionOrder(ProductionOrderRepository productionOrderRepository, + AuthorizationPort authorizationPort, + UnitOfWork unitOfWork) { + return new CancelProductionOrder(productionOrderRepository, authorizationPort, unitOfWork); + } } diff --git a/backend/src/main/java/de/effigenix/infrastructure/production/web/controller/ProductionOrderController.java b/backend/src/main/java/de/effigenix/infrastructure/production/web/controller/ProductionOrderController.java index fdd1915..0fd29ae 100644 --- a/backend/src/main/java/de/effigenix/infrastructure/production/web/controller/ProductionOrderController.java +++ b/backend/src/main/java/de/effigenix/infrastructure/production/web/controller/ProductionOrderController.java @@ -1,12 +1,17 @@ package de.effigenix.infrastructure.production.web.controller; +import de.effigenix.application.production.CancelProductionOrder; +import de.effigenix.application.production.CompleteProductionOrder; import de.effigenix.application.production.CreateProductionOrder; import de.effigenix.application.production.ReleaseProductionOrder; import de.effigenix.application.production.StartProductionOrder; +import de.effigenix.application.production.command.CancelProductionOrderCommand; +import de.effigenix.application.production.command.CompleteProductionOrderCommand; import de.effigenix.application.production.command.CreateProductionOrderCommand; import de.effigenix.application.production.command.ReleaseProductionOrderCommand; import de.effigenix.application.production.command.StartProductionOrderCommand; import de.effigenix.domain.production.ProductionOrderError; +import de.effigenix.infrastructure.production.web.dto.CancelProductionOrderRequest; import de.effigenix.infrastructure.production.web.dto.CreateProductionOrderRequest; import de.effigenix.infrastructure.production.web.dto.ProductionOrderResponse; import de.effigenix.infrastructure.production.web.dto.StartProductionOrderRequest; @@ -33,13 +38,19 @@ public class ProductionOrderController { private final CreateProductionOrder createProductionOrder; private final ReleaseProductionOrder releaseProductionOrder; private final StartProductionOrder startProductionOrder; + private final CompleteProductionOrder completeProductionOrder; + private final CancelProductionOrder cancelProductionOrder; public ProductionOrderController(CreateProductionOrder createProductionOrder, ReleaseProductionOrder releaseProductionOrder, - StartProductionOrder startProductionOrder) { + StartProductionOrder startProductionOrder, + CompleteProductionOrder completeProductionOrder, + CancelProductionOrder cancelProductionOrder) { this.createProductionOrder = createProductionOrder; this.releaseProductionOrder = releaseProductionOrder; this.startProductionOrder = startProductionOrder; + this.completeProductionOrder = completeProductionOrder; + this.cancelProductionOrder = cancelProductionOrder; } @PostMapping @@ -106,6 +117,43 @@ public class ProductionOrderController { return ResponseEntity.ok(ProductionOrderResponse.from(result.unsafeGetValue())); } + @PostMapping("/{id}/complete") + @PreAuthorize("hasAuthority('PRODUCTION_ORDER_WRITE')") + public ResponseEntity completeProductionOrder( + @PathVariable String id, + Authentication authentication + ) { + logger.info("Completing production order: {} by actor: {}", id, authentication.getName()); + + var cmd = new CompleteProductionOrderCommand(id); + var result = completeProductionOrder.execute(cmd, ActorId.of(authentication.getName())); + + if (result.isFailure()) { + throw new ProductionOrderDomainErrorException(result.unsafeGetError()); + } + + return ResponseEntity.ok(ProductionOrderResponse.from(result.unsafeGetValue())); + } + + @PostMapping("/{id}/cancel") + @PreAuthorize("hasAuthority('PRODUCTION_ORDER_WRITE')") + public ResponseEntity cancelProductionOrder( + @PathVariable String id, + @Valid @RequestBody CancelProductionOrderRequest request, + Authentication authentication + ) { + logger.info("Cancelling production order: {} by actor: {}, reason: {}", id, authentication.getName(), request.reason()); + + var cmd = new CancelProductionOrderCommand(id, request.reason()); + var result = cancelProductionOrder.execute(cmd, ActorId.of(authentication.getName())); + + if (result.isFailure()) { + throw new ProductionOrderDomainErrorException(result.unsafeGetError()); + } + + return ResponseEntity.ok(ProductionOrderResponse.from(result.unsafeGetValue())); + } + public static class ProductionOrderDomainErrorException extends RuntimeException { private final ProductionOrderError error; diff --git a/backend/src/main/java/de/effigenix/infrastructure/production/web/dto/CancelProductionOrderRequest.java b/backend/src/main/java/de/effigenix/infrastructure/production/web/dto/CancelProductionOrderRequest.java new file mode 100644 index 0000000..5e8ddc6 --- /dev/null +++ b/backend/src/main/java/de/effigenix/infrastructure/production/web/dto/CancelProductionOrderRequest.java @@ -0,0 +1,6 @@ +package de.effigenix.infrastructure.production.web.dto; + +import jakarta.validation.constraints.NotBlank; + +public record CancelProductionOrderRequest(@NotBlank String reason) { +} diff --git a/backend/src/main/java/de/effigenix/infrastructure/production/web/exception/ProductionErrorHttpStatusMapper.java b/backend/src/main/java/de/effigenix/infrastructure/production/web/exception/ProductionErrorHttpStatusMapper.java index fdca5fc..31176ee 100644 --- a/backend/src/main/java/de/effigenix/infrastructure/production/web/exception/ProductionErrorHttpStatusMapper.java +++ b/backend/src/main/java/de/effigenix/infrastructure/production/web/exception/ProductionErrorHttpStatusMapper.java @@ -59,6 +59,7 @@ public final class ProductionErrorHttpStatusMapper { case ProductionOrderError.RecipeNotActive e -> 409; case ProductionOrderError.InvalidStatusTransition e -> 409; case ProductionOrderError.BatchAlreadyAssigned e -> 409; + case ProductionOrderError.BatchNotCompleted e -> 409; case ProductionOrderError.ValidationFailure e -> 400; case ProductionOrderError.Unauthorized e -> 403; case ProductionOrderError.RepositoryFailure e -> 500; diff --git a/backend/src/test/java/de/effigenix/application/production/CancelProductionOrderTest.java b/backend/src/test/java/de/effigenix/application/production/CancelProductionOrderTest.java new file mode 100644 index 0000000..29de4ee --- /dev/null +++ b/backend/src/test/java/de/effigenix/application/production/CancelProductionOrderTest.java @@ -0,0 +1,180 @@ +package de.effigenix.application.production; + +import de.effigenix.application.production.command.CancelProductionOrderCommand; +import de.effigenix.domain.production.*; +import de.effigenix.shared.common.Quantity; +import de.effigenix.shared.common.RepositoryError; +import de.effigenix.shared.common.Result; +import de.effigenix.shared.common.UnitOfMeasure; +import de.effigenix.shared.persistence.UnitOfWork; +import de.effigenix.shared.security.ActorId; +import de.effigenix.shared.security.AuthorizationPort; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.math.BigDecimal; +import java.time.LocalDate; +import java.time.OffsetDateTime; +import java.time.ZoneOffset; +import java.util.Optional; +import java.util.function.Supplier; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +@DisplayName("CancelProductionOrder Use Case") +class CancelProductionOrderTest { + + @Mock private ProductionOrderRepository productionOrderRepository; + @Mock private AuthorizationPort authPort; + @Mock private UnitOfWork unitOfWork; + + private CancelProductionOrder cancelProductionOrder; + private ActorId performedBy; + + private static final LocalDate PLANNED_DATE = LocalDate.now().plusDays(7); + + @BeforeEach + void setUp() { + cancelProductionOrder = new CancelProductionOrder(productionOrderRepository, authPort, unitOfWork); + performedBy = ActorId.of("admin-user"); + lenient().when(unitOfWork.executeAtomically(any())).thenAnswer(inv -> ((Supplier) inv.getArgument(0)).get()); + } + + private CancelProductionOrderCommand validCommand() { + return new CancelProductionOrderCommand("order-1", "Kunde hat storniert"); + } + + private ProductionOrder orderWithStatus(ProductionOrderStatus status) { + return ProductionOrder.reconstitute( + ProductionOrderId.of("order-1"), + RecipeId.of("recipe-1"), + status, + status == ProductionOrderStatus.IN_PROGRESS ? BatchId.of("batch-1") : null, + Quantity.of(new BigDecimal("100"), UnitOfMeasure.KILOGRAM).unsafeGetValue(), + PLANNED_DATE, + Priority.NORMAL, + null, + OffsetDateTime.now(ZoneOffset.UTC), + OffsetDateTime.now(ZoneOffset.UTC), + 1L + ); + } + + @Test + @DisplayName("should cancel PLANNED order") + void should_Cancel_PlannedOrder() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.success(Optional.of(orderWithStatus(ProductionOrderStatus.PLANNED)))); + when(productionOrderRepository.save(any())).thenReturn(Result.success(null)); + + var result = cancelProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.unsafeGetValue().status()).isEqualTo(ProductionOrderStatus.CANCELLED); + verify(productionOrderRepository).save(any(ProductionOrder.class)); + } + + @Test + @DisplayName("should cancel RELEASED order") + void should_Cancel_ReleasedOrder() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.success(Optional.of(orderWithStatus(ProductionOrderStatus.RELEASED)))); + when(productionOrderRepository.save(any())).thenReturn(Result.success(null)); + + var result = cancelProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.unsafeGetValue().status()).isEqualTo(ProductionOrderStatus.CANCELLED); + verify(productionOrderRepository).save(any(ProductionOrder.class)); + } + + @Test + @DisplayName("should fail when order is IN_PROGRESS") + void should_Fail_When_InProgress() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.success(Optional.of(orderWithStatus(ProductionOrderStatus.IN_PROGRESS)))); + + var result = cancelProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isFailure()).isTrue(); + assertThat(result.unsafeGetError()).isInstanceOf(ProductionOrderError.InvalidStatusTransition.class); + verify(productionOrderRepository, never()).save(any()); + } + + @Test + @DisplayName("should fail when order is COMPLETED") + void should_Fail_When_Completed() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.success(Optional.of(orderWithStatus(ProductionOrderStatus.COMPLETED)))); + + var result = cancelProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isFailure()).isTrue(); + assertThat(result.unsafeGetError()).isInstanceOf(ProductionOrderError.InvalidStatusTransition.class); + verify(productionOrderRepository, never()).save(any()); + } + + @Test + @DisplayName("should fail when order is already CANCELLED") + void should_Fail_When_AlreadyCancelled() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.success(Optional.of(orderWithStatus(ProductionOrderStatus.CANCELLED)))); + + var result = cancelProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isFailure()).isTrue(); + assertThat(result.unsafeGetError()).isInstanceOf(ProductionOrderError.InvalidStatusTransition.class); + verify(productionOrderRepository, never()).save(any()); + } + + @Test + @DisplayName("should fail when order not found") + void should_Fail_When_OrderNotFound() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.success(Optional.empty())); + + var result = cancelProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isFailure()).isTrue(); + assertThat(result.unsafeGetError()).isInstanceOf(ProductionOrderError.ProductionOrderNotFound.class); + verify(productionOrderRepository, never()).save(any()); + } + + @Test + @DisplayName("should fail when unauthorized") + void should_Fail_When_Unauthorized() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(false); + + var result = cancelProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isFailure()).isTrue(); + assertThat(result.unsafeGetError()).isInstanceOf(ProductionOrderError.Unauthorized.class); + verify(productionOrderRepository, never()).save(any()); + } + + @Test + @DisplayName("should fail when repository returns error") + void should_Fail_When_RepositoryError() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.failure(new RepositoryError.DatabaseError("connection lost"))); + + var result = cancelProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isFailure()).isTrue(); + assertThat(result.unsafeGetError()).isInstanceOf(ProductionOrderError.RepositoryFailure.class); + } +} diff --git a/backend/src/test/java/de/effigenix/application/production/CompleteProductionOrderTest.java b/backend/src/test/java/de/effigenix/application/production/CompleteProductionOrderTest.java new file mode 100644 index 0000000..f0fb5ca --- /dev/null +++ b/backend/src/test/java/de/effigenix/application/production/CompleteProductionOrderTest.java @@ -0,0 +1,255 @@ +package de.effigenix.application.production; + +import de.effigenix.application.production.command.CompleteProductionOrderCommand; +import de.effigenix.domain.production.*; +import de.effigenix.shared.common.Quantity; +import de.effigenix.shared.common.RepositoryError; +import de.effigenix.shared.common.Result; +import de.effigenix.shared.common.UnitOfMeasure; +import de.effigenix.shared.persistence.UnitOfWork; +import de.effigenix.shared.security.ActorId; +import de.effigenix.shared.security.AuthorizationPort; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.math.BigDecimal; +import java.time.LocalDate; +import java.time.OffsetDateTime; +import java.time.ZoneOffset; +import java.util.List; +import java.util.Optional; +import java.util.function.Supplier; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +@DisplayName("CompleteProductionOrder Use Case") +class CompleteProductionOrderTest { + + @Mock private ProductionOrderRepository productionOrderRepository; + @Mock private BatchRepository batchRepository; + @Mock private AuthorizationPort authPort; + @Mock private UnitOfWork unitOfWork; + + private CompleteProductionOrder completeProductionOrder; + private ActorId performedBy; + + private static final LocalDate PLANNED_DATE = LocalDate.now().plusDays(7); + + @BeforeEach + void setUp() { + completeProductionOrder = new CompleteProductionOrder(productionOrderRepository, batchRepository, authPort, unitOfWork); + performedBy = ActorId.of("admin-user"); + lenient().when(unitOfWork.executeAtomically(any())).thenAnswer(inv -> ((Supplier) inv.getArgument(0)).get()); + } + + private CompleteProductionOrderCommand validCommand() { + return new CompleteProductionOrderCommand("order-1"); + } + + private ProductionOrder inProgressOrder() { + return ProductionOrder.reconstitute( + ProductionOrderId.of("order-1"), + RecipeId.of("recipe-1"), + ProductionOrderStatus.IN_PROGRESS, + BatchId.of("batch-1"), + Quantity.of(new BigDecimal("100"), UnitOfMeasure.KILOGRAM).unsafeGetValue(), + PLANNED_DATE, + Priority.NORMAL, + null, + OffsetDateTime.now(ZoneOffset.UTC), + OffsetDateTime.now(ZoneOffset.UTC), + 1L + ); + } + + private ProductionOrder plannedOrder() { + return ProductionOrder.reconstitute( + ProductionOrderId.of("order-1"), + RecipeId.of("recipe-1"), + ProductionOrderStatus.PLANNED, + null, + Quantity.of(new BigDecimal("100"), UnitOfMeasure.KILOGRAM).unsafeGetValue(), + PLANNED_DATE, + Priority.NORMAL, + null, + OffsetDateTime.now(ZoneOffset.UTC), + OffsetDateTime.now(ZoneOffset.UTC), + 1L + ); + } + + private Batch completedBatch() { + return Batch.reconstitute( + BatchId.of("batch-1"), + new BatchNumber("P-2026-02-25-001"), + RecipeId.of("recipe-1"), + BatchStatus.COMPLETED, + Quantity.of(new BigDecimal("100"), UnitOfMeasure.KILOGRAM).unsafeGetValue(), + Quantity.of(new BigDecimal("95"), UnitOfMeasure.KILOGRAM).unsafeGetValue(), + Quantity.of(new BigDecimal("5"), UnitOfMeasure.KILOGRAM).unsafeGetValue(), + "done", + PLANNED_DATE, PLANNED_DATE.plusDays(14), + OffsetDateTime.now(ZoneOffset.UTC), + OffsetDateTime.now(ZoneOffset.UTC), + OffsetDateTime.now(ZoneOffset.UTC), + null, null, + 1L, + List.of() + ); + } + + private Batch inProductionBatch() { + return Batch.reconstitute( + BatchId.of("batch-1"), + new BatchNumber("P-2026-02-25-001"), + RecipeId.of("recipe-1"), + BatchStatus.IN_PRODUCTION, + Quantity.of(new BigDecimal("100"), UnitOfMeasure.KILOGRAM).unsafeGetValue(), + null, null, null, + PLANNED_DATE, PLANNED_DATE.plusDays(14), + OffsetDateTime.now(ZoneOffset.UTC), + OffsetDateTime.now(ZoneOffset.UTC), + null, null, null, + 1L, + List.of() + ); + } + + @Test + @DisplayName("should complete order when IN_PROGRESS and batch is COMPLETED") + void should_Complete_When_InProgressAndBatchCompleted() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.success(Optional.of(inProgressOrder()))); + when(batchRepository.findById(BatchId.of("batch-1"))) + .thenReturn(Result.success(Optional.of(completedBatch()))); + when(productionOrderRepository.save(any())).thenReturn(Result.success(null)); + + var result = completeProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isSuccess()).isTrue(); + assertThat(result.unsafeGetValue().status()).isEqualTo(ProductionOrderStatus.COMPLETED); + verify(productionOrderRepository).save(any(ProductionOrder.class)); + } + + @Test + @DisplayName("should fail when batch is not COMPLETED") + void should_Fail_When_BatchNotCompleted() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.success(Optional.of(inProgressOrder()))); + when(batchRepository.findById(BatchId.of("batch-1"))) + .thenReturn(Result.success(Optional.of(inProductionBatch()))); + + var result = completeProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isFailure()).isTrue(); + assertThat(result.unsafeGetError()).isInstanceOf(ProductionOrderError.BatchNotCompleted.class); + verify(productionOrderRepository, never()).save(any()); + } + + @Test + @DisplayName("should fail when order is PLANNED (no batch assigned)") + void should_Fail_When_OrderPlanned() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.success(Optional.of(plannedOrder()))); + + var result = completeProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isFailure()).isTrue(); + assertThat(result.unsafeGetError()).isInstanceOf(ProductionOrderError.ValidationFailure.class); + verify(productionOrderRepository, never()).save(any()); + } + + @Test + @DisplayName("should fail when order is already COMPLETED") + void should_Fail_When_AlreadyCompleted() { + var completedOrder = ProductionOrder.reconstitute( + ProductionOrderId.of("order-1"), RecipeId.of("recipe-1"), + ProductionOrderStatus.COMPLETED, BatchId.of("batch-1"), + Quantity.of(new BigDecimal("100"), UnitOfMeasure.KILOGRAM).unsafeGetValue(), + PLANNED_DATE, Priority.NORMAL, null, + OffsetDateTime.now(ZoneOffset.UTC), OffsetDateTime.now(ZoneOffset.UTC), 1L); + + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.success(Optional.of(completedOrder))); + when(batchRepository.findById(BatchId.of("batch-1"))) + .thenReturn(Result.success(Optional.of(completedBatch()))); + + var result = completeProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isFailure()).isTrue(); + assertThat(result.unsafeGetError()).isInstanceOf(ProductionOrderError.InvalidStatusTransition.class); + verify(productionOrderRepository, never()).save(any()); + } + + @Test + @DisplayName("should fail when order is CANCELLED") + void should_Fail_When_OrderCancelled() { + var cancelledOrder = ProductionOrder.reconstitute( + ProductionOrderId.of("order-1"), RecipeId.of("recipe-1"), + ProductionOrderStatus.CANCELLED, null, + Quantity.of(new BigDecimal("100"), UnitOfMeasure.KILOGRAM).unsafeGetValue(), + PLANNED_DATE, Priority.NORMAL, null, + OffsetDateTime.now(ZoneOffset.UTC), OffsetDateTime.now(ZoneOffset.UTC), 1L); + + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.success(Optional.of(cancelledOrder))); + + var result = completeProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isFailure()).isTrue(); + // CANCELLED order has no batchId → ValidationFailure + assertThat(result.unsafeGetError()).isInstanceOf(ProductionOrderError.ValidationFailure.class); + verify(productionOrderRepository, never()).save(any()); + } + + @Test + @DisplayName("should fail when order not found") + void should_Fail_When_OrderNotFound() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.success(Optional.empty())); + + var result = completeProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isFailure()).isTrue(); + assertThat(result.unsafeGetError()).isInstanceOf(ProductionOrderError.ProductionOrderNotFound.class); + verify(productionOrderRepository, never()).save(any()); + } + + @Test + @DisplayName("should fail when unauthorized") + void should_Fail_When_Unauthorized() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(false); + + var result = completeProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isFailure()).isTrue(); + assertThat(result.unsafeGetError()).isInstanceOf(ProductionOrderError.Unauthorized.class); + verify(productionOrderRepository, never()).save(any()); + } + + @Test + @DisplayName("should fail when order repository returns error") + void should_Fail_When_RepositoryError() { + when(authPort.can(performedBy, ProductionAction.PRODUCTION_ORDER_WRITE)).thenReturn(true); + when(productionOrderRepository.findById(ProductionOrderId.of("order-1"))) + .thenReturn(Result.failure(new RepositoryError.DatabaseError("connection lost"))); + + var result = completeProductionOrder.execute(validCommand(), performedBy); + + assertThat(result.isFailure()).isTrue(); + assertThat(result.unsafeGetError()).isInstanceOf(ProductionOrderError.RepositoryFailure.class); + } +} diff --git a/backend/src/test/java/de/effigenix/domain/production/ProductionOrderTest.java b/backend/src/test/java/de/effigenix/domain/production/ProductionOrderTest.java index 9863cd2..0095071 100644 --- a/backend/src/test/java/de/effigenix/domain/production/ProductionOrderTest.java +++ b/backend/src/test/java/de/effigenix/domain/production/ProductionOrderTest.java @@ -503,6 +503,180 @@ class ProductionOrderTest { } } + @Nested + @DisplayName("complete()") + class Complete { + + private ProductionOrder orderWithStatus(ProductionOrderStatus status) { + return ProductionOrder.reconstitute( + ProductionOrderId.of("order-1"), + RecipeId.of("recipe-123"), + status, + status == ProductionOrderStatus.IN_PROGRESS || status == ProductionOrderStatus.COMPLETED + ? BatchId.of("batch-1") : null, + Quantity.of(new BigDecimal("100"), UnitOfMeasure.KILOGRAM).unsafeGetValue(), + FUTURE_DATE, + Priority.NORMAL, + null, + OffsetDateTime.now(ZoneOffset.UTC).minusHours(1), + OffsetDateTime.now(ZoneOffset.UTC).minusHours(1), + 1L + ); + } + + @Test + @DisplayName("should complete IN_PROGRESS order") + void should_Complete_When_InProgress() { + var order = orderWithStatus(ProductionOrderStatus.IN_PROGRESS); + var beforeUpdate = order.updatedAt(); + + var result = order.complete(); + + assertThat(result.isSuccess()).isTrue(); + assertThat(order.status()).isEqualTo(ProductionOrderStatus.COMPLETED); + assertThat(order.updatedAt()).isAfter(beforeUpdate); + } + + @Test + @DisplayName("should fail when completing PLANNED order") + void should_Fail_When_Planned() { + var order = orderWithStatus(ProductionOrderStatus.PLANNED); + + var result = order.complete(); + + assertThat(result.isFailure()).isTrue(); + var err = (ProductionOrderError.InvalidStatusTransition) result.unsafeGetError(); + assertThat(err.current()).isEqualTo(ProductionOrderStatus.PLANNED); + assertThat(err.target()).isEqualTo(ProductionOrderStatus.COMPLETED); + } + + @Test + @DisplayName("should fail when completing RELEASED order") + void should_Fail_When_Released() { + var order = orderWithStatus(ProductionOrderStatus.RELEASED); + + var result = order.complete(); + + assertThat(result.isFailure()).isTrue(); + var err = (ProductionOrderError.InvalidStatusTransition) result.unsafeGetError(); + assertThat(err.current()).isEqualTo(ProductionOrderStatus.RELEASED); + assertThat(err.target()).isEqualTo(ProductionOrderStatus.COMPLETED); + } + + @Test + @DisplayName("should fail when completing already COMPLETED order") + void should_Fail_When_AlreadyCompleted() { + var order = orderWithStatus(ProductionOrderStatus.COMPLETED); + + var result = order.complete(); + + assertThat(result.isFailure()).isTrue(); + var err = (ProductionOrderError.InvalidStatusTransition) result.unsafeGetError(); + assertThat(err.current()).isEqualTo(ProductionOrderStatus.COMPLETED); + assertThat(err.target()).isEqualTo(ProductionOrderStatus.COMPLETED); + } + + @Test + @DisplayName("should fail when completing CANCELLED order") + void should_Fail_When_Cancelled() { + var order = orderWithStatus(ProductionOrderStatus.CANCELLED); + + var result = order.complete(); + + assertThat(result.isFailure()).isTrue(); + var err = (ProductionOrderError.InvalidStatusTransition) result.unsafeGetError(); + assertThat(err.current()).isEqualTo(ProductionOrderStatus.CANCELLED); + assertThat(err.target()).isEqualTo(ProductionOrderStatus.COMPLETED); + } + } + + @Nested + @DisplayName("cancel()") + class Cancel { + + private ProductionOrder orderWithStatus(ProductionOrderStatus status) { + return ProductionOrder.reconstitute( + ProductionOrderId.of("order-1"), + RecipeId.of("recipe-123"), + status, + status == ProductionOrderStatus.IN_PROGRESS || status == ProductionOrderStatus.COMPLETED + ? BatchId.of("batch-1") : null, + Quantity.of(new BigDecimal("100"), UnitOfMeasure.KILOGRAM).unsafeGetValue(), + FUTURE_DATE, + Priority.NORMAL, + null, + OffsetDateTime.now(ZoneOffset.UTC).minusHours(1), + OffsetDateTime.now(ZoneOffset.UTC).minusHours(1), + 1L + ); + } + + @Test + @DisplayName("should cancel PLANNED order") + void should_Cancel_When_Planned() { + var order = orderWithStatus(ProductionOrderStatus.PLANNED); + var beforeUpdate = order.updatedAt(); + + var result = order.cancel(); + + assertThat(result.isSuccess()).isTrue(); + assertThat(order.status()).isEqualTo(ProductionOrderStatus.CANCELLED); + assertThat(order.updatedAt()).isAfter(beforeUpdate); + } + + @Test + @DisplayName("should cancel RELEASED order") + void should_Cancel_When_Released() { + var order = orderWithStatus(ProductionOrderStatus.RELEASED); + var beforeUpdate = order.updatedAt(); + + var result = order.cancel(); + + assertThat(result.isSuccess()).isTrue(); + assertThat(order.status()).isEqualTo(ProductionOrderStatus.CANCELLED); + assertThat(order.updatedAt()).isAfter(beforeUpdate); + } + + @Test + @DisplayName("should fail when cancelling IN_PROGRESS order") + void should_Fail_When_InProgress() { + var order = orderWithStatus(ProductionOrderStatus.IN_PROGRESS); + + var result = order.cancel(); + + assertThat(result.isFailure()).isTrue(); + var err = (ProductionOrderError.InvalidStatusTransition) result.unsafeGetError(); + assertThat(err.current()).isEqualTo(ProductionOrderStatus.IN_PROGRESS); + assertThat(err.target()).isEqualTo(ProductionOrderStatus.CANCELLED); + } + + @Test + @DisplayName("should fail when cancelling COMPLETED order") + void should_Fail_When_Completed() { + var order = orderWithStatus(ProductionOrderStatus.COMPLETED); + + var result = order.cancel(); + + assertThat(result.isFailure()).isTrue(); + var err = (ProductionOrderError.InvalidStatusTransition) result.unsafeGetError(); + assertThat(err.current()).isEqualTo(ProductionOrderStatus.COMPLETED); + assertThat(err.target()).isEqualTo(ProductionOrderStatus.CANCELLED); + } + + @Test + @DisplayName("should fail when cancelling already CANCELLED order") + void should_Fail_When_AlreadyCancelled() { + var order = orderWithStatus(ProductionOrderStatus.CANCELLED); + + var result = order.cancel(); + + assertThat(result.isFailure()).isTrue(); + var err = (ProductionOrderError.InvalidStatusTransition) result.unsafeGetError(); + assertThat(err.current()).isEqualTo(ProductionOrderStatus.CANCELLED); + assertThat(err.target()).isEqualTo(ProductionOrderStatus.CANCELLED); + } + } + @Nested @DisplayName("reconstitute()") class Reconstitute { diff --git a/backend/src/test/java/de/effigenix/infrastructure/production/web/ProductionOrderControllerIntegrationTest.java b/backend/src/test/java/de/effigenix/infrastructure/production/web/ProductionOrderControllerIntegrationTest.java index 9f91cb6..92099f4 100644 --- a/backend/src/test/java/de/effigenix/infrastructure/production/web/ProductionOrderControllerIntegrationTest.java +++ b/backend/src/test/java/de/effigenix/infrastructure/production/web/ProductionOrderControllerIntegrationTest.java @@ -2,8 +2,10 @@ package de.effigenix.infrastructure.production.web; import de.effigenix.domain.usermanagement.RoleName; import de.effigenix.infrastructure.AbstractIntegrationTest; +import de.effigenix.infrastructure.production.web.dto.CompleteBatchRequest; import de.effigenix.infrastructure.production.web.dto.CreateProductionOrderRequest; import de.effigenix.infrastructure.production.web.dto.PlanBatchRequest; +import de.effigenix.infrastructure.production.web.dto.RecordConsumptionRequest; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; @@ -34,7 +36,7 @@ class ProductionOrderControllerIntegrationTest extends AbstractIntegrationTest { String viewerId = createUser("po.viewer", "po.viewer@test.com", Set.of(viewerRoleId), "BRANCH-01"); adminToken = generateToken(adminId, "po.admin", - "PRODUCTION_ORDER_WRITE,PRODUCTION_ORDER_READ,RECIPE_WRITE,RECIPE_READ,BATCH_WRITE,BATCH_READ"); + "PRODUCTION_ORDER_WRITE,PRODUCTION_ORDER_READ,RECIPE_WRITE,RECIPE_READ,BATCH_WRITE,BATCH_READ,BATCH_COMPLETE,BATCH_CANCEL"); viewerToken = generateToken(viewerId, "po.viewer", "USER_READ"); } @@ -570,6 +572,261 @@ class ProductionOrderControllerIntegrationTest extends AbstractIntegrationTest { } } + @Nested + @DisplayName("POST /api/production/production-orders/{id}/complete – Produktionsauftrag abschließen") + class CompleteProductionOrderEndpoint { + + @Test + @DisplayName("IN_PROGRESS Order mit COMPLETED Batch abschließen → 200") + void completeOrder_withCompletedBatch_returns200() throws Exception { + String[] orderAndBatch = createInProgressOrderWithCompletedBatch(); + String orderId = orderAndBatch[0]; + + mockMvc.perform(post("/api/production/production-orders/{id}/complete", orderId) + .header("Authorization", "Bearer " + adminToken)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.id").value(orderId)) + .andExpect(jsonPath("$.status").value("COMPLETED")); + } + + @Test + @DisplayName("IN_PROGRESS Order mit nicht-COMPLETED Batch → 409") + void completeOrder_batchNotCompleted_returns409() throws Exception { + String orderId = createInProgressOrder(); + + mockMvc.perform(post("/api/production/production-orders/{id}/complete", orderId) + .header("Authorization", "Bearer " + adminToken)) + .andExpect(status().isConflict()) + .andExpect(jsonPath("$.code").value("PRODUCTION_ORDER_BATCH_NOT_COMPLETED")); + } + + @Test + @DisplayName("PLANNED Order abschließen → 400 (kein Batch zugewiesen)") + void completeOrder_plannedOrder_returns400() throws Exception { + String orderId = createPlannedOrder(); + + mockMvc.perform(post("/api/production/production-orders/{id}/complete", orderId) + .header("Authorization", "Bearer " + adminToken)) + .andExpect(status().isBadRequest()) + .andExpect(jsonPath("$.code").value("PRODUCTION_ORDER_VALIDATION_ERROR")); + } + + @Test + @DisplayName("RELEASED Order abschließen → 400 (kein Batch zugewiesen)") + void completeOrder_releasedOrder_returns400() throws Exception { + String orderId = createReleasedOrder(); + + mockMvc.perform(post("/api/production/production-orders/{id}/complete", orderId) + .header("Authorization", "Bearer " + adminToken)) + .andExpect(status().isBadRequest()) + .andExpect(jsonPath("$.code").value("PRODUCTION_ORDER_VALIDATION_ERROR")); + } + + @Test + @DisplayName("Order nicht gefunden → 404") + void completeOrder_notFound_returns404() throws Exception { + mockMvc.perform(post("/api/production/production-orders/{id}/complete", "non-existent-id") + .header("Authorization", "Bearer " + adminToken)) + .andExpect(status().isNotFound()) + .andExpect(jsonPath("$.code").value("PRODUCTION_ORDER_NOT_FOUND")); + } + + @Test + @DisplayName("Bereits COMPLETED Order erneut abschließen → 409") + void completeOrder_alreadyCompleted_returns409() throws Exception { + String[] orderAndBatch = createInProgressOrderWithCompletedBatch(); + String orderId = orderAndBatch[0]; + + // First complete + mockMvc.perform(post("/api/production/production-orders/{id}/complete", orderId) + .header("Authorization", "Bearer " + adminToken)) + .andExpect(status().isOk()); + + // Second complete + mockMvc.perform(post("/api/production/production-orders/{id}/complete", orderId) + .header("Authorization", "Bearer " + adminToken)) + .andExpect(status().isConflict()) + .andExpect(jsonPath("$.code").value("PRODUCTION_ORDER_INVALID_STATUS_TRANSITION")); + } + + @Test + @DisplayName("Ohne PRODUCTION_ORDER_WRITE → 403") + void completeOrder_withViewerToken_returns403() throws Exception { + mockMvc.perform(post("/api/production/production-orders/{id}/complete", "any-id") + .header("Authorization", "Bearer " + viewerToken)) + .andExpect(status().isForbidden()); + } + + @Test + @DisplayName("Ohne Token → 401") + void completeOrder_withoutToken_returns401() throws Exception { + mockMvc.perform(post("/api/production/production-orders/{id}/complete", "any-id")) + .andExpect(status().isUnauthorized()); + } + } + + @Nested + @DisplayName("POST /api/production/production-orders/{id}/cancel – Produktionsauftrag stornieren") + class CancelProductionOrderEndpoint { + + @Test + @DisplayName("PLANNED Order stornieren → 200") + void cancelOrder_planned_returns200() throws Exception { + String orderId = createPlannedOrder(); + + String json = """ + {"reason": "Kunde hat storniert"} + """; + + mockMvc.perform(post("/api/production/production-orders/{id}/cancel", orderId) + .header("Authorization", "Bearer " + adminToken) + .contentType(MediaType.APPLICATION_JSON) + .content(json)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.id").value(orderId)) + .andExpect(jsonPath("$.status").value("CANCELLED")); + } + + @Test + @DisplayName("RELEASED Order stornieren → 200") + void cancelOrder_released_returns200() throws Exception { + String orderId = createReleasedOrder(); + + String json = """ + {"reason": "Material nicht verfügbar"} + """; + + mockMvc.perform(post("/api/production/production-orders/{id}/cancel", orderId) + .header("Authorization", "Bearer " + adminToken) + .contentType(MediaType.APPLICATION_JSON) + .content(json)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.id").value(orderId)) + .andExpect(jsonPath("$.status").value("CANCELLED")); + } + + @Test + @DisplayName("IN_PROGRESS Order stornieren → 409") + void cancelOrder_inProgress_returns409() throws Exception { + String orderId = createInProgressOrder(); + + String json = """ + {"reason": "Storno-Versuch"} + """; + + mockMvc.perform(post("/api/production/production-orders/{id}/cancel", orderId) + .header("Authorization", "Bearer " + adminToken) + .contentType(MediaType.APPLICATION_JSON) + .content(json)) + .andExpect(status().isConflict()) + .andExpect(jsonPath("$.code").value("PRODUCTION_ORDER_INVALID_STATUS_TRANSITION")); + } + + @Test + @DisplayName("COMPLETED Order stornieren → 409") + void cancelOrder_completed_returns409() throws Exception { + String[] orderAndBatch = createInProgressOrderWithCompletedBatch(); + String orderId = orderAndBatch[0]; + + // Complete it first + mockMvc.perform(post("/api/production/production-orders/{id}/complete", orderId) + .header("Authorization", "Bearer " + adminToken)) + .andExpect(status().isOk()); + + String json = """ + {"reason": "Storno-Versuch nach Abschluss"} + """; + + mockMvc.perform(post("/api/production/production-orders/{id}/cancel", orderId) + .header("Authorization", "Bearer " + adminToken) + .contentType(MediaType.APPLICATION_JSON) + .content(json)) + .andExpect(status().isConflict()) + .andExpect(jsonPath("$.code").value("PRODUCTION_ORDER_INVALID_STATUS_TRANSITION")); + } + + @Test + @DisplayName("Bereits CANCELLED Order erneut stornieren → 409") + void cancelOrder_alreadyCancelled_returns409() throws Exception { + String orderId = createPlannedOrder(); + + String json = """ + {"reason": "Erster Storno"} + """; + + // First cancel + mockMvc.perform(post("/api/production/production-orders/{id}/cancel", orderId) + .header("Authorization", "Bearer " + adminToken) + .contentType(MediaType.APPLICATION_JSON) + .content(json)) + .andExpect(status().isOk()); + + // Second cancel + mockMvc.perform(post("/api/production/production-orders/{id}/cancel", orderId) + .header("Authorization", "Bearer " + adminToken) + .contentType(MediaType.APPLICATION_JSON) + .content(json)) + .andExpect(status().isConflict()) + .andExpect(jsonPath("$.code").value("PRODUCTION_ORDER_INVALID_STATUS_TRANSITION")); + } + + @Test + @DisplayName("Ohne reason → 400 (Bean Validation)") + void cancelOrder_blankReason_returns400() throws Exception { + String json = """ + {"reason": ""} + """; + + mockMvc.perform(post("/api/production/production-orders/{id}/cancel", "any-id") + .header("Authorization", "Bearer " + adminToken) + .contentType(MediaType.APPLICATION_JSON) + .content(json)) + .andExpect(status().isBadRequest()); + } + + @Test + @DisplayName("Order nicht gefunden → 404") + void cancelOrder_notFound_returns404() throws Exception { + String json = """ + {"reason": "Test"} + """; + + mockMvc.perform(post("/api/production/production-orders/{id}/cancel", "non-existent-id") + .header("Authorization", "Bearer " + adminToken) + .contentType(MediaType.APPLICATION_JSON) + .content(json)) + .andExpect(status().isNotFound()) + .andExpect(jsonPath("$.code").value("PRODUCTION_ORDER_NOT_FOUND")); + } + + @Test + @DisplayName("Ohne PRODUCTION_ORDER_WRITE → 403") + void cancelOrder_withViewerToken_returns403() throws Exception { + String json = """ + {"reason": "Test"} + """; + + mockMvc.perform(post("/api/production/production-orders/{id}/cancel", "any-id") + .header("Authorization", "Bearer " + viewerToken) + .contentType(MediaType.APPLICATION_JSON) + .content(json)) + .andExpect(status().isForbidden()); + } + + @Test + @DisplayName("Ohne Token → 401") + void cancelOrder_withoutToken_returns401() throws Exception { + String json = """ + {"reason": "Test"} + """; + + mockMvc.perform(post("/api/production/production-orders/{id}/cancel", "any-id") + .contentType(MediaType.APPLICATION_JSON) + .content(json)) + .andExpect(status().isUnauthorized()); + } + } + // ==================== Hilfsmethoden ==================== private String createPlannedOrder() throws Exception { @@ -653,6 +910,64 @@ class ProductionOrderControllerIntegrationTest extends AbstractIntegrationTest { return orderAndRecipe; } + /** Creates an IN_PROGRESS order (with a started batch). Returns orderId. */ + private String createInProgressOrder() throws Exception { + String[] orderAndRecipe = createReleasedOrderWithRecipe(); + String orderId = orderAndRecipe[0]; + String recipeId = orderAndRecipe[1]; + String batchId = createPlannedBatch(recipeId); + + String json = """ + {"batchId": "%s"} + """.formatted(batchId); + + mockMvc.perform(post("/api/production/production-orders/{id}/start", orderId) + .header("Authorization", "Bearer " + adminToken) + .contentType(MediaType.APPLICATION_JSON) + .content(json)) + .andExpect(status().isOk()); + + return orderId; + } + + /** Creates an IN_PROGRESS order with a COMPLETED batch. Returns [orderId, batchId]. */ + private String[] createInProgressOrderWithCompletedBatch() throws Exception { + String[] orderAndRecipe = createReleasedOrderWithRecipe(); + String orderId = orderAndRecipe[0]; + String recipeId = orderAndRecipe[1]; + String batchId = createPlannedBatch(recipeId); + + String startJson = """ + {"batchId": "%s"} + """.formatted(batchId); + + mockMvc.perform(post("/api/production/production-orders/{id}/start", orderId) + .header("Authorization", "Bearer " + adminToken) + .contentType(MediaType.APPLICATION_JSON) + .content(startJson)) + .andExpect(status().isOk()); + + // Record a consumption (required to complete batch) + String inputBatchId = createPlannedBatch(recipeId); + var consumptionRequest = new RecordConsumptionRequest( + inputBatchId, UUID.randomUUID().toString(), "10", "KILOGRAM"); + mockMvc.perform(post("/api/production/batches/{id}/consumptions", batchId) + .header("Authorization", "Bearer " + adminToken) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(consumptionRequest))) + .andExpect(status().isCreated()); + + // Complete the batch + var completeBatchRequest = new CompleteBatchRequest("95", "KILOGRAM", "5", "KILOGRAM", "Fertig"); + mockMvc.perform(post("/api/production/batches/{id}/complete", batchId) + .header("Authorization", "Bearer " + adminToken) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(completeBatchRequest))) + .andExpect(status().isOk()); + + return new String[]{orderId, batchId}; + } + private String createPlannedBatch() throws Exception { return createPlannedBatch(createActiveRecipe()); } diff --git a/loadtest/src/test/java/de/effigenix/loadtest/scenario/ProductionScenario.java b/loadtest/src/test/java/de/effigenix/loadtest/scenario/ProductionScenario.java index 992b4b6..21fbfec 100644 --- a/loadtest/src/test/java/de/effigenix/loadtest/scenario/ProductionScenario.java +++ b/loadtest/src/test/java/de/effigenix/loadtest/scenario/ProductionScenario.java @@ -127,6 +127,26 @@ public final class ProductionScenario { ); } + public static ChainBuilder completeProductionOrder() { + return exec( + http("Produktionsauftrag abschließen") + .post("/api/production/production-orders/#{productionOrderId}/complete") + .header("Authorization", "Bearer #{accessToken}") + .check(status().in(200, 400, 409, 500)) + ); + } + + public static ChainBuilder cancelProductionOrder() { + return exec( + http("Produktionsauftrag stornieren") + .post("/api/production/production-orders/#{productionOrderId}/cancel") + .header("Authorization", "Bearer #{accessToken}") + .header("Content-Type", "application/json") + .body(StringBody(JsonBodyBuilder.cancelProductionOrderBody())) + .check(status().in(200, 400, 409, 500)) + ); + } + // ---- Zusammengesetztes Szenario ---- /** @@ -191,6 +211,18 @@ public final class ProductionScenario { .exec(completeBatch()) ) .pause(1, 2) + // Produktionsauftrag abschließen (nutzt den zuvor gestarteten Order) + .doIf(session -> session.contains("productionOrderId")).then( + exec(completeProductionOrder()) + ) + .pause(1, 2) + // Neuen Auftrag anlegen und direkt stornieren + .exec(createProductionOrder()) + .pause(1, 2) + .doIf(session -> session.contains("productionOrderId")).then( + exec(cancelProductionOrder()) + ) + .pause(1, 2) // Nochmal Chargen-Liste prüfen .exec(listBatches()); } diff --git a/loadtest/src/test/java/de/effigenix/loadtest/simulation/FullWorkloadSimulation.java b/loadtest/src/test/java/de/effigenix/loadtest/simulation/FullWorkloadSimulation.java index 050e025..f4eff1e 100644 --- a/loadtest/src/test/java/de/effigenix/loadtest/simulation/FullWorkloadSimulation.java +++ b/loadtest/src/test/java/de/effigenix/loadtest/simulation/FullWorkloadSimulation.java @@ -117,6 +117,8 @@ public class FullWorkloadSimulation extends Simulation { details("Charge abschließen").responseTime().mean().lt(50), details("Produktionsauftrag anlegen").responseTime().mean().lt(50), details("Produktionsauftrag freigeben").responseTime().mean().lt(50), + details("Produktionsauftrag abschließen").responseTime().mean().lt(50), + details("Produktionsauftrag stornieren").responseTime().mean().lt(50), details("Bestandsbewegung erfassen").responseTime().mean().lt(50) ); } diff --git a/loadtest/src/test/java/de/effigenix/loadtest/util/JsonBodyBuilder.java b/loadtest/src/test/java/de/effigenix/loadtest/util/JsonBodyBuilder.java index 96602ff..030cac1 100644 --- a/loadtest/src/test/java/de/effigenix/loadtest/util/JsonBodyBuilder.java +++ b/loadtest/src/test/java/de/effigenix/loadtest/util/JsonBodyBuilder.java @@ -89,6 +89,11 @@ public final class JsonBodyBuilder { {"actualQuantity":"9.5","actualQuantityUnit":"KG","waste":"0.5","wasteUnit":"KG","remarks":"Lasttest"}"""; } + public static String cancelProductionOrderBody() { + return """ + {"reason":"Lasttest-Stornierung"}"""; + } + public static String createProductionOrderBody(String recipeId) { return """ {"recipeId":"%s","plannedQuantity":"20","plannedQuantityUnit":"KG","plannedDate":"%s","priority":"NORMAL"}"""