TEST1 - Añadiendo Pruebas

<dependencies>
    <dependency>
        <groupId>com.iconsolutions.ipf.core.test</groupId>
        <artifactId>ipf-test-fw-whitebox</artifactId>
         <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.iconsolutions.ipf.tutorial</groupId>
        <artifactId>ipf-tutorial-app</artifactId>
        <version>${project.version}</version>
        <scope>test</scope>
    </dependency>
</dependencies>

@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest. WebEnvironment. DEFINED_PORT)
@Import({AllTestConfig.class})
public class FeatureTestRunner extends IPFFeatureTestRunner {
}

public class FeatureTestRunner extends IPFFeatureTestRunner implements KafkaIntegrationTestSupport, MongoIntegrationTestSupport {
}

static {
    kafkaContainer.withEnv("KAFKA_CREATE_TOPICS", "SANCTIONS_RESPONSE:1:1, SANCTIONS_REQUEST:1:1, PAYMENT_INITIATION_REQUEST:1:1, PAYMENT_INITIATION_RESPONSE:1:1");
    SingletonContainerPattern.startAllInParallel(mongoContainer, kafkaContainer);
}

public class InitiationConfig {

    enum InitiationTypes implements MessageType {

        INITIATION_REQUEST("initiate request"),
        INITIATION_RESPONSE("initiation response");

        private final String name;

        InitiationTypes(String name) {
            this.name = name;
        }

        @Override
        public String getName() {
            return name();
        }

        @Override
        public Set<String> getAliases() {
            return Set.of(name);
        }
    }

}

@Bean
MessageDefinition<InitiationRequest> initiationRequestMessageDefinition(@Value("${application.base.url}") String baseUrl) {
    return new DefaultMessageDefinition. Builder<InitiationRequest>()
            .withType(InitiationTypes. INITIATION_REQUEST) (1)
            .withDocumentTypeClass(InitiationRequest.class) (2)
            .withGenerator(props -> new InitiationRequest()) (3)
            .withDestination(baseUrl + "/submit") (4)
            .withCorrelatingIdGet(message -> Optional.ofNullable(message.getDocument().getRequestId())) (5)
            .withPreSend(message -> ContextUtils.setClientRequestId(message.getDocument().getRequestId())) (6)
            .build();
}

@Bean
MessageDefinition<InitiationResponse> initiationResponseMessageDefinition() {
    return new DefaultMessageDefinition. Builder<InitiationResponse>()
            .withType(InitiationTypes. INITIATION_RESPONSE) (1)
            .withDocumentTypeClass(InitiationResponse.class) (2)
            .withCorrelatingIdGet(message -> Optional.ofNullable(message.getDocument().getRequestId())) (3)
            .build();
}

@Bean
public MessageTransport initiationTransport(MessageDefinition<InitiationRequest> initiationRequestMessageDefinition, MessageDefinition<InitiationResponse> initiationResponseMessageDefinition) {
    return new HttpSenderTestTransporter. Builder<InitiationRequest, InitiationResponse>()
            .withIdentifier("initiation") (1)
            .withRequestMessageDefinition(initiationRequestMessageDefinition) (2)
            .withResponseMessageDefinition(initiationResponseMessageDefinition) (3)
            .build();
}

application.base.url="http://localhost:8080"

<dependency>
    <groupId>org.junit.vintage</groupId>
    <artifactId>junit-vintage-engine</artifactId>
</dependency>

<dependency>
    <groupId>org.wiremock</groupId>
    <artifactId>wiremock-standalone</artifactId>
</dependency>

@Configuration
public class DummyODSConsumer {

    @Bean
    public WireMockServer odsMock() {
        WireMockServer wireMockServer = new WireMockServer(
                new WireMockConfiguration()
                        .port(8093)
                        .needClientAuth(true)
        );

        wireMockServer.start();

        wireMockServer.stubFor(WireMock.post(WireMock.urlEqualTo("/ipf-processing-data"))
                .willReturn(WireMock.aResponse()
                        .withStatus(200)));

        return wireMockServer;
    }

}

@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest. WebEnvironment. DEFINED_PORT)
@Import({AllTestConfig.class, InitiationConfig.class, DummyODSConsumer.class})
public class FeatureTestRunner extends IPFFeatureTestRunner implements KafkaIntegrationTestSupport, MongoIntegrationTestSupport {..}

<dependency>
    <groupId>com.iconsolutions.ipf.core.test</groupId>
    <artifactId>ipf-test-fw-connectors</artifactId>
</dependency>

public class SanctionsConfig {

    enum SanctionsTypes implements MessageType {

        SANCTIONS_REQUEST("sanctions request"),
        SANCTIONS_RESPONSE("sanctions response");

        private final String name;

        SanctionsTypes(String name) {
            this.name = name;
        }

        @Override
        public String getName() {
            return name();
        }

        @Override
        public Set<String> getAliases() {
            return Set.of(name);
        }
    }

}

@Bean
MessageDefinition<SanctionsRequest> receiveSanctionsRequest() {
    return new DefaultMessageDefinition. Builder<SanctionsRequest>()
            .withType(SanctionsTypes. SANCTIONS_REQUEST) (1)
            .withDocumentTypeClass(SanctionsRequest.class) (2)
            .withSource("SANCTIONS_REQUEST") (3)
            .withFromStringMapper(serialisedString -> SerializationHelper.stringToObject(serialisedString, SanctionsRequest.class)) (4)
            .withCorrelatingIdGet(message -> Optional.ofNullable(ContextUtils.getClientRequestId())) (5)
            .build();
}

@Bean
MessageDefinition<SanctionsResponse> sendSanctionsResponse() {
    return new DefaultMessageDefinition. Builder<SanctionsResponse>()
            .withType(SanctionsTypes. SANCTIONS_RESPONSE)
            .withDocumentTypeClass(SanctionsResponse.class)
            .withDestination("SANCTIONS_RESPONSE")
            .withGenerator(props -> {
                SanctionsResponse sanctionsResponse = new SanctionsResponse(); (1)
                sanctionsResponse.setHeader(HeaderUtils.makeHeader("Sanctions", ContextUtils.getClientRequestId())); (2)
                sanctionsResponse.getHeader().getTechnical().setOriginalEventId(((SanctionsRequest) PreviousMessages.getLastMessage(SanctionsTypes. SANCTIONS_REQUEST, false).getDocument()).getHeader().getTechnical().getEventId()); (3)
                sanctionsResponse.setPayload(new SanctionsResponsePayload()); (4)
                return sanctionsResponse;
            })
            .withCorrelatingIdGet(doc -> Optional.ofNullable(ContextUtils.getClientRequestId()))
            .build();
}

@Bean
public MessageTransport sanctionsKafkaTransport(MessageDefinition<SanctionsRequest> sanctionsRequestMessageDefinition,
MessageDefinition<SanctionsResponse> sanctionsResponseMessageDefinition,
ClassicActorSystemProvider actorSystem) {
    return new KafkaTestTransporter. Builder<SanctionsRequest,SanctionsResponse>()
            .withIdentifier("sanctions") (1)
            .withPropertiesPath("sanctions") (2)
            .withReceiveMessageDefinition(sanctionsRequestMessageDefinition) (3)
            .withSendMessageDefinition(sanctionsResponseMessageDefinition) (4)
            .withActorSystem(actorSystem) (5)
            .build();
}

.withGenerator(params -> {
    var fraudResponse = new OlafResponse();
    fraudResponse.setHeader(HeaderUtils.makeHeader("Fraud", ContextUtils.getClientRequestId()));
    fraudResponse.setPayload(new FraudFeedbackPayload(new FraudFeedback(new FraudFeedback. PaymentStatusChanged("FraudFeedbackOK", "0"), null)));
    return fraudResponse;
    })
}

public class FraudConfig {

    @Bean
    MessageDefinition<OlafResponse> fraudResponseMessageDefinition() {
        return new DefaultMessageDefinition. Builder<OlafResponse>()
                .withType(FraudTypes. FRAUD_RESPONSE)
                .withCausedByType(FraudTypes. FRAUD_REQUEST)
                .withDocumentTypeClass(OlafResponse.class)
                .withCorrelatingIdGet(response -> Optional.of(ContextUtils.getClientRequestId()))
                .withGenerator(params -> {
                    var fraudResponse = new OlafResponse();
                    fraudResponse.setHeader(HeaderUtils.makeHeader("Fraud", ContextUtils.getClientRequestId()));
                    fraudResponse.setPayload(new FraudFeedbackPayload(new FraudFeedback(new FraudFeedback. PaymentStatusChanged("FraudFeedbackOK", "0"), null)));
                    return fraudResponse;
                })
                .build();
    }

    @Bean
    MessageDefinition<OlafRequest> fraudRequestMessageDefinition() {
        return new DefaultMessageDefinition. Builder<OlafRequest>()
                .withType(FraudTypes. FRAUD_REQUEST)
                .withDocumentTypeClass(OlafRequest.class)
                .withFromStringMapper(serialisedString -> SerializationHelper.stringToObject(serialisedString, OlafRequest.class))
                .withCorrelatingIdGet(fraudRequest -> Optional.of(ContextUtils.getClientRequestId()))
                .build();
    }

    enum FraudTypes implements MessageType {

        FRAUD_REQUEST("fraud request"),
        FRAUD_RESPONSE("fraud response");

        private final String name;

        FraudTypes(String name) {
            this.name = name;
        }

        @Override
        public String getName() {
            return name();
        }

        @Override
        public Set<String> getAliases() {
            return Set.of(name);
        }
    }

}

@Bean
public MessageTransport fraudTransport(@Value("${fraud.http.client.port}") String port,
                                       MessageDefinition<OlafRequest> fraudRequestMessageDefinition,
                                       MessageDefinition<OlafResponse> fraudResponseMessageDefinition,
                                       ClassicActorSystemProvider actorSystem) {
    return new HttpConsumerTestTransporter. Builder()
            .withIdentifier("fraud")
            .withPort(Integer.parseInt(port)) (1)
            .withOperation(new HttpOperation. Builder<>("v1", fraudRequestMessageDefinition, fraudResponseMessageDefinition).withHttpMethod(HttpMethod. POST).build()) (2)
            .withActorSystem(actorSystem)
            .build();
}

@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest. WebEnvironment. DEFINED_PORT)
@Import({AllTestConfig.class, FraudConfig.class, SanctionsConfig.class, InitiationConfig.class, DummyODSConsumer.class})
public class FeatureTestRunner extends IPFFeatureTestRunner implements KafkaIntegrationTestSupport, MongoIntegrationTestSupport {..}