sebi/effigenix
1
0
Fork 0
mirror of https://github.com/s-frick/effigenix.git synced 2026-03-28 15:29:34 +01:00
Code Issues Releases Activity Actions

feat(production,inventory): Produktionsverbrauch automatisch im Inventory abziehen

Browse source 
RecordConsumption publiziert ConsumptionRecorded-Event, das über
ConsumptionRecordedInventoryListener den BookProductionConsumption
Use Case triggert – Bestandsabzug und PRODUCTION_CONSUMPTION
StockMovement werden automatisch verbucht.
This commit is contained in:
Sebastian Frick 2026-03-19 16:25:39 +01:00
parent aa7ac785bb
commit 004d96b291
12 changed files with 504 additions and 9 deletions
Download patch file Download diff file Expand all files Collapse all files

215
backend/src/test/java/de/effigenix/application/inventory/BookProductionConsumptionTest.java Normal file
View file

@ -0,0 +1,215 @@
package de.effigenix.application.inventory;
import de.effigenix.application.inventory.command.BookProductionConsumptionCommand;
import de.effigenix.domain.inventory.*;
import de.effigenix.domain.masterdata.article.ArticleId;
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 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.Instant;
import java.time.LocalDate;
import java.util.List;
import java.util.function.Supplier;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
@DisplayName("BookProductionConsumption Use Case")
class BookProductionConsumptionTest {
@Mock private StockRepository stockRepository;
@Mock private StockMovementRepository stockMovementRepository;
@Mock private UnitOfWork unitOfWork;
private BookProductionConsumption bookProductionConsumption;
@BeforeEach
void setUp() {
bookProductionConsumption = new BookProductionConsumption(stockRepository, stockMovementRepository, unitOfWork);
lenient().when(unitOfWork.executeAtomically(any())).thenAnswer(inv -> ((Supplier<?>) inv.getArgument(0)).get());
}
private Stock stockWithBatch(String articleId, String batchReferenceId, String quantity) {
var stockBatch = StockBatch.reconstitute(
StockBatchId.of("sb-1"),
new BatchReference(batchReferenceId, BatchType.PRODUCED),
Quantity.of(new BigDecimal(quantity), UnitOfMeasure.KILOGRAM).unsafeGetValue(),
LocalDate.of(2026, 6, 1),
StockBatchStatus.AVAILABLE,
Instant.now()
);
return Stock.reconstitute(
StockId.of("stock-1"),
ArticleId.of(articleId),
StorageLocationId.of("loc-prod"),
null, null,
List.of(stockBatch), List.of()
);
}
private Stock stockWithoutMatchingBatch(String articleId) {
var stockBatch = StockBatch.reconstitute(
StockBatchId.of("sb-other"),
new BatchReference("OTHER-BATCH", BatchType.PRODUCED),
Quantity.of(new BigDecimal("100"), UnitOfMeasure.KILOGRAM).unsafeGetValue(),
LocalDate.of(2026, 6, 1),
StockBatchStatus.AVAILABLE,
Instant.now()
);
return Stock.reconstitute(
StockId.of("stock-2"),
ArticleId.of(articleId),
StorageLocationId.of("loc-prod"),
null, null,
List.of(stockBatch), List.of()
);
}
private BookProductionConsumptionCommand validCommand() {
return new BookProductionConsumptionCommand(
"P-2026-03-19-001", "article-42", "5", "KILOGRAM");
}
@Test
@DisplayName("should deduct stock and record movement when batch found")
void should_DeductStock_When_BatchFound() {
var stock = stockWithBatch("article-42", "P-2026-03-19-001", "50");
when(stockRepository.findAllByArticleId(ArticleId.of("article-42")))
.thenReturn(Result.success(List.of(stock)));
when(stockRepository.save(any())).thenReturn(Result.success(null));
when(stockMovementRepository.save(any())).thenReturn(Result.success(null));
var result = bookProductionConsumption.execute(validCommand());
assertThat(result.isSuccess()).isTrue();
verify(stockRepository).save(stock);
verify(stockMovementRepository).save(any(StockMovement.class));
}
@Test
@DisplayName("should fail when no stock exists for article")
void should_Fail_When_NoStockForArticle() {
when(stockRepository.findAllByArticleId(ArticleId.of("article-42")))
.thenReturn(Result.success(List.of()));
var result = bookProductionConsumption.execute(validCommand());
assertThat(result.isFailure()).isTrue();
assertThat(result.unsafeGetError()).isInstanceOf(ProductionConsumptionError.StockNotFound.class);
verify(stockRepository, never()).save(any());
}
@Test
@DisplayName("should fail when batch not found in any stock")
void should_Fail_When_BatchNotInStock() {
var stock = stockWithoutMatchingBatch("article-42");
when(stockRepository.findAllByArticleId(ArticleId.of("article-42")))
.thenReturn(Result.success(List.of(stock)));
var result = bookProductionConsumption.execute(validCommand());
assertThat(result.isFailure()).isTrue();
assertThat(result.unsafeGetError()).isInstanceOf(ProductionConsumptionError.BatchNotFoundInStock.class);
verify(stockRepository, never()).save(any());
}
@Test
@DisplayName("should fail when removal quantity exceeds stock")
void should_Fail_When_QuantityExceedsStock() {
var stock = stockWithBatch("article-42", "P-2026-03-19-001", "3");
when(stockRepository.findAllByArticleId(ArticleId.of("article-42")))
.thenReturn(Result.success(List.of(stock)));
var result = bookProductionConsumption.execute(validCommand());
assertThat(result.isFailure()).isTrue();
assertThat(result.unsafeGetError()).isInstanceOf(ProductionConsumptionError.RemovalFailed.class);
verify(stockMovementRepository, never()).save(any());
}
@Test
@DisplayName("should fail with RepositoryFailure when stock lookup fails")
void should_Fail_When_StockLookupFails() {
when(stockRepository.findAllByArticleId(any()))
.thenReturn(Result.failure(new RepositoryError.DatabaseError("connection lost")));
var result = bookProductionConsumption.execute(validCommand());
assertThat(result.isFailure()).isTrue();
assertThat(result.unsafeGetError()).isInstanceOf(ProductionConsumptionError.RepositoryFailure.class);
}
@Test
@DisplayName("should fail when quantity amount is zero")
void should_Fail_When_ZeroQuantity() {
var stock = stockWithBatch("article-42", "P-2026-03-19-001", "50");
when(stockRepository.findAllByArticleId(ArticleId.of("article-42")))
.thenReturn(Result.success(List.of(stock)));
var cmd = new BookProductionConsumptionCommand(
"P-2026-03-19-001", "article-42", "0", "KILOGRAM");
var result = bookProductionConsumption.execute(cmd);
assertThat(result.isFailure()).isTrue();
assertThat(result.unsafeGetError()).isInstanceOf(ProductionConsumptionError.RemovalFailed.class);
}
@Test
@DisplayName("should fail when quantity unit is invalid")
void should_Fail_When_InvalidQuantityUnit() {
var stock = stockWithBatch("article-42", "P-2026-03-19-001", "50");
when(stockRepository.findAllByArticleId(ArticleId.of("article-42")))
.thenReturn(Result.success(List.of(stock)));
var cmd = new BookProductionConsumptionCommand(
"P-2026-03-19-001", "article-42", "5", "INVALID_UNIT");
var result = bookProductionConsumption.execute(cmd);
assertThat(result.isFailure()).isTrue();
assertThat(result.unsafeGetError()).isInstanceOf(ProductionConsumptionError.RemovalFailed.class);
}
@Test
@DisplayName("should fail with RepositoryFailure when movement save fails")
void should_Fail_When_MovementSaveFails() {
var stock = stockWithBatch("article-42", "P-2026-03-19-001", "50");
when(stockRepository.findAllByArticleId(ArticleId.of("article-42")))
.thenReturn(Result.success(List.of(stock)));
when(stockRepository.save(any())).thenReturn(Result.success(null));
when(stockMovementRepository.save(any()))
.thenReturn(Result.failure(new RepositoryError.DatabaseError("write error")));
var result = bookProductionConsumption.execute(validCommand());
assertThat(result.isFailure()).isTrue();
assertThat(result.unsafeGetError()).isInstanceOf(ProductionConsumptionError.RepositoryFailure.class);
}
@Test
@DisplayName("should fail with RepositoryFailure when stock save fails")
void should_Fail_When_StockSaveFails() {
var stock = stockWithBatch("article-42", "P-2026-03-19-001", "50");
when(stockRepository.findAllByArticleId(ArticleId.of("article-42")))
.thenReturn(Result.success(List.of(stock)));
when(stockRepository.save(any()))
.thenReturn(Result.failure(new RepositoryError.DatabaseError("write error")));
var result = bookProductionConsumption.execute(validCommand());
assertThat(result.isFailure()).isTrue();
assertThat(result.unsafeGetError()).isInstanceOf(ProductionConsumptionError.RepositoryFailure.class);
}
}

41
backend/src/test/java/de/effigenix/application/production/RecordConsumptionTest.java
View file

@ -2,10 +2,12 @@ package de.effigenix.application.production;
import de.effigenix.application.production.command.RecordConsumptionCommand;
import de.effigenix.domain.production.*;
import de.effigenix.domain.production.event.ConsumptionRecorded;
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.event.DomainEventPublisher;
import de.effigenix.shared.security.ActorId;
import de.effigenix.shared.security.AuthorizationPort;
import de.effigenix.shared.persistence.UnitOfWork;
@ -13,6 +15,7 @@ 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.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
@ -33,6 +36,7 @@ class RecordConsumptionTest {
@Mock private BatchRepository batchRepository;
@Mock private AuthorizationPort authPort;
@Mock private DomainEventPublisher domainEventPublisher;
@Mock private UnitOfWork unitOfWork;
private RecordConsumption recordConsumption;
@ -40,7 +44,7 @@ class RecordConsumptionTest {
@BeforeEach
void setUp() {
recordConsumption = new RecordConsumption(batchRepository, authPort, unitOfWork);
recordConsumption = new RecordConsumption(batchRepository, authPort, domainEventPublisher, unitOfWork);
performedBy = ActorId.of("admin-user");
lenient().when(unitOfWork.executeAtomically(any())).thenAnswer(inv -> ((Supplier<?>) inv.getArgument(0)).get());
}
@ -191,6 +195,41 @@ class RecordConsumptionTest {
assertThat(result.unsafeGetError()).isInstanceOf(BatchError.RepositoryFailure.class);
}
@Test
@DisplayName("should publish ConsumptionRecorded event after successful consumption")
void should_PublishEvent_When_ConsumptionSucceeds() {
var batchId = BatchId.of("batch-1");
var batch = inProductionBatch("batch-1");
when(authPort.can(performedBy, ProductionAction.BATCH_WRITE)).thenReturn(true);
when(batchRepository.findById(batchId)).thenReturn(Result.success(Optional.of(batch)));
when(batchRepository.save(any())).thenReturn(Result.success(null));
recordConsumption.execute(validCommand("batch-1"), performedBy);
var captor = ArgumentCaptor.forClass(ConsumptionRecorded.class);
verify(domainEventPublisher).publish(captor.capture());
var event = captor.getValue();
assertThat(event.batchId()).isEqualTo(batchId);
assertThat(event.inputBatchId()).isEqualTo("input-batch-1");
assertThat(event.articleId()).isEqualTo("article-1");
assertThat(event.quantity().amount()).isEqualByComparingTo(new BigDecimal("5.0"));
assertThat(event.quantity().uom()).isEqualTo(UnitOfMeasure.KILOGRAM);
assertThat(event.occurredAt()).isNotNull();
}
@Test
@DisplayName("should not publish event when consumption fails")
void should_NotPublishEvent_When_ConsumptionFails() {
var batchId = BatchId.of("batch-1");
var batch = plannedBatch("batch-1");
when(authPort.can(performedBy, ProductionAction.BATCH_WRITE)).thenReturn(true);
when(batchRepository.findById(batchId)).thenReturn(Result.success(Optional.of(batch)));
recordConsumption.execute(validCommand("batch-1"), performedBy);
verify(domainEventPublisher, never()).publish(any());
}
@Test
@DisplayName("should fail with RepositoryFailure on repository error during save")
void should_FailWithRepositoryFailure_When_SaveFails() {