Simuladores IPF

<dependencies>
    <dependency>
       <groupId>com.iconsolutions.test</groupId>
        <artifactId>ipf-simulator-ng-api</artifactId>
        <version>${simulator.version}</version>
    </dependency>
    <dependency>
       <groupId>com.iconsolutions.test</groupId>
        <artifactId>ipf-simulator-ng-core</artifactId>
        <version>${simulator.version}</version>
    </dependency>
</dependencies>

@SpringBootApplication
class ExampleSimulatorApplication {
    public static void main(final String[] args) {
        final var simulator = new SpringApplication(ExampleSimulatorApplication.class);
        simulator.setWebApplicationType(NONE);
        simulator.run(args);
    }
}

    @SuppressWarnings("unused")
    enum TestBusinessDomainMessageType implements MessageType {

        MY_REQUEST,
        PAIN001_RAW_REQUEST,

        PACS008_RAW_REQUEST;

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

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

    @Bean
    MessageDefinition<MyRequest> requestMessageDefinition(final WireMockServer wireMockServer) {
        return new DefaultMessageDefinition.Builder<MyRequest>()
                .withType(MY_REQUEST)  (1)
                .withGenerator(myRequestGenerator()) (2)
                .withDocumentTypeClass(MyRequest.class) (3)
                .withDestination(wireMockServer.url("/endpoint")) (4)
                .withToStringMapper(this::messageAsJson)
                .build();
    }

    private String messageAsJson(Object document) {
        try {
            return objectMapper.writeValueAsString(document);
        } catch (JsonProcessingException e) {
            throw new IconRuntimeException("Could not serialize " + document, e);
        }
    }

    @Bean
    RequestInitiationGenerator<MyRequest> myRequestGenerator() {
        return properties -> new MyRequest();
    }

    @Bean
    RequestInitiationEnricher<MyRequest> myRequestEnricher() {
        return (myRequest, parameters) -> {
            Optional.ofNullable(parameters.getTransactionId())
                    .ifPresent(myRequest::setTxnId);

            Optional.ofNullable(parameters.getAmount())
                    .map(RequestAmount::getAmount)
                    .ifPresent(myRequest::setAmount);

            return myRequest;
        };
    }

    @Bean
    SpelRequestInitiationEnricher<MyRequest, MyRequest> mySpelRequestEnricher() {

        var CUSTOMISED_TRANSACTION_ID = "myCustomisedTransactionId";
        var legacyFields = List.of(CUSTOMISED_TRANSACTION_ID);
        var spelParserConfiguration = new SpelParserConfiguration(
                true,
                true,
                10
        );

        return new SpelRequestInitiationEnricher<>(
                legacyFields,  (1)
                spelParserConfiguration
        ) {

            @Override
            protected void enrichFromInitiateRequestParameters(MyRequest myRequest,
                                                               InitiateRequestParameters parameters
            ) { (2)
                Optional.ofNullable(parameters.getTransactionId())
                        .ifPresent(myRequest::setTxnId);

                Optional.ofNullable(parameters.getAmount())
                        .map(RequestAmount::getAmount)
                        .ifPresent(myRequest::setAmount);
            }

            @Override
            protected MyRequest getObjectToEnrichFromAdditionalInfo(MyRequest request) {
                (3)
                return request;
            }

            @Override
            protected void enrichUsingLegacyFields(MyRequest request,
                                                   Map.Entry<String, Object> entry
            ) { (4)
                if (CUSTOMISED_TRANSACTION_ID.equals(entry.getKey())) {
                    request.setTxnId(entry.getValue().toString());
                }
            }

        };
    }

    @Bean
    RawRequestWrapper<MyRawPain001Request> rawPain001RequestWrapper() {
        return new RawRequestWrapper<MyRawPain001Request>() {
            @Override
            public MyRawPain001Request map(InitiateWithRawRequest initiateWithRawRequest) { (1)
                return MyRawPain001Request.builder()
                        .rawXml(initiateWithRawRequest.getRawRequest())
                        .build();
            }

            @Override
            public boolean supports(InitiateWithRawRequest initiateWithRawRequest) { (2)
                return "this is pain001 message".equalsIgnoreCase(initiateWithRawRequest.getMetadata());
            }
        };
    }

    @Bean
    MessageDefinition<MyRawPain001Request> rawPain001RequestMessageDefinition(final WireMockServer wireMockServer) {
        return new DefaultMessageDefinition.Builder<MyRawPain001Request>()
                .withType(PAIN001_RAW_REQUEST)  (1)
                .withDocumentTypeClass(MyRawPain001Request.class) (2)
                .withDestination(wireMockServer.url("/pain001")) (3)
                .withToStringMapper(MyRawPain001Request::getRawXml) (4)
                .build();
    }

    @Bean
    MessageTransport channelMessageTransport() {
        final ActorSystem actorSystem = ActorSystem.create("test-implementation");
        /* This transporter is asynchronous and does not add messages to the message bucket,
         * therefore it is not suitable for use with JBehave feature tests */
        final var transporter = new AkkaHttpMessageTransporter<>(
                Http.get(actorSystem),
                actorSystem
        );

        return MessageTransportImpl.MessageTransportImplBuilder.aMessageTransportImpl()
                .withSendingSupplier(transporter)
                .withSupportedMessageTypes(Set.of(
                        MY_REQUEST,
                        PAIN001_RAW_REQUEST,
                        PACS008_RAW_REQUEST))
                .build();
    }

final class AkkaHttpMessageTransporter<T> implements TransporterWithAckSupport<HttpResponse> {

    @Override
    public CompletionStage<HttpResponse> sendMessageWithAck(MessageDefinition messageDefinition, Message message, String destination) {

        HttpRequest request = httpRequestFor(messageDefinition, message, destination);
        LOGGER.debug("Sending request {}", request);

        return akkaHttp.singleRequest(request)
                // Consume response entity
                .thenCompose(httpResponse -> httpResponse
                        .toStrict(TOSTRICT_TIMEOUT_MILLIS, classicActorSystemProvider)
                        .thenApply(HttpResponse.class::cast));
    }

    private HttpRequest httpRequestFor(
            MessageDefinition<T> messageDefinition, Message<T> message, String destination) {

        return HttpRequest.create(uriFor(destination, messageDefinition))
                .withMethod(httpMethodFor(messageDefinition))
                .withHeaders(headersFor(message))
                .withEntity(HttpEntities.create(
                        ContentTypes.APPLICATION_JSON,
                        messageDefinition.asString(message.getDocument())
                ));
    }

    private String uriFor(String destination, MessageDefinition<T> messageDefinition) {
        return StringUtils.defaultIfBlank(destination, messageDefinition.getDestination()); (1)
    }
    //..
}

final class ExampleSimulatorHandler implements RequestHandler {

    ExampleSimulatorHandler(final WireMockServer wireMockServer) {
        this.wireMockServer = wireMockServer;
        this.latency = 0;

        this.wireMockServer.stubFor(post(urlEqualTo("/endpoint"))
                .withRequestBody(containing("this-is-a-magic-txnId-and-will-cause-a-rejection"))
                .willReturn(aResponse()
                        .withStatus(418)
                        .withBody("FAILED")));

        this.wireMockServer.stubFor(post(urlEqualTo("/endpoint"))
                .withRequestBody(containing("this-is-a-magic-txnId-and-will-be-accepted"))
                .willReturn(aResponse()
                        .withStatus(201)
                        .withBody("SUCCESS")));
    }

}

@SpringBootApplication
class ExampleSimulatorApplication {

    @Bean
    RequestHandler testSimulatorHandler(final WireMockServer wireMockServer) {
        return new ExampleSimulatorHandler(wireMockServer);
    }

}

    @Override
    public List<MagicValue> getMagicValues() {
        return List.of(new MagicValue(
                "Rejects requests with this txnId",
                "txnId",
                "this-is-a-magic-txnId-and-will-cause-a-rejection"));
    }