Apakah kode mapping bisa dihasilkan dan dikompilasi?

Apakah field yang benar, dengan makna yang benar, berpindah ke target yang benar, dalam semua kondisi penting?

@Test
void mapsCustomerToResponse() {
    Customer customer = new Customer(new CustomerId("CUS-001"), "Ana");

    CustomerResponse response = mapper.toResponse(customer);

    assertThat(response.customerId()).isEqualTo("CUS-001");
    assertThat(response.fullName()).isEqualTo("Ana");
}

@Test
void createPaymentFixture_mapsToCommand() throws Exception {
    CreatePaymentRequest request = objectMapper.readValue(
        fixture("create-payment-valid-card.json"),
        CreatePaymentRequest.class
    );

    CreatePaymentCommand command = mapper.toCommand(request);

    assertThat(command.money().amount()).isEqualByComparingTo("100.00");
}

@Test
void paymentApprovedEvent_goldenJson() throws Exception {
    PaymentApprovedEvent event = mapper.toEvent(fixturePayment());

    assertThatJson(objectMapper.writeValueAsString(event)).isEqualTo(
        fixtureText("payment-approved-event-v1.json")
    );
}

JSON bytes -> Jackson -> Validation -> MapStruct -> Use Case

Customer customer = CustomerFixture.randomCustomer();

Customer customer = CustomerFixtures.activeCustomer(
    "CUS-001",
    "Ana Maria",
    "ana@example.com"
);

fixtures/customer/customer-active.json
fixtures/payment/create-payment-card-valid.json
fixtures/payment/create-payment-invalid-money-scale.json
fixtures/event/payment-approved-v1.json
fixtures/event/payment-approved-v1-extra-field.json
fixtures/xml/case-report-valid.xml
fixtures/xml/case-report-wrong-namespace.xml

@Test
void customerResponse_golden() throws Exception {
    CustomerResponse response = mapper.toResponse(fixtureCustomer());

    String actual = objectMapper.writeValueAsString(response);

    assertThatJson(actual).isEqualTo("""
    {
      "customerId": "CUS-001",
      "fullName": "Ana Maria",
      "status": "ACTIVE"
    }
    """);
}

assertThat(response).isNotNull();

assertThat(response.fullName()).isEqualTo(customer.fullName());

assertThat(response.customerId())
    .as("public customer id must use business id, not database id")
    .isEqualTo("CUS-001");

assertThat(response).doesNotHaveFieldOrProperty("passwordHash");

@Test
void patch_nullPhone_clearsPhone() throws Exception {
    CustomerEntity target = existingCustomerWithPhone("0812");
    CustomerPatchRequest patch = patchParser.parse("""
    { "phoneNumber": null }
    """);

    patchApplier.apply(patch, target);

    assertThat(target.getPhoneNumber()).isNull();
}

@Test
void merge_nullPhone_keepsExistingPhone() {
    CustomerEntity target = existingCustomerWithPhone("0812");
    CustomerMergeRequest request = new CustomerMergeRequest(null, null, null);

    mapper.merge(request, target);

    assertThat(target.getPhoneNumber()).isEqualTo("0812");
}

@Test
void allProviderStatusesAreMapped() {
    for (ProviderStatus status : ProviderStatus.values()) {
        assertThatCode(() -> mapper.toDomain(status))
            .as("status %s must be handled", status)
            .doesNotThrowAnyException();
    }
}

@ParameterizedTest
@CsvSource({
    "WAITING,PENDING",
    "PAID,COMPLETED",
    "FAIL,FAILED"
})
void mapsProviderStatus(ProviderStatus source, PaymentStatus expected) {
    assertThat(mapper.toDomain(source)).isEqualTo(expected);
}

@Test
void unknownProviderStatus_preservesRaw() {
    ProviderStatusValue status = mapper.toStatus("NEW_PROVIDER_CODE");

    assertThat(status.raw()).isEqualTo("NEW_PROVIDER_CODE");
    assertThat(status.known()).isEqualTo(ProviderStatusValue.Known.UNRECOGNIZED);
}

@Test
void mapsMoney_preservesDecimalStringMeaning() {
    MoneyDto dto = new MoneyDto("100.00", "IDR");

    Money money = mapper.toMoney(dto);

    assertThat(money.amount()).isEqualByComparingTo("100.00");
    assertThat(money.currency()).isEqualTo(Currency.getInstance("IDR"));
}

@Test
void money_rejectsTooManyFractionDigits() {
    MoneyDto dto = new MoneyDto("100.001", "IDR");

    assertThatThrownBy(() -> mapper.toMoney(dto))
        .isInstanceOf(IllegalArgumentException.class);
}

@Test
void mapsOccurredAtToInstant() {
    EventDto dto = new EventDto("2026-06-29T03:00:00Z");

    EventCommand command = mapper.toCommand(dto);

    assertThat(command.occurredAt()).isEqualTo(Instant.parse("2026-06-29T03:00:00Z"));
}

@Test
void rejectsTimestampWithoutOffsetWhenInstantRequired() {
    EventDto dto = new EventDto("2026-06-29T10:00:00");

    assertThatThrownBy(() -> mapper.toCommand(dto))
        .isInstanceOf(DateTimeParseException.class);
}

@Test
void mapsOrderLinesInSameOrder() {
    Order order = fixtureOrderWithLines("SKU-A", "SKU-B", "SKU-C");

    OrderResponse response = mapper.toResponse(order);

    assertThat(response.lines())
        .extracting(OrderLineResponse::sku)
        .containsExactly("SKU-A", "SKU-B", "SKU-C");
}

@Test
void mapsEmptyLinesToEmptyList() {
    Order order = fixtureOrderWithLines();

    OrderResponse response = mapper.toResponse(order);

    assertThat(response.lines()).isEmpty();
}

@Test
void accountResponse_doesNotExposeSensitiveFields() throws Exception {
    Account account = fixtureAccountWithSecrets();

    AccountResponse response = mapper.toResponse(account);
    String json = objectMapper.writeValueAsString(response);

    assertThat(json).doesNotContain("passwordHash");
    assertThat(json).doesNotContain("accessToken");
    assertThat(json).doesNotContain("internalRiskScore");
}

@Test
void orderResponse_doesNotIncludeCustomerOrdersBackReference() throws Exception {
    Order order = fixtureOrderWithBidirectionalCustomer();

    OrderResponse response = mapper.toResponse(order);
    String json = objectMapper.writeValueAsString(response);

    assertThat(json).doesNotContain("orders");
}

@Test
void providerPaymentFixture_mapsToCommand() throws Exception {
    ProviderPaymentDto dto = objectMapper.readValue(
        fixture("provider/payment-paid-v1.json"),
        ProviderPaymentDto.class
    );

    PaymentImportedCommand command = mapper.toCommand(dto);

    assertThat(command.paymentId().value()).isEqualTo("PAY-001");
    assertThat(command.money().amount()).isEqualByComparingTo("100.00");
    assertThat(command.status()).isEqualTo(PaymentStatus.COMPLETED);
}

provider/payment-paid-v1.json
provider/payment-paid-v1-extra-field.json
provider/payment-paid-v1-unknown-status.json
provider/payment-paid-v1-invalid-amount.json
provider/payment-paid-v1-missing-currency.json

case-report-valid.xml
case-report-wrong-namespace.xml
case-report-missing-required.xml
case-report-invalid-date.xml
case-report-xxe.xml

@Property
void branchCodeRoundTripPreservesLeadingZeros(@ForAll("branchCodes") String raw) {
    BranchCode code = mapper.toBranchCode(raw);

    assertThat(mapper.fromBranchCode(code)).isEqualTo(raw);
}

@Property
void moneyDtoRoundTripPreservesAmountAndCurrency(@ForAll MoneyDto dto) {
    assumeValidMoneyDto(dto);

    Money money = mapper.toMoney(dto);
    MoneyDto roundTrip = mapper.toDto(money);

    assertThat(roundTrip.amount()).isEqualTo(dto.amount());
    assertThat(roundTrip.currency()).isEqualTo(dto.currency());
}

Payment mapper mutation surface:
- paymentId: preserves external id, not internal id
- amount: decimal string to BigDecimal, no double
- currency: ISO code, uppercase required
- status: explicit provider code map
- occurredAt: ISO instant, offset required
- customerId: business id, not DB id
- rawProviderStatus: preserved when unknown

For MapStruct mapper affecting payment/event/security/patch, generated code inspected? yes/no

private final CustomerMapper mapper = Mappers.getMapper(CustomerMapper.class);

@SpringBootTest
class PaymentMapperSpringTest {
    @Autowired PaymentMapper mapper;

    @Test
    void mapsWithInjectedDependencies() {
        // test
    }
}

public record PaymentApprovedEvent(
    String eventId,
    String paymentId,
    String status,
    String schemaVersion,
    String newRequiredField
) {}

assertThatJson(actual).isEqualTo(expectedFixture);

@Test
void request_rejectsBlankCustomerId() {
    CreateCustomerRequest request = new CreateCustomerRequest("", "Ana");

    assertThat(validator.validate(request))
        .extracting(v -> v.getPropertyPath().toString())
        .contains("customerId");
}

@Test
void validRequest_mapsToCommand() {
    CreateCustomerRequest request = new CreateCustomerRequest("CUS-001", "Ana");

    CreateCustomerCommand command = mapper.toCommand(request);

    assertThat(command.customerId().value()).isEqualTo("CUS-001");
}

invalid JSON -> deserialization/validation error -> mapper not called

@Test
void mapperRejectsUnknownProviderStatus() {}

@Test
void mapperDoesNotExposePasswordHash() {}

@Test
void mapperDoesNotDefaultMissingAmountToZero() {}

@Test
void patchAbsentFieldDoesNotChangeTarget() {}

@Test
void invalidDateWithoutOffsetRejected() {}

@Test
void branchCodeLeadingZeroPreserved() {}

@Test
void mapsLargeBatchWithinBudget() {
    List<ProviderPaymentDto> dtos = fixturePayments(100_000);

    long start = System.nanoTime();
    List<PaymentImportedCommand> commands = dtos.stream()
        .map(mapper::toCommand)
        .toList();
    long elapsed = System.nanoTime() - start;

    assertThat(commands).hasSize(100_000);
    // Use benchmark framework for real performance gates.
}

@Test void testMapper() {}

@Test void mapsProviderPaidStatusToCompleted() {}
@Test void preservesLeadingZerosInAccountNumber() {}
@Test void patchNullPhoneClearsPhone() {}
@Test void mergeNullPhoneKeepsExistingPhone() {}
@Test void responseDoesNotExposeInternalRiskScore() {}
@Test void eventGoldenJsonRemainsBackwardCompatible() {}

- Compile with MapStruct strict policies.
- Run mapper unit tests.
- Run fixture/golden tests.
- Run validation tests.
- Run contract compatibility tests for public events/API.
- Run security/redaction tests.
- Run mutation testing for critical mapper if useful.

PaymentApprovedEvent toApprovedEvent(Payment payment);

1. maps required fields
2. amount serializes as decimal string
3. currency is ISO code
4. occurredAt is ISO instant
5. schemaVersion constant is v1
6. card token absent from JSON
7. internal risk score absent from JSON
8. golden JSON equals fixture
9. null optional note omitted/included per contract
10. event remains deserializable by v1 consumer fixture

@Test
void approvedEvent_doesNotExposeCardToken() throws Exception {
    Payment payment = fixturePaymentWithCardToken("tok_secret");

    PaymentApprovedEvent event = mapper.toApprovedEvent(payment);
    String json = objectMapper.writeValueAsString(event);

    assertThat(json).doesNotContain("tok_secret");
    assertThat(json).doesNotContain("cardToken");
}

ProviderTransferDto -> TransferImportedCommand

transfer_id: String
source_account: String
destination_account: String
amount: String
currency: String
status: String
created_at: String
metadata: Map<String, String>