feat: Release 1.1.0

.woodpecker/maven.yaml

@@ -1,5 +1,5 @@
 variables:
-  &maven_image maven:3.9.6-eclipse-temurin-17-alpine
+  &maven_image maven:3.9.6-eclipse-temurin-21-alpine
 
 steps:
   - name: build

pom.xml

@@ -13,7 +13,7 @@
 
     <groupId>eu.ztsh</groupId>
     <artifactId>wymiana-walut</artifactId>
-    <version>1.0.0-SNAPSHOT</version>
+    <version>1.1.0</version>
 
     <properties>
         <!-- encoding -->
@@ -22,12 +22,13 @@
         <project.reporting.outputEncoding>${source.encoding}</project.reporting.outputEncoding>
 
         <!-- JDK -->
-        <java.version>17</java.version>
+        <java.version>21</java.version>
         <maven.compiler.source>${java.version}</maven.compiler.source>
         <maven.compiler.target>${java.version}</maven.compiler.target>
 
         <!-- dependencies -->
         <wiremock.version>3.5.4</wiremock.version>
+        <openapi.version>2.5.0</openapi.version>
 
         <!-- plugins -->
         <jsonschema2pojo.version>1.2.1</jsonschema2pojo.version>
@@ -51,6 +52,10 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-jpa</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
 
         <!-- 3rd party -->
         <dependency>
@@ -58,6 +63,11 @@
             <artifactId>lombok</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>org.springdoc</groupId>
+            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
+            <version>${openapi.version}</version>
+        </dependency>
 
         <!-- Database -->
         <dependency>
@@ -69,6 +79,12 @@
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-webflux</artifactId>
+            <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
@@ -100,6 +116,7 @@
                 <configuration>
                     <sourceDirectory>${basedir}/src/main/resources/schema</sourceDirectory>
                     <targetPackage>eu.ztsh.wymiana.model</targetPackage>
+                    <useBigDecimals>true</useBigDecimals>
                 </configuration>
                 <executions>
                     <execution>
@@ -109,6 +126,32 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>default-test</id>
+                        <configuration>
+                            <excludes>
+                                <exclude>**/*Tests.java</exclude>
+                            </excludes>
+                        </configuration>
+                    </execution>
+                    <execution>
+                        <id>integration-tests</id>
+                        <phase>test</phase>
+                        <goals>
+                            <goal>test</goal>
+                        </goals>
+                        <configuration>
+                            <excludes>
+                                <exclude>**/*Test.java</exclude>
+                            </excludes>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 

readme.md

@@ -0,0 +1,202 @@
+# Wymiana walut
+
+Prosty mikroserwis stworzony na potrzeby rekrutacji
+
+## Założenia
+
+- PESEL jedynym identyfikatorem
+- Jedno konto na PESEL
+- Użytkownik pełnoletni
+- Wymiana walut na podstawie tabeli NBP
+- Baza danych in-memory
+
+## Interfejsy
+
+- stworzenie konta
+
+  ⇒ POST `/api/user`
+  ```json
+  {
+    "type": "object",
+    "properties": {
+      "name": {
+        "type": "string"
+      },
+      "surname": {
+        "type": "string"
+      },
+      "pesel": {
+        "type": "string"
+      },
+      "initial": {
+        "type": "number",
+        "description": "początkowy stan konta w domyślnej walucie"
+      }
+    },
+    "required": [
+      "name",
+      "surname",
+      "pesel",
+      "initial"
+    ]
+  }
+  ```
+  ⇐ 204/400/409/500
+
+- pobranie informacji o koncie
+
+  ⇒ GET `/api/user/{pesel}`
+
+  ⇐ 200/400/404/500
+  ```json
+  {
+    "type": "object",
+    "def": {
+      "currency": {
+        "type": "object",
+        "properties": {
+          "symbol": {
+            "type": "string"
+          },
+          "amount": {
+            "type": "number"
+          }
+        },
+        "required": [
+          "symbol",
+          "amount"
+        ]
+      }
+    },
+    "properties": {
+      "name": {
+        "type": "string"
+      },
+      "surname": {
+        "type": "string"
+      },
+      "pesel": {
+        "type": "string"
+      },
+      "currencies": {
+        "type": "array",
+        "items": {
+          "$ref": "#/def/currency"
+        }
+      }
+    },
+    "required": [
+      "name",
+      "surname",
+      "pesel",
+      "currencies"
+    ]
+  }
+  ```
+- zlecenie wymiany walut
+
+  ⇒ POST `/api/exchange/{pesel}`
+  ```json
+  {
+    "type": "object",
+    "properties": {
+      "pesel": {
+        "type": "string"
+      },
+      "from": {
+        "type": "string",
+        "description": "waluta źródłowa"
+      },
+      "to": {
+        "type": "string",
+        "description": "waluta docelowa"
+      },
+      "toBuy": {
+        "type": "number",
+        "description": "ilość do zakupu"
+      },
+      "toSell": {
+        "type": "number",
+        "description": "ilość do sprzedaży"
+      }
+    },
+    "oneOf": [
+      {
+        "required": [
+          "pesel",
+          "from",
+          "to",
+          "toBuy"
+        ]
+      },
+      {
+        "required": [
+          "pesel",
+          "from",
+          "to",
+          "toSell"
+        ]
+      }
+    ]
+  }
+  ```
+
+  ⇐ 200/400/404/500
+
+  patrz: pobranie informacji o koncie
+
+## Architektura
+
+```mermaid
+    flowchart LR
+    actor["fa:fa-person"]
+    subgraph NBP
+        tabC["Tabela C"]
+    end
+    subgraph proces
+        subgraph spring-boot
+            core
+            subgraph endpoint
+                user
+                exchange
+            end
+        end
+        hsqldb
+    end
+
+    actor <--> user
+    actor <--> exchange
+    endpoint <--> core
+    core <--> tabC
+    core <-- hsql . port --> hsqldb
+
+```
+
+## Konfiguracja
+
+Aplikacja posiada dostosowaną konfigurację, która obejmuje własności:
+
+### `hsqldb`
+
+Konfiguracja bazy danych
+
+| Nazwa | Opis             | Typ    | Wartość domyślna |
+|-------|------------------|--------|------------------|
+| name  | host bazy danych | string | db               |
+| port  | port bazy danych | int    | 9090             |
+
+### `nbp`
+
+Konfiguracja połączenia z Narodowym Bankiem Polskim
+
+| Nazwa   | Opis         | Typ    | Wartość domyślna  |
+|---------|--------------|--------|-------------------|
+| baseurl | host API nbp | string | http://api.nbp.pl |
+
+### `currency`
+
+Konfiguracja walut
+
+| Nazwa   | Opis                                    | Typ    | Wartość domyślna |
+|---------|-----------------------------------------|--------|------------------|
+| initial | waluta początkowa przy zakładaniu konta | string | PLN              |

src/main/java/eu/ztsh/wymiana/config/CurrencyProperties.java

@@ -0,0 +1,9 @@
+package eu.ztsh.wymiana.config;
+
+import eu.ztsh.wymiana.model.Symbol;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+@ConfigurationProperties("currency")
+public record CurrencyProperties(Symbol initial) {
+
+}

src/main/java/eu/ztsh/wymiana/config/NbpProperties.java

@@ -0,0 +1,8 @@
+package eu.ztsh.wymiana.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+@ConfigurationProperties("nbp")
+public record NbpProperties(String baseurl) {
+
+}

src/main/java/eu/ztsh/wymiana/config/RestClientConfiguration.java

@@ -8,9 +8,9 @@ import org.springframework.web.client.RestClient;
 public class RestClientConfiguration {
 
     @Bean
-    public RestClient restClient() {
+    public RestClient restClient(NbpProperties nbpProperties) {
         return RestClient.builder()
-            .baseUrl("http://api.nbp.pl")
+            .baseUrl(nbpProperties.baseurl())
             .defaultHeader("Accept", "application/json")
             .build();
     }

src/main/java/eu/ztsh/wymiana/data/entity/CurrencyEntity.java

@@ -1,12 +1,17 @@
 package eu.ztsh.wymiana.data.entity;
 
+import eu.ztsh.wymiana.model.Symbol;
 import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
 import jakarta.persistence.Id;
 import jakarta.persistence.Table;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
+import java.math.BigDecimal;
+
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
@@ -17,7 +22,8 @@ public class CurrencyEntity {
     @Id
     String pesel;
     @Id
-    String symbol;
-    Double amount;
+    @Enumerated(EnumType.STRING)
+    Symbol symbol;
+    BigDecimal amount;
 
 }

src/main/java/eu/ztsh/wymiana/exception/NoDataException.java

@@ -1,8 +1,10 @@
 package eu.ztsh.wymiana.exception;
 
+import eu.ztsh.wymiana.model.Symbol;
+
 public class NoDataException extends RuntimeException {
 
-    public NoDataException(String code, String date) {
+    public NoDataException(Symbol code, String date) {
         super("No data for code %s and date %s".formatted(code, date));
     }
 

src/main/java/eu/ztsh/wymiana/exception/UserNotFoundException.java

@@ -0,0 +1,15 @@
+package eu.ztsh.wymiana.exception;
+
+import eu.ztsh.wymiana.web.model.CurrencyExchangeRequest;
+
+public class UserNotFoundException extends RuntimeException {
+
+    public UserNotFoundException(CurrencyExchangeRequest entity) {
+        this(entity.pesel());
+    }
+
+    public UserNotFoundException(String pesel) {
+        super("User with PESEL %s not found".formatted(pesel));
+    }
+
+}

src/main/java/eu/ztsh/wymiana/model/Currency.java

@@ -1,5 +1,7 @@
 package eu.ztsh.wymiana.model;
 
-public record Currency(String symbol, double amount) {
+import java.math.BigDecimal;
+
+public record Currency(Symbol symbol, BigDecimal amount) {
 
 }

src/main/java/eu/ztsh/wymiana/model/Symbol.java

@@ -0,0 +1,6 @@
+package eu.ztsh.wymiana.model;
+
+public enum Symbol {
+    PLN,
+    USD
+}

src/main/java/eu/ztsh/wymiana/model/User.java

@@ -2,6 +2,6 @@ package eu.ztsh.wymiana.model;
 
 import java.util.Map;
 
-public record User(String name, String surname, String pesel, Map<String, Currency> currencies) {
+public record User(String name, String surname, String pesel, Map<Symbol, Currency> currencies) {
 
 }

src/main/java/eu/ztsh/wymiana/model/UserCreateRequestConfiguredWrapper.java

@@ -0,0 +1,65 @@
+package eu.ztsh.wymiana.model;
+
+import eu.ztsh.wymiana.web.model.UserCreateRequest;
+
+import java.math.BigDecimal;
+
+public class UserCreateRequestConfiguredWrapper {
+
+    private final UserCreateRequest request;
+    private final Symbol initialSymbol;
+
+    public String name() {
+        return request.name();
+    }
+
+    public String surname() {
+        return request.surname();
+    }
+
+    public String pesel() {
+        return request.pesel();
+    }
+
+    public BigDecimal initial() {
+        return request.initial();
+    }
+
+    public Symbol initialSymbol() {
+        return initialSymbol;
+    }
+
+    private UserCreateRequestConfiguredWrapper(Builder builder) {
+        this.request = builder.request;
+        this.initialSymbol = builder.initial;
+    }
+
+    public static Builder wrap(UserCreateRequest request) {
+        return new Builder().withRequest(request);
+    }
+
+    public static final class Builder {
+
+        private UserCreateRequest request;
+        private Symbol initial;
+
+        private Builder() {
+        }
+
+        private Builder withRequest(UserCreateRequest request) {
+            this.request = request;
+            return this;
+        }
+
+        public Builder withInitial(Symbol initial) {
+            this.initial = initial;
+            return this;
+        }
+
+        public UserCreateRequestConfiguredWrapper build() {
+            return new UserCreateRequestConfiguredWrapper(this);
+        }
+
+    }
+
+}

src/main/java/eu/ztsh/wymiana/service/CurrencyService.java

@@ -2,7 +2,9 @@ package eu.ztsh.wymiana.service;
 
 import eu.ztsh.wymiana.exception.ExchangeFailedException;
 import eu.ztsh.wymiana.exception.InsufficientFundsException;
+import eu.ztsh.wymiana.exception.UserNotFoundException;
 import eu.ztsh.wymiana.model.Currency;
+import eu.ztsh.wymiana.model.Symbol;
 import eu.ztsh.wymiana.model.User;
 import eu.ztsh.wymiana.validation.InstanceValidator;
 import eu.ztsh.wymiana.web.model.CurrencyExchangeRequest;
@@ -27,59 +29,56 @@ public class CurrencyService {
     public User exchange(CurrencyExchangeRequest request) {
         validator.validate(request);
         return userService.get(request.pesel()).map(user -> {
-                if (!request.from().equalsIgnoreCase("PLN") && !request.to().equalsIgnoreCase("PLN")) {
+                if (!request.from().equals(Symbol.PLN) && !request.to().equals(Symbol.PLN)) {
                     throw new ExchangeFailedException("Either 'from' or 'to' has to be PLN");
                 }
-                // As we support only USD now, we need to limit second parameter too
-                // Begin: unlock other currencies
-                if (!request.from().equalsIgnoreCase("USD") && !request.to().equalsIgnoreCase("USD")) {
-                    throw new ExchangeFailedException("Either 'from' or 'to' has to be USD");
-                }
-                // End: unlock other currencies
 
-                var from = user.currencies().get(request.from().toUpperCase());
+                var from = user.currencies().get(request.from());
                 if (from == null) {
                     // There is no currency 'from' opened so no need to check if user has funds to exchange
                     throw new InsufficientFundsException();
                 }
                 var exchanged = performExchange(from,
-                    Optional.ofNullable(user.currencies().get(request.to().toUpperCase())).orElse(create(request.to())),
-                    Optional.ofNullable(request.toSell()).orElse(0D),
-                    Optional.ofNullable(request.toBuy()).orElse(0D));
+                    Optional.ofNullable(user.currencies().get(request.to())).orElse(create(request.to())),
+                    Optional.ofNullable(request.toSell()).orElse(BigDecimal.ZERO),
+                    Optional.ofNullable(request.toBuy()).orElse(BigDecimal.ZERO));
                 user.currencies().putAll(exchanged);
                 return userService.update(user);
             })
-            .orElseThrow(ExchangeFailedException::new);
+            .orElseThrow(() -> new UserNotFoundException(request));
     }
 
-    private Currency create(String symbol) {
-        // TODO: check if supported - now limited to PLN <-> USD
-        return new Currency(symbol.toUpperCase(), 0D);
+    private Currency create(Symbol symbol) {
+        return new Currency(symbol, BigDecimal.ZERO);
     }
 
-    private Map<String, Currency> performExchange(Currency from, Currency to, double toSell, double toBuy) {
-        double exchangeRate;
-        double neededFromAmount;
-        double requestedToAmount;
-        if (from.symbol().equalsIgnoreCase("PLN")) {
+    private Map<Symbol, Currency> performExchange(Currency from, Currency to, BigDecimal toSell, BigDecimal toBuy) {
+        BigDecimal exchangeRate;
+        BigDecimal neededFromAmount;
+        BigDecimal requestedToAmount;
+        if (from.symbol().equals(Symbol.PLN)) {
             exchangeRate = nbpService.getSellRate(to.symbol());
-            neededFromAmount = round(toBuy != 0 ? toBuy * exchangeRate : toSell);
-            requestedToAmount = round(toBuy != 0 ? toBuy : toSell / exchangeRate);
+            neededFromAmount = round(toBuy.signum() != 0 ? toBuy.multiply(exchangeRate) : toSell);
+            requestedToAmount = round(toBuy.signum() != 0 ? toBuy : divide(toSell, exchangeRate));
         } else {
             exchangeRate = nbpService.getBuyRate(from.symbol());
-            neededFromAmount = round(toBuy != 0 ? toBuy / exchangeRate : toSell);
-            requestedToAmount = round(toBuy != 0 ? toBuy : toSell * exchangeRate);
+            neededFromAmount = round(toBuy.signum() != 0 ? divide(toBuy, exchangeRate) : toSell);
+            requestedToAmount = round(toBuy.signum() != 0 ? toBuy : toSell.multiply(exchangeRate));
         }
-        if (neededFromAmount > from.amount()) {
+        if (neededFromAmount.compareTo(from.amount()) > 0) {
             throw new InsufficientFundsException();
         }
-        var newFrom = new Currency(from.symbol(), from.amount() - neededFromAmount);
-        var newTo = new Currency(to.symbol(), to.amount() + requestedToAmount);
+        var newFrom = new Currency(from.symbol(), from.amount().subtract(neededFromAmount));
+        var newTo = new Currency(to.symbol(), to.amount().add(requestedToAmount));
         return Stream.of(newFrom, newTo).collect(Collectors.toMap(Currency::symbol, currency -> currency));
     }
 
-    private double round(double input) {
-        return BigDecimal.valueOf(input).setScale(2, RoundingMode.HALF_UP).doubleValue();
+    private BigDecimal round(BigDecimal input) {
+        return input.setScale(2, RoundingMode.HALF_UP);
+    }
+
+    private BigDecimal divide(BigDecimal input, BigDecimal division) {
+        return input.setScale(2, RoundingMode.HALF_UP).divide(division, RoundingMode.HALF_UP);
     }
 
 }

src/main/java/eu/ztsh/wymiana/service/NbpService.java

@@ -2,12 +2,14 @@ package eu.ztsh.wymiana.service;
 
 import eu.ztsh.wymiana.exception.NoDataException;
 import eu.ztsh.wymiana.model.Rates;
+import eu.ztsh.wymiana.model.Symbol;
 import lombok.RequiredArgsConstructor;
 import org.assertj.core.util.VisibleForTesting;
 import org.springframework.http.HttpStatusCode;
 import org.springframework.stereotype.Service;
 import org.springframework.web.client.RestClient;
 
+import java.math.BigDecimal;
 import java.time.Clock;
 import java.time.DayOfWeek;
 import java.time.LocalDate;
@@ -28,28 +30,28 @@ public class NbpService {
     private static final String URI_PATTERN = "/api/exchangerates/rates/c/{code}/{date}/";
     private final DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd");
 
-    private final ConcurrentMap<String, RatesCache> cache = new ConcurrentHashMap<>(1);
+    private final ConcurrentMap<Symbol, RatesCache> cache = new ConcurrentHashMap<>(1);
 
-    public double getSellRate(String currency) {
-        return getCurrency(currency.toUpperCase()).sell();
+    public BigDecimal getSellRate(Symbol currency) {
+        return getCurrency(currency).sell();
     }
 
-    public double getBuyRate(String currency) {
-        return getCurrency(currency.toUpperCase()).buy();
+    public BigDecimal getBuyRate(Symbol currency) {
+        return getCurrency(currency).buy();
     }
 
-    private synchronized RatesCache getCurrency(String currency) {
+    private synchronized RatesCache getCurrency(Symbol currency) {
         var today = getFetchDate();
         var cacheObject = cache.get(currency);
         if (cacheObject == null || cacheObject.date().isBefore(today)) {
             var fresh = fetchData(currency, dtf.format(today));
-            var rate = fresh.getRates().get(0);
+            var rate = fresh.getRates().getFirst();
             cacheObject = new RatesCache(
                 LocalDate.parse(rate.getEffectiveDate(), dtf),
                 rate.getBid(),
                 rate.getAsk()
             );
-            cache.put(fresh.getCode(), cacheObject);
+            cache.put(Symbol.valueOf(fresh.getCode().toUpperCase()), cacheObject);
         }
         return cacheObject;
     }
@@ -68,8 +70,8 @@ public class NbpService {
     }
 
     @VisibleForTesting
-    Rates fetchData(String code, String date) {
-        return restClient.get().uri(URI_PATTERN, code.toLowerCase(), date)
+    Rates fetchData(Symbol code, String date) {
+        return restClient.get().uri(URI_PATTERN, code.name().toLowerCase(), date)
             .retrieve()
             .onStatus(HttpStatusCode::is4xxClientError, ((request, response) -> {
                 throw new NoDataException(code, date);
@@ -82,7 +84,7 @@ public class NbpService {
             || today.getDayOfWeek() == DayOfWeek.SUNDAY;
     }
 
-    private record RatesCache(LocalDate date, double buy, double sell) {
+    private record RatesCache(LocalDate date, BigDecimal buy, BigDecimal sell) {
 
     }
 

src/main/java/eu/ztsh/wymiana/service/UserService.java

@@ -1,32 +1,40 @@
 package eu.ztsh.wymiana.service;
 
+import eu.ztsh.wymiana.config.CurrencyProperties;
 import eu.ztsh.wymiana.data.repository.UserRepository;
 import eu.ztsh.wymiana.exception.UserAlreadyExistsException;
 import eu.ztsh.wymiana.model.User;
+import eu.ztsh.wymiana.model.UserCreateRequestConfiguredWrapper;
 import eu.ztsh.wymiana.util.UserMapper;
 import eu.ztsh.wymiana.validation.InstanceValidator;
 import eu.ztsh.wymiana.web.model.UserCreateRequest;
 import lombok.RequiredArgsConstructor;
+import org.hibernate.validator.constraints.pl.PESEL;
 import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
 
 import java.util.Optional;
 
+@Validated
 @RequiredArgsConstructor
 @Service
 public class UserService {
 
     private final UserRepository userRepository;
     private final InstanceValidator validator;
+    private final CurrencyProperties currencyProperties;
 
     public User create(UserCreateRequest request) {
         validator.validate(request);
         if (userRepository.findById(request.pesel()).isPresent()) {
             throw new UserAlreadyExistsException(request);
         }
-        return UserMapper.entityToPojo(userRepository.save(UserMapper.requestToEntity(request)));
+        return UserMapper.entityToPojo(userRepository.save(UserMapper.requestToEntity(
+            UserCreateRequestConfiguredWrapper.wrap(request).withInitial(currencyProperties.initial()).build()
+        )));
     }
 
-    public Optional<User> get(String pesel) {
+    public Optional<User> get(@PESEL String pesel) {
         return userRepository.findById(pesel).map(UserMapper::entityToPojo);
     }
 

src/main/java/eu/ztsh/wymiana/util/CurrencyMapper.java

@@ -2,6 +2,7 @@ package eu.ztsh.wymiana.util;
 
 import eu.ztsh.wymiana.data.entity.CurrencyEntity;
 import eu.ztsh.wymiana.model.Currency;
+import eu.ztsh.wymiana.model.Symbol;
 
 import java.util.List;
 import java.util.Map;
@@ -17,12 +18,12 @@ public class CurrencyMapper {
         return new CurrencyEntity(pesel, pojo.symbol(), pojo.amount());
     }
 
-    public static Map<String, Currency> entitiesToPojoMap(List<CurrencyEntity> values) {
+    public static Map<Symbol, Currency> entitiesToPojoMap(List<CurrencyEntity> values) {
         return values.stream().map(CurrencyMapper::entityToPojo)
             .collect(Collectors.toMap(Currency::symbol, pojo -> pojo));
     }
 
-    public static List<CurrencyEntity> pojoMapToEntities(Map<String, Currency> currencies, String pesel) {
+    public static List<CurrencyEntity> pojoMapToEntities(Map<Symbol, Currency> currencies, String pesel) {
         return currencies.values().stream().map(entry -> pojoToEntity(entry, pesel)).toList();
     }
 

src/main/java/eu/ztsh/wymiana/util/UserMapper.java

@@ -3,7 +3,8 @@ package eu.ztsh.wymiana.util;
 import eu.ztsh.wymiana.data.entity.CurrencyEntity;
 import eu.ztsh.wymiana.data.entity.UserEntity;
 import eu.ztsh.wymiana.model.User;
-import eu.ztsh.wymiana.web.model.UserCreateRequest;
+import eu.ztsh.wymiana.model.UserCreateRequestConfiguredWrapper;
+import eu.ztsh.wymiana.web.model.UserResponse;
 
 import java.util.List;
 
@@ -19,9 +20,13 @@ public class UserMapper {
             CurrencyMapper.pojoMapToEntities(pojo.currencies(), pojo.pesel()));
     }
 
-    public static UserEntity requestToEntity(UserCreateRequest request) {
+    public static UserResponse pojoToResponse(User pojo) {
+        return new UserResponse(pojo.name(), pojo.surname(), pojo.pesel(), pojo.currencies().values().stream().toList());
+    }
+
+    public static UserEntity requestToEntity(UserCreateRequestConfiguredWrapper request) {
         return new UserEntity(request.pesel(), request.name(), request.surname(),
-            List.of(new CurrencyEntity(request.pesel(), "PLN", request.pln())));
+            List.of(new CurrencyEntity(request.pesel(), request.initialSymbol(), request.initial())));
     }
 
     private UserMapper() {

src/main/java/eu/ztsh/wymiana/validation/ValidExchangeRequestValidator.java

@@ -18,8 +18,8 @@ public class ValidExchangeRequestValidator implements
         return (request.from() != null && !request.from().equals(request.to()))
             && !((request.toBuy() == null && request.toSell() == null)
                 || (request.toBuy() != null && request.toSell() != null))
-            && ((request.toBuy() != null && request.toBuy() >= 0)
-                || (request.toSell() != null && request.toSell() >= 0));
+            && ((request.toBuy() != null && request.toBuy().signum() >= 0)
+                || (request.toSell() != null && request.toSell().signum() >= 0));
     }
 
 }

src/main/java/eu/ztsh/wymiana/web/controller/ExchangeController.java

@@ -0,0 +1,62 @@
+package eu.ztsh.wymiana.web.controller;
+
+import eu.ztsh.wymiana.exception.InsufficientFundsException;
+import eu.ztsh.wymiana.exception.UserNotFoundException;
+import eu.ztsh.wymiana.service.CurrencyService;
+import eu.ztsh.wymiana.web.model.CurrencyExchangeRequest;
+import eu.ztsh.wymiana.web.model.UserResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RequiredArgsConstructor
+@Validated
+@RestController
+@RequestMapping(path = "/api/exchange", produces = "application/json")
+public class ExchangeController {
+
+    private final CurrencyService currencyService;
+
+    @Operation(summary = "Perform exchange")
+    @ApiResponses(value = {
+        @ApiResponse(responseCode = "200",
+            description = "Exchange performed successfully",
+            content = @Content(mediaType = MediaType.APPLICATION_JSON_VALUE,
+                schema = @Schema(implementation = UserResponse.class))),
+        @ApiResponse(responseCode = "400",
+            description = "Insufficient funds",
+            content = @Content(mediaType = MediaType.TEXT_PLAIN_VALUE)),
+        @ApiResponse(responseCode = "404",
+            description = "User not found",
+            content = @Content(mediaType = MediaType.TEXT_PLAIN_VALUE)),
+        @ApiResponse(responseCode = "500",
+            description = "Another error has occurred",
+            content = @Content(mediaType = MediaType.TEXT_PLAIN_VALUE))
+    })
+    @PostMapping
+    public ResponseEntity<Object> exchange(@Valid @RequestBody CurrencyExchangeRequest request) {
+        try {
+            return ResponseEntity.status(200).body(currencyService.exchange(request));
+        } catch (Exception e) {
+            var status = switch (e) {
+                case InsufficientFundsException ignored -> HttpStatus.BAD_REQUEST;
+                case UserNotFoundException ignored -> HttpStatus.NOT_FOUND;
+                default -> HttpStatus.INTERNAL_SERVER_ERROR;
+            };
+            return ResponseEntity.status(status).body(e.getMessage());
+        }
+    }
+
+}

src/main/java/eu/ztsh/wymiana/web/controller/UserController.java

@@ -0,0 +1,83 @@
+package eu.ztsh.wymiana.web.controller;
+
+import eu.ztsh.wymiana.exception.UserAlreadyExistsException;
+import eu.ztsh.wymiana.exception.UserNotFoundException;
+import eu.ztsh.wymiana.service.UserService;
+import eu.ztsh.wymiana.util.UserMapper;
+import eu.ztsh.wymiana.validation.ValidationFailedException;
+import eu.ztsh.wymiana.web.model.UserCreateRequest;
+import eu.ztsh.wymiana.web.model.UserResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import jakarta.validation.ValidationException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RequiredArgsConstructor
+@Validated
+@RestController
+@RequestMapping(path = "/api/user", produces = "application/json")
+@Tag(name="User management", description = "Create or get user")
+public class UserController {
+
+    private final UserService userService;
+
+    @Operation(summary = "Get user by PESEL")
+    @ApiResponses(value = {
+        @ApiResponse(responseCode = "200", description = "User found"),
+        @ApiResponse(responseCode = "400", description = "Request not valid", content = @Content),
+        @ApiResponse(responseCode = "404", description = "User not found", content = @Content),
+        @ApiResponse(responseCode = "500", description = "Another error has occurred", content = @Content)
+    })
+    @GetMapping("{pesel}")
+    public ResponseEntity<UserResponse> get(@PathVariable("pesel") String pesel) {
+        try {
+            return userService.get(pesel)
+                .map(UserMapper::pojoToResponse)
+                .map(ResponseEntity::ok)
+                .orElseThrow(() -> new UserNotFoundException(pesel));
+        } catch (Exception e) {
+            return ResponseEntity.status(switch (e) {
+                case ValidationException ignore -> 400;
+                case UserNotFoundException ignore -> 404;
+                default -> 500;
+            }).build();
+        }
+    }
+
+    @Operation(summary = "Create user")
+    @ApiResponses(value = {
+        @ApiResponse(responseCode = "204", description = "User created", content = @Content),
+        @ApiResponse(responseCode = "400", description = "Request not valid", content = @Content(mediaType = MediaType.TEXT_PLAIN_VALUE)),
+        @ApiResponse(responseCode = "409", description = "User already exists", content = @Content(mediaType = MediaType.TEXT_PLAIN_VALUE)),
+        @ApiResponse(responseCode = "500", description = "Another error has occurred", content = @Content(mediaType = MediaType.TEXT_PLAIN_VALUE))
+    })
+    @PostMapping
+    public ResponseEntity<String> create(@Valid @RequestBody UserCreateRequest request) {
+        try {
+            userService.create(request);
+        } catch (Exception e) {
+            var status = switch (e) {
+                case ValidationFailedException ignored -> HttpStatus.BAD_REQUEST;
+                case UserAlreadyExistsException ignored -> HttpStatus.CONFLICT;
+                default -> HttpStatus.INTERNAL_SERVER_ERROR;
+            };
+            return ResponseEntity.status(status).body(e.getMessage());
+        }
+        return ResponseEntity.status(204).build();
+    }
+
+}

src/main/java/eu/ztsh/wymiana/web/model/CurrencyExchangeRequest.java

@@ -1,18 +1,22 @@
 package eu.ztsh.wymiana.web.model;
 
+import eu.ztsh.wymiana.model.Symbol;
 import eu.ztsh.wymiana.validation.ValidExchangeRequest;
+import jakarta.validation.constraints.Min;
 import jakarta.validation.constraints.NotNull;
 import lombok.Builder;
 import org.hibernate.validator.constraints.pl.PESEL;
 
+import java.math.BigDecimal;
+
 @Builder
 @ValidExchangeRequest
 public record CurrencyExchangeRequest(
-    @PESEL String pesel,
-    @NotNull String from,
-    @NotNull String to,
-    Double toBuy,
-    Double toSell
+    @NotNull @PESEL String pesel,
+    @NotNull Symbol from,
+    @NotNull Symbol to,
+    @Min(0) BigDecimal toBuy,
+    @Min(0) BigDecimal toSell
 ) {
 
 }

src/main/java/eu/ztsh/wymiana/web/model/UserCreateRequest.java

@@ -4,12 +4,15 @@ import eu.ztsh.wymiana.validation.Adult;
 import jakarta.validation.constraints.Min;
 import jakarta.validation.constraints.NotNull;
 import lombok.Builder;
+import org.hibernate.validator.constraints.pl.PESEL;
+
+import java.math.BigDecimal;
 
 @Builder
 public record UserCreateRequest(
     @NotNull String name,
     @NotNull String surname,
-    @Adult String pesel,
-    @Min(0) double pln) {
+    @PESEL @Adult @NotNull String pesel,
+    @NotNull @Min(0) BigDecimal initial) {
 
 }

src/main/java/eu/ztsh/wymiana/web/model/UserResponse.java

@@ -0,0 +1,9 @@
+package eu.ztsh.wymiana.web.model;
+
+import eu.ztsh.wymiana.model.Currency;
+
+import java.util.List;
+
+public record UserResponse(String name, String surname, String pesel, List<Currency> currencies) {
+
+}

src/main/resources/application.yaml

@@ -2,6 +2,11 @@ hsqldb:
   name: db
   port: 9090
 
+nbp:
+  baseurl: "http://api.nbp.pl"
+currency:
+  initial: PLN
+
 spring:
   datasource:
     username: sa
@@ -11,3 +16,15 @@ spring:
   jpa:
     hibernate:
       ddl-auto: create
+  jackson:
+    mapper:
+      ACCEPT_CASE_INSENSITIVE_ENUMS: true
+
+management:
+  endpoints:
+    jmx:
+      exposure:
+        exclude: '*'
+    web:
+      exposure:
+        include: health

src/test/java/eu/ztsh/wymiana/EntityCreator.java

@@ -2,13 +2,20 @@ package eu.ztsh.wymiana;
 
 import eu.ztsh.wymiana.data.entity.CurrencyEntity;
 import eu.ztsh.wymiana.data.entity.UserEntity;
+import eu.ztsh.wymiana.model.Currency;
 import eu.ztsh.wymiana.model.Rate;
 import eu.ztsh.wymiana.model.Rates;
+import eu.ztsh.wymiana.model.Symbol;
+import eu.ztsh.wymiana.model.User;
 import eu.ztsh.wymiana.web.model.CurrencyExchangeRequest;
 import eu.ztsh.wymiana.web.model.UserCreateRequest;
 
+import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 
 public class EntityCreator {
@@ -16,27 +23,46 @@ public class EntityCreator {
     public static class Constants {
 
         public static String PESEL = "00281018264";
+        public static String INVALID_PESEL = PESEL.replace('6', '7');
+        public static String ANOTHER_PESEL = "08280959342";
         public static String NAME = "Janina";
         public static String SURNAME = "Kowalska";
-        public static double PLN = 20.10;
-        public static double USD_SELL = 5.18;
-        public static double USD_BUY = 5.08;
-        public static String PLN_SYMBOL = "PLN";
-        public static String USD_SYMBOL = "USD";
-        public static double BUY_RATE = 3.8804;
-        public static double SELL_RATE = 3.9572;
+        public static BigDecimal PLN = createScaled(20.10, 2);
+        public static BigDecimal USD_SELL = createScaled(5.18, 2);
+        public static BigDecimal USD_BUY = createScaled(5.08, 2);
+        public static BigDecimal BUY_RATE = createScaled(3.8804, 4);
+        public static BigDecimal SELL_RATE = createScaled(3.9572, 4);
 
     }
 
-    public static UserEntityBuilder user() {
+    public static UserEntityBuilder userEntity() {
         return new UserEntityBuilder();
     }
 
+    public static User user() {
+        return user(Constants.PLN, BigDecimal.ZERO);
+    }
+
+    public static User user(BigDecimal pln, BigDecimal usd) {
+        Map<Symbol, Currency> currencies = new HashMap<>();
+        if (pln.signum() > 0) {
+            currencies.put(Symbol.PLN, new Currency(Symbol.PLN, pln));
+        }
+        if (usd.signum() > 0) {
+            currencies.put(Symbol.USD, new Currency(Symbol.USD, usd));
+        }
+        return new User(Constants.NAME, Constants.SURNAME, Constants.PESEL, currencies);
+    }
+
     public static UserCreateRequest.UserCreateRequestBuilder userRequest() {
+        return userRequest(null);
+    }
+
+    public static UserCreateRequest.UserCreateRequestBuilder userRequest(Double initial) {
         return UserCreateRequest.builder().name(Constants.NAME)
             .surname(Constants.SURNAME)
             .pesel(Constants.PESEL)
-            .pln(Constants.PLN);
+            .initial(initial != null ? createScaled(initial, 2) : Constants.PLN);
     }
 
     public static CurrencyExchangeRequest.CurrencyExchangeRequestBuilder exchangeRequest() {
@@ -47,7 +73,7 @@ public class EntityCreator {
         var rates = new Rates();
         rates.setTable("C");
         rates.setCurrency("dolar amerykański");
-        rates.setCode("USD");
+        rates.setCode(Symbol.USD.toString());
         var rate = new Rate();
         rate.setNo("096/C/NBP/2024");
         rate.setEffectiveDate(date);
@@ -62,8 +88,8 @@ public class EntityCreator {
         String name;
         String surname;
         String pesel;
-        double pln = -1;
-        double usd = -1;
+        BigDecimal pln = BigDecimal.valueOf(-1);
+        BigDecimal usd = BigDecimal.valueOf(-1);
 
         public UserEntityBuilder name(String name) {
             this.name = name;
@@ -81,26 +107,34 @@ public class EntityCreator {
         }
 
         public UserEntityBuilder pln(double pln) {
-            this.pln = pln;
+            return this.pln(BigDecimal.valueOf(pln));
+        }
+
+        public UserEntityBuilder pln(BigDecimal pln) {
+            this.pln = pln.setScale(2, RoundingMode.HALF_UP);
             return this;
         }
 
         public UserEntityBuilder usd(double usd) {
-            this.usd = usd;
+            return this.usd(BigDecimal.valueOf(usd));
+        }
+
+        public UserEntityBuilder usd(BigDecimal usd) {
+            this.usd = usd.setScale(2, RoundingMode.HALF_UP);
             return this;
         }
 
         public UserEntity build() {
             var nonnulPesel = Optional.ofNullable(pesel).orElse(Constants.PESEL);
             List<CurrencyEntity> currencies = new ArrayList<>();
-            if (pln > -1) {
-                currencies.add(new CurrencyEntity(nonnulPesel, "PLN", pln));
+            if (pln.signum() > -1) {
+                currencies.add(new CurrencyEntity(nonnulPesel, Symbol.PLN, pln));
             }
-            if (usd > -1) {
-                currencies.add(new CurrencyEntity(nonnulPesel, "USD", usd));
+            if (usd.signum() > -1) {
+                currencies.add(new CurrencyEntity(nonnulPesel, Symbol.USD, usd));
             }
             if (currencies.isEmpty()) {
-                currencies.add(new CurrencyEntity(nonnulPesel, "PLN", Constants.PLN));
+                currencies.add(new CurrencyEntity(nonnulPesel, Symbol.PLN, Constants.PLN));
             }
             return new UserEntity(
                 nonnulPesel,
@@ -112,4 +146,8 @@ public class EntityCreator {
 
     }
 
+    private static BigDecimal createScaled(double input, int scale) {
+        return BigDecimal.valueOf(input).setScale(scale, RoundingMode.HALF_UP);
+    }
+
 }

src/test/java/eu/ztsh/wymiana/RepositoryBasedTest.java

@@ -29,6 +29,7 @@ public abstract class RepositoryBasedTest {
             .isNotEmpty()
             .get()
             .usingRecursiveComparison()
+            .ignoringCollectionOrder()
             .isEqualTo(entity);
     }
 

src/test/java/eu/ztsh/wymiana/data/repository/UserRepositoryTest.java

@@ -18,7 +18,7 @@ class UserRepositoryTest extends RepositoryBasedTest {
     @Transactional
     @DisplayName("Basic insert & get test")
     void basicTest() {
-        var entity = EntityCreator.user().build();
+        var entity = EntityCreator.userEntity().build();
         userRepository.save(entity);
         expect(entity);
     }

src/test/java/eu/ztsh/wymiana/service/CurrencyServiceTest.java

@@ -2,9 +2,11 @@ package eu.ztsh.wymiana.service;
 
 import eu.ztsh.wymiana.EntityCreator;
 import eu.ztsh.wymiana.RepositoryBasedTest;
+import eu.ztsh.wymiana.config.CurrencyProperties;
 import eu.ztsh.wymiana.data.repository.UserRepository;
-import eu.ztsh.wymiana.exception.ExchangeFailedException;
 import eu.ztsh.wymiana.exception.InsufficientFundsException;
+import eu.ztsh.wymiana.exception.UserNotFoundException;
+import eu.ztsh.wymiana.model.Symbol;
 import eu.ztsh.wymiana.validation.InstanceValidator;
 import eu.ztsh.wymiana.validation.ValidationFailedException;
 import jakarta.transaction.Transactional;
@@ -15,6 +17,8 @@ import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.Mockito;
 import org.springframework.beans.factory.annotation.Autowired;
 
+import java.math.BigDecimal;
+import java.util.Objects;
 import java.util.stream.Stream;
 
 import static eu.ztsh.wymiana.EntityCreator.Constants.*;
@@ -26,86 +30,88 @@ class CurrencyServiceTest extends RepositoryBasedTest {
     private final CurrencyService currencyService;
 
     @Autowired
-    public CurrencyServiceTest(UserRepository userRepository, InstanceValidator instanceValidator) {
+    public CurrencyServiceTest(UserRepository userRepository, InstanceValidator instanceValidator,
+                               CurrencyProperties currencyProperties) {
         super(userRepository);
         var nbp = Mockito.mock(NbpService.class);
-        Mockito.when(nbp.getSellRate("USD")).thenReturn(SELL_RATE);
-        Mockito.when(nbp.getBuyRate("USD")).thenReturn(BUY_RATE);
-        currencyService = new CurrencyService(new UserService(userRepository, instanceValidator), nbp, instanceValidator);
+        Mockito.when(nbp.getSellRate(Symbol.USD)).thenReturn(SELL_RATE);
+        Mockito.when(nbp.getBuyRate(Symbol.USD)).thenReturn(BUY_RATE);
+        currencyService = new CurrencyService(new UserService(userRepository, instanceValidator, currencyProperties),
+            nbp, instanceValidator);
     }
 
     @Transactional
     @Test
     void plnToUsdToSellSuccessTest() {
-        var entity = EntityCreator.user().build();
+        var entity = EntityCreator.userEntity().build();
         userRepository.save(entity);
         var result = currencyService.exchange(EntityCreator.exchangeRequest()
-            .from(PLN_SYMBOL)
-            .to(USD_SYMBOL)
+            .from(Symbol.PLN)
+            .to(Symbol.USD)
             .toSell(PLN)
             .build());
         assertThat(result.currencies())
-            .matches(map -> map.get(PLN_SYMBOL).amount() == 0 && map.get(USD_SYMBOL).amount() == USD_BUY);
-        var expected = EntityCreator.user().pln(0).usd(USD_BUY).build();
+            .matches(map -> map.get(Symbol.PLN).amount().signum() == 0 && Objects.equals(map.get(Symbol.USD).amount(), USD_BUY), "USD 5.08");
+        var expected = EntityCreator.userEntity().pln(0).usd(USD_BUY).build();
         expect(expected);
     }
 
     @Transactional
     @Test
     void plnToUsdToBuySuccessTest() {
-        var entity = EntityCreator.user().build();
+        var entity = EntityCreator.userEntity().build();
         userRepository.save(entity);
         var result = currencyService.exchange(EntityCreator.exchangeRequest()
-            .from(PLN_SYMBOL)
-            .to(USD_SYMBOL)
+            .from(Symbol.PLN)
+            .to(Symbol.USD)
             .toBuy(USD_BUY)
             .build());
         assertThat(result.currencies())
-            .matches(map -> map.get(PLN_SYMBOL).amount() == 0 && map.get(USD_SYMBOL).amount() == USD_BUY);
-        var expected = EntityCreator.user().pln(0).usd(USD_BUY).build();
+            .matches(map -> map.get(Symbol.PLN).amount().signum() == 0 && Objects.equals(map.get(Symbol.USD).amount(), USD_BUY));
+        var expected = EntityCreator.userEntity().pln(0).usd(USD_BUY).build();
         expect(expected);
     }
 
     @Transactional
     @Test
     void usdToPlnToSellSuccessTest() {
-        var entity = EntityCreator.user().pln(-1).usd(USD_SELL).build();
+        var entity = EntityCreator.userEntity().pln(-1).usd(USD_SELL).build();
         userRepository.save(entity);
         var result = currencyService.exchange(EntityCreator.exchangeRequest()
-            .from(USD_SYMBOL)
-            .to(PLN_SYMBOL)
+            .from(Symbol.USD)
+            .to(Symbol.PLN)
             .toSell(USD_SELL)
             .build());
         assertThat(result.currencies())
-            .matches(map -> map.get(PLN_SYMBOL).amount() == PLN && map.get(USD_SYMBOL).amount() == 0);
-        var expected = EntityCreator.user().pln(PLN).usd(0).build();
+            .matches(map -> Objects.equals(map.get(Symbol.PLN).amount(), PLN) && map.get(Symbol.USD).amount().signum() == 0, "PLN 20.10");
+        var expected = EntityCreator.userEntity().pln(PLN).usd(0).build();
         expect(expected);
     }
 
     @Transactional
     @Test
     void usdToPlnToBuySuccessTest() {
-        var entity = EntityCreator.user().pln(-1).usd(USD_SELL).build();
+        var entity = EntityCreator.userEntity().pln(-1).usd(USD_SELL).build();
         userRepository.save(entity);
         var result = currencyService.exchange(EntityCreator.exchangeRequest()
-            .from(USD_SYMBOL)
-            .to(PLN_SYMBOL)
+            .from(Symbol.USD)
+            .to(Symbol.PLN)
             .toBuy(PLN)
             .build());
         assertThat(result.currencies())
-            .matches(map -> map.get(PLN_SYMBOL).amount() == PLN && map.get(USD_SYMBOL).amount() == 0);
-        var expected = EntityCreator.user().pln(PLN).usd(0).build();
+            .matches(map -> Objects.equals(map.get(Symbol.PLN).amount(), PLN) && map.get(Symbol.USD).amount().signum() == 0, "PLN 20.10");
+        var expected = EntityCreator.userEntity().pln(PLN).usd(0).build();
         expect(expected);
     }
 
     @Transactional
     @Test
     void usdToPlnNoUsdCurrencyTest() {
-        var entity = EntityCreator.user().build();
+        var entity = EntityCreator.userEntity().build();
         userRepository.save(entity);
         var request = EntityCreator.exchangeRequest()
-            .from(USD_SYMBOL)
-            .to(PLN_SYMBOL)
+            .from(Symbol.USD)
+            .to(Symbol.PLN)
             .toBuy(PLN)
             .build();
         assertThatThrownBy(() -> currencyService.exchange(request))
@@ -115,17 +121,17 @@ class CurrencyServiceTest extends RepositoryBasedTest {
     @Transactional
     @Test
     void doubleExchangeTest() {
-        var initialValue = 100;
-        var entity = EntityCreator.user().pln(initialValue).build();
+        var initialValue = BigDecimal.valueOf(100);
+        var entity = EntityCreator.userEntity().pln(initialValue).build();
         userRepository.save(entity);
-        var result1 = currencyService.exchange(EntityCreator.exchangeRequest()
-            .from(PLN_SYMBOL)
-            .to(USD_SYMBOL)
+        currencyService.exchange(EntityCreator.exchangeRequest()
+            .from(Symbol.PLN)
+            .to(Symbol.USD)
             .toBuy(USD_BUY)
             .build());
-        var result2 = currencyService.exchange(EntityCreator.exchangeRequest()
-            .from(USD_SYMBOL)
-            .to(PLN_SYMBOL)
+        currencyService.exchange(EntityCreator.exchangeRequest()
+            .from(Symbol.USD)
+            .to(Symbol.PLN)
             .toSell(USD_BUY)
             .build());
         var resultOptional = userRepository.findById(entity.getPesel());
@@ -134,18 +140,18 @@ class CurrencyServiceTest extends RepositoryBasedTest {
         var resultEntity = resultOptional.get();
         assertThat(resultEntity.getCurrencies()
             .stream()
-            .filter(c -> c.getSymbol().equalsIgnoreCase("PLN"))
-            .findFirst()).isNotEmpty().get().matches(currencyEntity -> currencyEntity.getAmount() < initialValue);
+            .filter(c -> c.getSymbol().equals(Symbol.PLN))
+            .findFirst()).isNotEmpty().get().matches(currencyEntity -> currencyEntity.getAmount().compareTo(initialValue) < 0);
     }
 
     @Transactional
     @Test
     void insufficientFundsTest() {
-        var entity = EntityCreator.user().build();
+        var entity = EntityCreator.userEntity().build();
         userRepository.save(entity);
         var request = EntityCreator.exchangeRequest()
-            .from(PLN_SYMBOL)
-            .to(USD_SYMBOL)
+            .from(Symbol.PLN)
+            .to(Symbol.USD)
             .toBuy(PLN)
             .build();
         assertThatThrownBy(() -> currencyService.exchange(request))
@@ -158,8 +164,8 @@ class CurrencyServiceTest extends RepositoryBasedTest {
     void invalidPeselTest(String pesel) {
         var entity = EntityCreator.exchangeRequest()
             .pesel(pesel)
-            .from(PLN_SYMBOL)
-            .to(USD_SYMBOL)
+            .from(Symbol.PLN)
+            .to(Symbol.USD)
             .toSell(USD_SELL)
             .build();
         assertThatThrownBy(() -> currencyService.exchange(entity))
@@ -170,19 +176,19 @@ class CurrencyServiceTest extends RepositoryBasedTest {
     @Test
     void notExistingUserTest() {
         var entity = EntityCreator.exchangeRequest()
-            .from(PLN_SYMBOL)
-            .to(USD_SYMBOL)
+            .from(Symbol.PLN)
+            .to(Symbol.USD)
             .toSell(USD_SELL)
             .build();
         assertThatThrownBy(() -> currencyService.exchange(entity))
-            .isInstanceOf(ExchangeFailedException.class);
+            .isInstanceOf(UserNotFoundException.class);
     }
 
     @Test
     @DisplayName("Empty 'from' value")
     void emptyFromTest() {
         var entity = EntityCreator.exchangeRequest()
-            .to(USD_SYMBOL)
+            .to(Symbol.USD)
             .toSell(USD_SELL)
             .build();
         assertThatThrownBy(() -> currencyService.exchange(entity))
@@ -194,7 +200,7 @@ class CurrencyServiceTest extends RepositoryBasedTest {
     @DisplayName("Empty 'to' value")
     void emptyToTest() {
         var entity = EntityCreator.exchangeRequest()
-            .from(PLN_SYMBOL)
+            .from(Symbol.PLN)
             .toSell(USD_SELL)
             .build();
         assertThatThrownBy(() -> currencyService.exchange(entity))
@@ -203,7 +209,7 @@ class CurrencyServiceTest extends RepositoryBasedTest {
     }
 
     private static Stream<String> invalidPeselTest() {
-        return Stream.of("INVALID", PESEL.replace('6', '7'));
+        return Stream.of("INVALID", INVALID_PESEL);
     }
 
 }

src/test/java/eu/ztsh/wymiana/service/NbpServiceTest.java

@@ -5,6 +5,7 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import eu.ztsh.wymiana.EntityCreator;
 import eu.ztsh.wymiana.WireMockExtension;
 import eu.ztsh.wymiana.exception.NoDataException;
+import eu.ztsh.wymiana.model.Symbol;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
@@ -79,7 +80,7 @@ class NbpServiceTest {
         var url = "/api/exchangerates/rates/c/usd/%s/".formatted(date);
         WireMockExtension.response(url, 200, new ObjectMapper().writeValueAsString(EntityCreator.rates(date)));
         try {
-            assertThat(nbpService.getSellRate(EntityCreator.Constants.USD_SYMBOL)).isEqualTo(EntityCreator.Constants.SELL_RATE);
+            assertThat(nbpService.getSellRate(Symbol.USD)).isEqualTo(EntityCreator.Constants.SELL_RATE);
         } finally {
             WireMockExtension.verifyGet(1, url);
         }
@@ -92,9 +93,9 @@ class NbpServiceTest {
         var url = "/api/exchangerates/rates/c/usd/%s/".formatted(date);
         WireMockExtension.response(url, 200, new ObjectMapper().writeValueAsString(EntityCreator.rates(date)));
         // save to cache
-        assertThat(nbpService.getSellRate(EntityCreator.Constants.USD_SYMBOL)).isEqualTo(EntityCreator.Constants.SELL_RATE);
+        assertThat(nbpService.getSellRate(Symbol.USD)).isEqualTo(EntityCreator.Constants.SELL_RATE);
         // get from cache
-        assertThat(nbpService.getBuyRate(EntityCreator.Constants.USD_SYMBOL)).isEqualTo(EntityCreator.Constants.BUY_RATE);
+        assertThat(nbpService.getBuyRate(Symbol.USD)).isEqualTo(EntityCreator.Constants.BUY_RATE);
         WireMockExtension.verifyGet(1, url);
     }
 
@@ -102,9 +103,9 @@ class NbpServiceTest {
     @Test
     void getInvalidCurrencyTest() {
         var date = dtf.format(updateClock(DayOfWeek.FRIDAY));
-        var url = "/api/exchangerates/rates/c/usb/%s/".formatted(date);
+        var url = "/api/exchangerates/rates/c/usd/%s/".formatted(date);
         WireMockExtension.response(url, 404, "404 NotFound - Not Found - Brak danych");
-        assertThatThrownBy(() -> nbpService.getSellRate("usb")).isInstanceOf(NoDataException.class);
+        assertThatThrownBy(() -> nbpService.getSellRate(Symbol.USD)).isInstanceOf(NoDataException.class);
         WireMockExtension.verifyGet(1, url);
     }
 

src/test/java/eu/ztsh/wymiana/service/UserServiceTest.java

@@ -2,6 +2,7 @@ package eu.ztsh.wymiana.service;
 
 import eu.ztsh.wymiana.EntityCreator;
 import eu.ztsh.wymiana.RepositoryBasedTest;
+import eu.ztsh.wymiana.config.CurrencyProperties;
 import eu.ztsh.wymiana.data.repository.UserRepository;
 import eu.ztsh.wymiana.exception.UserAlreadyExistsException;
 import eu.ztsh.wymiana.util.UserMapper;
@@ -21,9 +22,10 @@ class UserServiceTest extends RepositoryBasedTest {
     private final UserService userService;
 
     @Autowired
-    public UserServiceTest(UserRepository userRepository, InstanceValidator instanceValidator) {
+    public UserServiceTest(UserRepository userRepository, InstanceValidator instanceValidator,
+                           CurrencyProperties currencyProperties) {
         super(userRepository);
-        userService = new UserService(userRepository, instanceValidator);
+        userService = new UserService(userRepository, instanceValidator, currencyProperties);
     }
 
     @Test
@@ -31,7 +33,7 @@ class UserServiceTest extends RepositoryBasedTest {
     @DisplayName("Create new user")
     void createNewUserTest() {
         userService.create(EntityCreator.userRequest().build());
-        var entity = EntityCreator.user().build();
+        var entity = EntityCreator.userEntity().build();
         expect(entity);
     }
 
@@ -42,47 +44,46 @@ class UserServiceTest extends RepositoryBasedTest {
         var second = EntityCreator.userRequest().build();
         userService.create(first);
         assertThatThrownBy(() -> userService.create(second))
-                .isInstanceOf(UserAlreadyExistsException.class)
-                .hasMessage("User with PESEL %s already exists".formatted(EntityCreator.Constants.PESEL));
+            .isInstanceOf(UserAlreadyExistsException.class)
+            .hasMessage("User with PESEL %s already exists".formatted(EntityCreator.Constants.PESEL));
     }
 
     @Test
     @DisplayName("Try to create another user with same PESEL")
     void createDuplicatedPeselTest() {
         var first = EntityCreator.userRequest().build();
-        var second = EntityCreator.userRequest()
-                .name("Jan")
-                .surname("Kowalski")
-                .pln(30.30)
-                .build();
+        var second = EntityCreator.userRequest(30.30)
+            .name("Jan")
+            .surname("Kowalski")
+            .build();
         userService.create(first);
         assertThatThrownBy(() -> userService.create(second))
-                .isInstanceOf(UserAlreadyExistsException.class)
-                .hasMessage("User with PESEL %s already exists".formatted(EntityCreator.Constants.PESEL));
+            .isInstanceOf(UserAlreadyExistsException.class)
+            .hasMessage("User with PESEL %s already exists".formatted(EntityCreator.Constants.PESEL));
     }
 
     @Test
     @DisplayName("Try to create too young user")
     void youngUserTest() {
-        var request = EntityCreator.userRequest().pesel("08280959342").build();
+        var request = EntityCreator.userRequest().pesel("").build();
         assertThatThrownBy(() -> userService.create(request))
-                .isInstanceOf(ValidationFailedException.class)
-                .hasMessageContaining(Adult.MESSAGE);
+            .isInstanceOf(ValidationFailedException.class)
+            .hasMessageContaining(Adult.MESSAGE);
     }
 
     @Test
     @Transactional
     @DisplayName("Get existing user")
     void getExistingUserTest() {
-        var entity = EntityCreator.user().build();
+        var entity = EntityCreator.userEntity().build();
         userRepository.save(entity);
         var userOptional = userService.get(EntityCreator.Constants.PESEL);
         var expected = UserMapper.entityToPojo(entity);
         assertThat(userOptional)
-                .isNotEmpty()
-                .get()
-                .usingRecursiveComparison()
-                .isEqualTo(expected);
+            .isNotEmpty()
+            .get()
+            .usingRecursiveComparison()
+            .isEqualTo(expected);
     }
 
     @Test

src/test/java/eu/ztsh/wymiana/util/UserMapperTest.java

@@ -1,25 +1,18 @@
 package eu.ztsh.wymiana.util;
 
 import eu.ztsh.wymiana.EntityCreator;
-import eu.ztsh.wymiana.model.Currency;
-import eu.ztsh.wymiana.model.User;
+import eu.ztsh.wymiana.model.Symbol;
+import eu.ztsh.wymiana.model.UserCreateRequestConfiguredWrapper;
 import org.junit.jupiter.api.Test;
 
-import java.util.Map;
-
 import static org.assertj.core.api.Assertions.assertThat;
 
 class UserMapperTest {
 
     @Test
     void entityToPojoTest() {
-        var entity = EntityCreator.user().build();
-        var expected = new User(
-            EntityCreator.Constants.NAME,
-            EntityCreator.Constants.SURNAME,
-            EntityCreator.Constants.PESEL,
-            Map.of("PLN", new Currency("PLN", EntityCreator.Constants.PLN))
-        );
+        var entity = EntityCreator.userEntity().build();
+        var expected = EntityCreator.user();
         assertThat(UserMapper.entityToPojo(entity))
             .usingRecursiveComparison()
             .isEqualTo(expected);
@@ -27,13 +20,8 @@ class UserMapperTest {
 
     @Test
     void pojoToEntityTest() {
-        var entity = new User(
-            EntityCreator.Constants.NAME,
-            EntityCreator.Constants.SURNAME,
-            EntityCreator.Constants.PESEL,
-            Map.of("PLN", new Currency("PLN", EntityCreator.Constants.PLN))
-        );
-        var expected = EntityCreator.user().build();
+        var entity = EntityCreator.user();
+        var expected = EntityCreator.userEntity().build();
         assertThat(UserMapper.pojoToEntity(entity))
             .usingRecursiveComparison()
             .isEqualTo(expected);
@@ -41,8 +29,10 @@ class UserMapperTest {
 
     @Test
     void requestToEntityTest() {
-        var request = EntityCreator.userRequest().build();
-        var expected = EntityCreator.user().build();
+        var request = UserCreateRequestConfiguredWrapper.wrap(EntityCreator.userRequest().build())
+            .withInitial(Symbol.PLN)
+            .build() ;
+        var expected = EntityCreator.userEntity().build();
         assertThat(UserMapper.requestToEntity(request))
             .usingRecursiveComparison()
             .isEqualTo(expected);

src/test/java/eu/ztsh/wymiana/validation/ValidExchangeRequestValidatorTest.java

@@ -1,14 +1,15 @@
 package eu.ztsh.wymiana.validation;
 
 import eu.ztsh.wymiana.EntityCreator;
+import eu.ztsh.wymiana.model.Symbol;
 import eu.ztsh.wymiana.web.model.CurrencyExchangeRequest;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
-import static eu.ztsh.wymiana.EntityCreator.Constants.PLN_SYMBOL;
+import java.math.BigDecimal;
+
 import static eu.ztsh.wymiana.EntityCreator.Constants.USD_BUY;
 import static eu.ztsh.wymiana.EntityCreator.Constants.USD_SELL;
-import static eu.ztsh.wymiana.EntityCreator.Constants.USD_SYMBOL;
 
 class ValidExchangeRequestValidatorTest extends ValidatorTest<ValidExchangeRequestValidator, CurrencyExchangeRequest> {
 
@@ -20,8 +21,8 @@ class ValidExchangeRequestValidatorTest extends ValidatorTest<ValidExchangeReque
     @DisplayName("Valid request with buy value specified")
     void validRequestWithBuyTest() {
         assertThatValidation(EntityCreator.exchangeRequest()
-            .from(PLN_SYMBOL)
-            .to(USD_SYMBOL)
+            .from(Symbol.PLN)
+            .to(Symbol.USD)
             .toBuy(USD_BUY)
             .build()).isTrue();
     }
@@ -30,8 +31,8 @@ class ValidExchangeRequestValidatorTest extends ValidatorTest<ValidExchangeReque
     @DisplayName("Valid request with sell value specified")
     void validRequestWithSellTest() {
         assertThatValidation(EntityCreator.exchangeRequest()
-            .from(PLN_SYMBOL)
-            .to(USD_SYMBOL)
+            .from(Symbol.PLN)
+            .to(Symbol.USD)
             .toSell(USD_SELL)
             .build()).isTrue();
     }
@@ -40,8 +41,8 @@ class ValidExchangeRequestValidatorTest extends ValidatorTest<ValidExchangeReque
     @DisplayName("From and To have same value")
     void sameFromToTest() {
         assertThatValidation(EntityCreator.exchangeRequest()
-            .from(USD_SYMBOL)
-            .to(USD_SYMBOL)
+            .from(Symbol.USD)
+            .to(Symbol.USD)
             .toSell(USD_SELL)
             .build()).isFalse();
     }
@@ -50,8 +51,8 @@ class ValidExchangeRequestValidatorTest extends ValidatorTest<ValidExchangeReque
     @DisplayName("Empty amounts")
     void emptyBuySellTest() {
         assertThatValidation(EntityCreator.exchangeRequest()
-            .from(PLN_SYMBOL)
-            .to(USD_SYMBOL)
+            .from(Symbol.PLN)
+            .to(Symbol.USD)
             .build()).isFalse();
     }
 
@@ -59,8 +60,8 @@ class ValidExchangeRequestValidatorTest extends ValidatorTest<ValidExchangeReque
     @DisplayName("Both Buy and Sell params filled in")
     void bothFilledBuySellTest() {
         assertThatValidation(EntityCreator.exchangeRequest()
-            .from(PLN_SYMBOL)
-            .to(USD_SYMBOL)
+            .from(Symbol.PLN)
+            .to(Symbol.USD)
             .toBuy(USD_BUY)
             .toSell(USD_SELL)
             .build()).isFalse();
@@ -70,9 +71,9 @@ class ValidExchangeRequestValidatorTest extends ValidatorTest<ValidExchangeReque
     @DisplayName("Negative buy amount value")
     void negativeBuyAmountTest() {
         assertThatValidation(EntityCreator.exchangeRequest()
-            .from(PLN_SYMBOL)
-            .to(USD_SYMBOL)
-            .toBuy(-1.0)
+            .from(Symbol.PLN)
+            .to(Symbol.USD)
+            .toBuy(BigDecimal.valueOf(-1.0))
             .build()).isFalse();
     }
 
@@ -80,9 +81,9 @@ class ValidExchangeRequestValidatorTest extends ValidatorTest<ValidExchangeReque
     @DisplayName("Negative sell amount value")
     void negativeSellAmountTest() {
         assertThatValidation(EntityCreator.exchangeRequest()
-            .from(PLN_SYMBOL)
-            .to(USD_SYMBOL)
-            .toSell(-1.0)
+            .from(Symbol.PLN)
+            .to(Symbol.USD)
+            .toSell(BigDecimal.valueOf(-1.0))
             .build()).isFalse();
     }
 

src/test/java/eu/ztsh/wymiana/web/ApplicationIntegrationTests.java

@@ -0,0 +1,264 @@
+package eu.ztsh.wymiana.web;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import eu.ztsh.wymiana.EntityCreator;
+import eu.ztsh.wymiana.WireMockExtension;
+import eu.ztsh.wymiana.model.Symbol;
+import eu.ztsh.wymiana.util.UserMapper;
+import org.junit.jupiter.api.ClassOrderer;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestClassOrder;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.reactive.server.WebTestClient;
+
+import java.math.BigDecimal;
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.TemporalAdjusters;
+
+import static eu.ztsh.wymiana.EntityCreator.Constants.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration test suite.
+ * Contrary to the principle of test independence, tests are dependent on one another to create continuous suite.
+ */
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@ActiveProfiles("it")
+@ExtendWith(WireMockExtension.class)
+@TestMethodOrder(MethodOrderer.DisplayName.class)
+@TestClassOrder(ClassOrderer.DisplayName.class)
+class ApplicationIntegrationTests {
+
+    private final WebTestClient webTestClient;
+    private final ObjectMapper objectMapper;
+
+    @Autowired
+    public ApplicationIntegrationTests(WebTestClient webTestClient) {
+        this.webTestClient = webTestClient;
+        objectMapper = new ObjectMapper();
+    }
+
+    private String asJson(Object object) {
+        try {
+            return objectMapper.writeValueAsString(object);
+        } catch (JsonProcessingException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+    @Nested
+    @TestMethodOrder(MethodOrderer.DisplayName.class)
+    @DisplayName("01: Context")
+    class ContextTests {
+
+        @Test
+        @DisplayName("01.1: Load context")
+        void contextLoads() {
+            assertThat(webTestClient).isNotNull();
+            webTestClient.get().uri("/actuator/health").exchange().expectBody().json("{\"status\":\"UP\"}");
+        }
+
+    }
+
+    @Nested
+    @TestMethodOrder(MethodOrderer.DisplayName.class)
+    @DisplayName("02: User")
+    class UserTests {
+
+        private static final String endpoint = "/api/user";
+
+        @Test
+        @DisplayName("02.1: Create valid user")
+        void createUserTest() {
+            webTestClient.post()
+                .uri(endpoint)
+                .bodyValue(EntityCreator.userRequest(100D).build())
+                .exchange()
+                .expectStatus().isNoContent();
+        }
+
+        @Test
+        @DisplayName("02.2: Try to create invalid user")
+        void createInvalidUserTest() {
+            webTestClient.post()
+                .uri(endpoint)
+                .bodyValue(EntityCreator.userRequest().pesel(INVALID_PESEL).build())
+                .exchange()
+                .expectStatus()
+                .isBadRequest();
+        }
+
+        @Test
+        @DisplayName("02.3: Try to create duplicated user")
+        void createDuplicatedUserTest() {
+            webTestClient.post()
+                .uri(endpoint)
+                .bodyValue(EntityCreator.userRequest().build())
+                .exchange()
+                .expectStatus().isEqualTo(409)
+                .expectBody(String.class).isEqualTo("User with PESEL %s already exists".formatted(PESEL));
+        }
+
+        @Test
+        @DisplayName("02.4: Get valid user")
+        void getValidUserTest() {
+            webTestClient.get()
+                .uri(endpoint.concat("/").concat(PESEL))
+                .exchange()
+                .expectStatus().isOk()
+                .expectBody().json(asJson(UserMapper.pojoToResponse(UserMapper.entityToPojo(EntityCreator.userEntity().pln(100).build()))));
+        }
+
+        @Test
+        @DisplayName("02.5: Try to get non-existing user")
+        void getNonExistingUserTest() {
+            webTestClient.get()
+                .uri(endpoint.concat("/").concat(ANOTHER_PESEL))
+                .exchange()
+                .expectStatus().isNotFound();
+        }
+
+        @Test
+        @DisplayName("02.6: Get user by incorrect PESEL")
+        void getIncorrectPeselUserTest() {
+            webTestClient.get()
+                .uri(endpoint.concat("/").concat(INVALID_PESEL))
+                .exchange()
+                .expectStatus().isBadRequest();
+        }
+
+    }
+
+    @Nested
+    @TestMethodOrder(MethodOrderer.DisplayName.class)
+    @DisplayName("03: Exchange")
+    class ExchangeTests {
+
+        private static final String URI_PATTERN = "/api/exchangerates/rates/c/usd/%s/";
+        private final DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+        private static final String endpoint = "/api/exchange";
+
+        @Test
+        @DisplayName("03.1: Try to perform invalid money exchange: no data")
+        void noNbpDataTest() {
+            webTestClient.post()
+                .uri(endpoint)
+                .bodyValue(EntityCreator.exchangeRequest()
+                    .from(Symbol.PLN)
+                    .to(Symbol.USD)
+                    .toSell(PLN)
+                    .build())
+                .exchange()
+                .expectStatus().isEqualTo(500);
+        }
+
+        @Test
+        @DisplayName("03.2: Perform valid money exchange")
+        void exchangeTest() {
+            var date = getTodayOrLastFriday();
+            WireMockExtension.response(
+                URI_PATTERN.formatted(date),
+                200,
+                asJson(EntityCreator.rates(date))
+            );
+            var expected = asJson(EntityCreator.user(BigDecimal.valueOf(100).subtract(PLN), USD_BUY));
+            webTestClient.post()
+                .uri(endpoint)
+                .bodyValue(EntityCreator.exchangeRequest()
+                    .from(Symbol.PLN)
+                    .to(Symbol.USD)
+                    .toSell(PLN)
+                    .build())
+                .exchange()
+                .expectStatus().isOk()
+                .expectBody().json(expected);
+            WireMockExtension.verifyGet(1, URI_PATTERN.formatted(date));
+        }
+
+        @Test
+        @DisplayName("03.3: Try to perform invalid money exchange: not existing user")
+        void exchangeNotExistingUserTest() {
+            webTestClient.post()
+                .uri(endpoint)
+                .bodyValue(EntityCreator.exchangeRequest()
+                    .pesel(ANOTHER_PESEL)
+                    .from(Symbol.PLN)
+                    .to(Symbol.USD)
+                    .toSell(PLN)
+                    .build())
+                .exchange()
+                .expectStatus().isNotFound()
+                .expectBody(String.class).isEqualTo("User with PESEL %s not found".formatted(ANOTHER_PESEL));
+        }
+
+        @Test
+        @DisplayName("03.4: Try to perform invalid money exchange: invalid PESEL")
+        void invalidPeselTest() {
+            webTestClient.post()
+                .uri(endpoint)
+                .bodyValue(EntityCreator.exchangeRequest()
+                    .pesel(INVALID_PESEL)
+                    .from(Symbol.PLN)
+                    .to(Symbol.USD)
+                    .toSell(PLN)
+                    .build())
+                .exchange()
+                .expectStatus().isBadRequest();
+        }
+
+        @Test
+        @DisplayName("03.5: Try to perform invalid money exchange: insufficient funds")
+        void insufficientFundsTest() {
+            webTestClient.post()
+                .uri(endpoint)
+                .bodyValue(EntityCreator.exchangeRequest()
+                    .from(Symbol.USD)
+                    .to(Symbol.PLN)
+                    .toBuy(PLN)
+                    .build())
+                .exchange()
+                .expectStatus().isBadRequest();
+        }
+
+        @Test
+        @DisplayName("03.6: Perform valid money exchange with lower case currency symbols")
+        void ignoreCaseTest() {
+            var date = getTodayOrLastFriday();
+            var expected = asJson(EntityCreator.user(BigDecimal.valueOf(100).subtract(PLN.multiply(BigDecimal.TWO)), USD_BUY.multiply(BigDecimal.TWO)));
+            webTestClient.post()
+                .uri(endpoint)
+                .header("Content-Type", "application/json")
+                .bodyValue(asJson(EntityCreator.exchangeRequest()
+                    .from(Symbol.PLN)
+                    .to(Symbol.USD)
+                    .toSell(PLN)
+                    .build()).replace("USD", "usd").replace("PLN", "pln"))
+                .exchange()
+                .expectStatus().isOk()
+                .expectBody().json(expected);
+            // cache
+            WireMockExtension.verifyGet(0, URI_PATTERN.formatted(date));
+        }
+
+        private String getTodayOrLastFriday() {
+            var today = LocalDate.now();
+            if (today.getDayOfWeek() == DayOfWeek.SATURDAY
+                || today.getDayOfWeek() == DayOfWeek.SUNDAY) {
+                today = today.with(TemporalAdjusters.previous(DayOfWeek.FRIDAY));
+            }
+            return today.format(dtf);
+        }
+
+    }
+
+}

src/test/resources/application-it.yaml

@@ -0,0 +1,2 @@
+nbp:
+  baseurl: "http://localhost:38080"