Test and validate

mvn clean verify

mvn quarkus:dev

mvn kamel:dev

class {Vendor}{Domain}ConnectorTest extends GrandCentralTestSupportUtil {

    @Override
    protected RouteBuilder createRouteBuilder() throws Exception {
        {Vendor}{Domain}Connector connector = new {Vendor}{Domain}Connector();
        Properties props = useOverridePropertiesWithPropertiesComponent();
        for (Field field : connector.getClass().getDeclaredFields()) {
            if (field.isAnnotationPresent(PropertyInject.class)) {
                field.setAccessible(true);
                PropertyInject annotation = field.getAnnotation(PropertyInject.class);
                String value = props.getProperty(annotation.value(),
                    annotation.defaultValue().isEmpty() ? null : annotation.defaultValue());
                if (value != null) field.set(connector, value);
            }
        }
        return connector;
    }

    @Override
    protected Properties useOverridePropertiesWithPropertiesComponent() {
        Properties p = new Properties();
        p.setProperty("{vendor}.base.url", "http://localhost:8080/mock");
        p.setProperty("retryFlag", "false");
        p.setProperty("acceptedHeaders", "entityId,Content-Type");
        p.setProperty("resourcesBasePath", "");
        return p;
    }

    @Override
    public void doPostSetup() throws Exception {
        JunitUtil.mockRoutes(context,
            List.of("direct://getEntityById", "direct://createEntity"),
            "kamelet:*");
        context.start();
    }

    @Test
    void getEntityById_shouldReturnMappedResponse() throws Exception {
        MockEndpoint mockKamelet = findMockKamelet();
        mockKamelet.whenAnyExchangeReceived(exchange ->
            exchange.getIn().setBody(JunitUtil.loadJsonFromResource("mock-entity-response.json")));

        Exchange result = template.send("direct://getEntityById",
            e -> e.getIn().setHeader("entityId", "ENTITY001"));

        assertNotNull(result.getIn().getBody(String.class));
        assertFalse(result.isFailed());
    }
}

class {Op}{Entity}RequestTransformationTest {

    private static CamelContext context;
    private static ProducerTemplate template;
    private static final ObjectMapper MAPPER = new ObjectMapper();

    @BeforeAll
    static void setUp() throws Exception {
        context = new DefaultCamelContext();
        context.addRoutes(new RouteBuilder() {
            @Override public void configure() {
                from("direct:transform")
                    .to("jolt:{op}-{entity}-request-transformation.json"
                        + "?transformDsl=Chainr&inputType=JsonString&outputType=JsonString");
            }
        });
        context.start();
        template = context.createProducerTemplate();
    }

    @Test
    void shouldMapRequiredFields() throws Exception {
        String input = JunitUtil.loadJsonFromResource("test-{op}-{entity}-input.json").toString();
        String output = template.requestBody("direct:transform", input, String.class);
        Map<String, Object> result = MAPPER.readValue(output, new TypeReference<>() {});
        assertNotNull(result.get("vendorField"));
    }
}

class {Op}{Entity}RequestTransformationTest {

    private static CamelContext context;
    private static ProducerTemplate template;

    @BeforeAll
    static void setUp() throws Exception {
        // Required for XSLT 3.0 (Saxon)
        System.setProperty("javax.xml.transform.TransformerFactory",
            "net.sf.saxon.TransformerFactoryImpl");
        context = new DefaultCamelContext();
        context.addRoutes(new RouteBuilder() {
            @Override public void configure() {
                from("direct:transform")
                    .to("xslt:{op}-{entity}-request-transformation.xslt");
            }
        });
        context.start();
        template = context.createProducerTemplate();
    }

    @Test
    void shouldProduceValidRequest() throws Exception {
        String input = JunitUtil.loadXmlFromResource("test-empty-root.xml");
        Exchange exchange = template.send("direct:transform", e -> {
            e.getIn().setBody(input);
            e.getIn().setHeader("entityId", "12345");
        });
        String output = exchange.getIn().getBody(String.class);
        assertNotNull(output);
        assertTrue(output.contains("12345"));
    }
}

mvn test
mvn -Dtest=<ConnectorName>Test#<methodName> test