Refactor and improve Camel integration with better error handling, logging, and documentation

- Added detailed explanation of Apache Camel integration to the documentation
- Refactored CurrencyConversionService to use ProducerTemplate effectively
- Improved error handling and logging in CurrencyConversionService
- Created ExchangeRateProcessor for handling API responses
- Updated CurrencyConversionRoute to use ExchangeRateProcessor
- Updated tests for CurrencyConversionService and ExchangeRateProcessor
- Added headers and comments to newly created/updated files for consistency
- Updated POM file to include necessary dependencies and plugins

Author: Shelson Ferrari

pom.xml

@@ -11,21 +11,22 @@ Currency Conversion API - POM.xml
 This file configures the Maven project for the Currency Conversion API application.
 
 Includes:
-- Dependency definitions
-- Plugins
-- Build profiles
-- Project properties
+- Dependency definitions for various libraries and frameworks such as Apache Camel, Spring Boot,
+and Hibernate.
+- Plugins for building, testing, and documenting the project.
+- Build profiles for different environments and use cases.
+- Project properties including Java version and encoding settings.
 
 Manages:
-- Spring Boot dependencies
-- Testing tools
-- Validation
-- JSON handling
+- Spring Boot dependencies for web and data access.
+- Testing tools including JUnit, Mockito, and AssertJ.
+- Validation using Hibernate Validator.
+- JSON handling with Jackson and other libraries.
 
 Configures:
-- Plugins for code style checking
-- Rule enforcement
-- Javadoc generation
+- Plugins for code style checking (Checkstyle) to ensure consistent code quality.
+- Rule enforcement using the Maven Enforcer Plugin.
+- Javadoc generation for creating project documentation.
 -->
 
 <!-- Maven project definition -->
@@ -84,6 +85,22 @@ Configures:
             <version>3.15.0</version>
         </dependency>
 
+        <!-- Apache Camel dependencies para testes -->
+        <dependency>
+            <groupId>org.apache.camel</groupId>
+            <artifactId>camel-test-spring-junit5</artifactId>
+            <version>4.0.2</version>
+            <scope>test</scope>
+        </dependency>
+
+        <!-- Dependência do WireMock para simular respostas de API -->
+        <dependency>
+            <groupId>com.github.tomakehurst</groupId>
+            <artifactId>wiremock-jre8</artifactId>
+            <version>2.31.0</version>
+            <scope>test</scope>
+        </dependency>
+
         <!-- Apache Camel dependencies -->
         <dependency>
             <groupId>org.apache.camel</groupId>

src/main/java/com/shelson/application/processors/ExchangeRateProcessor.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2024, Shelson Ferrari
+ *
+ * Licensed under the MIT License and the Apache License, Version 2.0 (the "Licenses"); you may not use this file except in
+ * compliance with the Licenses. You may obtain a copy of the Licenses at
+ *
+ * MIT License:
+ * https://opensource.org/licenses/MIT
+ *
+ * Apache License, Version 2.0:
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the Licenses is
+ * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+ * the Licenses for the specific language governing permissions and limitations under the Licenses.
+ */
+
+package com.shelson.application.processors;
+
+import java.util.Map;
+
+import org.apache.camel.Exchange;
+import org.apache.camel.Processor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * Processor to handle exchange rates.
+ * This processor reads the exchange rate data from the message body,
+ * parses it, and sets the parsed rates back into the message body.
+ */
+@Component
+public class ExchangeRateProcessor implements Processor {
+    private static final Logger logger = LoggerFactory.getLogger(ExchangeRateProcessor.class);
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    /**
+     * Processes the exchange to extract and set exchange rates.
+     *
+     * @param exchange The Camel exchange containing the message
+     * @throws Exception If an error occurs during processing
+     */
+    @Override
+    public void process(Exchange exchange) throws Exception {
+        logger.info("Processing exchange to extract rates");
+        String response = exchange.getIn().getBody(String.class);
+        Map<String, Map<String, Double>> ratesResponse = objectMapper.readValue(response, new TypeReference<Map<String, Map<String, Double>>>() {});
+        Map<String, Double> rates = ratesResponse.get("rates");
+        exchange.getIn().setBody(rates);
+        logger.info("Exchange rates extracted and set in the message body");
+    }
+}

src/main/java/com/shelson/application/routes/CurrencyConversionRoute.java

@@ -14,15 +14,19 @@
  * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
  * the Licenses for the specific language governing permissions and limitations under the Licenses.
  */
+
 package com.shelson.application.routes;
 
 import org.apache.camel.builder.RouteBuilder;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import com.shelson.application.dto.CurrencyConversionDTO;
+import com.shelson.application.processors.ExchangeRateProcessor;
 import com.shelson.application.service.CurrencyConversionService;
 import com.shelson.domain.model.Currency;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Camel route for handling currency conversion requests.
@@ -32,20 +36,32 @@
 @Component
 public class CurrencyConversionRoute extends RouteBuilder {
 
+    private static final Logger logger = LoggerFactory.getLogger(CurrencyConversionRoute.class);
+
     @Autowired
     private CurrencyConversionService currencyConversionService;
 
+    @Autowired
+    private ExchangeRateProcessor exchangeRateProcessor;
+
+    /**
+     * Configures the Camel route for currency conversion.
+     * 
+     * @throws Exception if an error occurs during configuration
+     */
     @Override
     public void configure() throws Exception {
         from("direct:convertCurrency")
             .routeId("currencyConversionRoute")
             .log("Processing currency conversion: source=${header.source}, target=${header.target}, amount=${header.amount}")
+            .process(exchangeRateProcessor)
             .process(exchange -> {
                 String source = exchange.getIn().getHeader("source", String.class);
                 String target = exchange.getIn().getHeader("target", String.class);
                 Double amount = exchange.getIn().getHeader("amount", Double.class);
 
                 if (source == null || target == null || amount == null) {
+                    logger.error("Source, target, and amount must be provided");
                     throw new IllegalArgumentException("Source, target, and amount must be provided");
                 }
 
@@ -54,7 +70,8 @@ public void configure() throws Exception {
 
                 CurrencyConversionDTO conversionDTO = currencyConversionService.convertCurrency(sourceCurrency, targetCurrency, amount);
                 exchange.getIn().setBody(conversionDTO);
-            })
-            .log("Currency conversion completed: ${body}");
+
+                logger.info("Currency conversion completed: {}", conversionDTO);
+            });
     }
 }

src/main/java/com/shelson/application/service/CurrencyConversionService.java

@@ -10,10 +10,11 @@
  * Apache License, Version 2.0:
  * http://www.apache.org/licenses/LICENSE-2.0
  *
- * Unless required by applicable law or agreed to in writing, software distributed under the Licenses is
- * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
- * the Licenses for the specific language governing permissions and limitations under the Licenses.
+ * Unless required by applicable law or agreed to in writing, software distributed under the Licenses é
+ * distribuído em uma base "COMO ESTÁ", SEM GARANTIAS OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas. Veja
+ * os Licenses para a linguagem específica que rege permissões e limitações sob os Licenses.
  */
+
 package com.shelson.application.service;
 
 import java.time.LocalDateTime;
@@ -83,7 +84,7 @@ public CurrencyConversionDTO convertCurrency(Currency sourceCurrency, Currency t
             }
         } catch (Exception ex) {
             logger.error("Error fetching exchange rates from API: {}", ex.getMessage());
-            throw new ResourceNotFoundException("Error fetching exchange rates from API: " + ex.getMessage());
+            throw new ResourceNotFoundException("Error fetching exchange rates from API", ex);
         }
 
         if (rates == null || !rates.containsKey(targetCurrency.getCode())) {

src/main/java/com/shelson/infrastructure/exception/ResourceNotFoundException.java

@@ -14,30 +14,32 @@
  * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
  * the Licenses for the specific language governing permissions and limitations under the Licenses.
  */
-package com.shelson.infrastructure.exception;
 
-import org.springframework.http.HttpStatus;
-import org.springframework.web.bind.annotation.ResponseStatus;
+package com.shelson.infrastructure.exception;
 
 /**
  * Exception thrown when a requested resource is not found.
- * <p>
- * This exception is used to indicate that a specific resource was not found.
- * It is annotated with {@link ResponseStatus} to return a 404 Not Found HTTP status
- * code when the exception is thrown.
- * </p>
  */
-@ResponseStatus(code = HttpStatus.NOT_FOUND)
 public class ResourceNotFoundException extends RuntimeException {
-	
+
     private static final long serialVersionUID = 1L;
 
     /**
-     * Constructor that accepts an error message.
+     * Constructs a new ResourceNotFoundException with the specified detail message.
      *
-     * @param message The error message detailing the cause of the exception.
+     * @param message the detail message
      */
     public ResourceNotFoundException(String message) {
         super(message);
     }
+
+    /**
+     * Constructs a new ResourceNotFoundException with the specified detail message and cause.
+     *
+     * @param message the detail message
+     * @param cause the cause
+     */
+    public ResourceNotFoundException(String message, Throwable cause) {
+        super(message, cause);
+    }
 }

src/test/java/com/shelson/application/processors/ExchangeRateProcessorTest.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2024, Shelson Ferrari
+ *
+ * Licensed under the MIT License and the Apache License, Version 2.0 (the "Licenses"); you may not use this file except in
+ * compliance with the Licenses. You may obtain a copy of the Licenses at
+ *
+ * MIT License:
+ * https://opensource.org/licenses/MIT
+ *
+ * Apache License, Version 2.0:
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the Licenses is
+ * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+ * the Licenses for the specific language governing permissions and limitations under the Licenses.
+ */
+
+package com.shelson.application.processors;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import java.util.Map;
+
+import org.apache.camel.Exchange;
+import org.apache.camel.impl.DefaultCamelContext;
+import org.apache.camel.support.DefaultExchange;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Unit tests for the {@link ExchangeRateProcessor} class.
+ */
+public class ExchangeRateProcessorTest {
+
+    private static final Logger logger = LoggerFactory.getLogger(ExchangeRateProcessorTest.class);
+
+    private ExchangeRateProcessor processor;
+    private Exchange exchange;
+
+    /**
+     * Sets up the test environment.
+     */
+    @BeforeEach
+    public void setUp() {
+        processor = new ExchangeRateProcessor();
+        exchange = new DefaultExchange(new DefaultCamelContext());
+        logger.info("Test environment set up");
+    }
+
+    /**
+     * Tests the {@link ExchangeRateProcessor#process(Exchange)} method.
+     * 
+     * @throws Exception if any error occurs during processing
+     */
+    @Test
+    public void testProcess() throws Exception {
+        // Correctly formatted JSON string
+        String json = "{\"rates\":{\"USD\":1.0,\"EUR\":0.85}}";
+        exchange.getIn().setBody(json);
+
+        logger.info("Processing exchange with body: {}", json);
+        processor.process(exchange);
+
+        @SuppressWarnings("unchecked")
+        Map<String, Double> rates = exchange.getIn().getBody(Map.class);
+
+        assertNotNull(rates, "Rates should not be null");
+        assertEquals(1.0, rates.get("USD"), "USD rate should be 1.0");
+        assertEquals(0.85, rates.get("EUR"), "EUR rate should be 0.85");
+
+        logger.info("Processed rates: {}", rates);
+    }
+}

src/test/java/com/shelson/application/routes/CurrencyConversionRouteTest.java

@@ -0,0 +1,46 @@
+package com.shelson.application.routes;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.test.spring.junit5.CamelSpringBootTest;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.annotation.DirtiesContext;
+
+import com.shelson.application.dto.CurrencyConversionDTO;
+
+@CamelSpringBootTest
+@SpringBootTest
+@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD)
+public class CurrencyConversionRouteTest {
+
+    @Autowired
+    private ProducerTemplate producerTemplate;
+
+    @Autowired
+    private CamelContext camelContext;
+
+    @Test
+    public void testCurrencyConversionRoute() throws Exception {
+        camelContext.start();
+
+        Map<String, Object> headers = new HashMap<>();
+        headers.put("source", "USD");
+        headers.put("target", "EUR");
+        headers.put("amount", 100.0);
+
+        CurrencyConversionDTO result = producerTemplate.requestBodyAndHeaders("direct:convertCurrency", null, headers, CurrencyConversionDTO.class);
+        assertNotNull(result);
+        assertEquals("USD", result.getSourceCurrency().getCode());
+        assertEquals("EUR", result.getTargetCurrency().getCode());
+
+        camelContext.stop();
+    }
+}

src/test/java/com/shelson/application/service/CurrencyConversionServiceTest.java

@@ -10,9 +10,9 @@
  * Apache License, Version 2.0:
  * http://www.apache.org/licenses/LICENSE-2.0
  *
- * Unless required by applicable law or agreed to in writing, software distributed under the Licenses is
- * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
- * the Licenses for the specific language governing permissions and limitations under the Licenses.
+ * Unless required by applicable law or agreed to in writing, software distribuído sob os Licenses é
+ * distribuído em uma base "COMO ESTÁ", SEM GARANTIAS OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas. Veja
+ * os Licenses para a linguagem específica que rege permissões e limitações sob os Licenses.
  */
 
 package com.shelson.application.service;