Fixing NPE in Sdf09ValidationRule, AccountBalanceFreeAmountEnough and fixing error checking the balance in AccountBalanceFreeAmountEnough. Adding test for Sdf09Executor.

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/AccountBalanceFreeAmountEnough.java

@@ -27,6 +27,9 @@ public class AccountBalanceFreeAmountEnough<T extends WithAccount & WithSum> imp
     @Override
     public Optional<EnumMessage> validate(ImdgValidationContext<T> context) {
         T validatedObject = context.getValidatedObject();
+        if (validatedObject.getSum() == null) {
+            return of(BalanceError.BalanceNotEnough);
+        }
         if (validatedObject.getSum().compareTo(BigDecimal.ZERO) >= 0) {
             return empty();
         }
@@ -36,7 +39,7 @@ public class AccountBalanceFreeAmountEnough<T extends WithAccount & WithSum> imp
         if (balance == null) {
             return of(BalanceError.BalanceNotEnough);
         }
-        if (balance.getFreeBalanceAmount().compareTo(validatedObject.getSum()) < 0) {
+        if (balance.getFreeBalanceAmount().compareTo(validatedObject.getSum().abs()) < 0) {
             return of(BalanceError.BalanceNotEnough);
         }
         return empty();

clearing-parent/balance-service/src/main/java/ru/spcex/clearing/balance/validation/Sdf09ValidationRule.java

@@ -1,6 +1,5 @@
 package ru.spcex.clearing.balance.validation;
 
-import org.slf4j.LoggerFactory;
 import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.company.Company;
 import ru.clearing.classes.statics.data.company.CompanySymbols;
@@ -26,7 +25,7 @@ public enum Sdf09ValidationRule implements IValidationRule<ImdgValidationContext
             Imdg<CompanySymbols> companySymbolImdg = context.obtainMap(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
             Imdg<Company> companyImdg = context.obtainMap(IMDGDistributedNames.Map_Company, Company.class);
             if (sdf09.getInn() == null) {
-                return of( BalanceError.CompanyNotFound, "empty inn");
+                return of(BalanceError.CompanyNotFound, "empty inn");
             }
             String innStr = sdf09.getInn().setScale(0, RoundingMode.DOWN).toString();
             CompanySymbols symbol = companySymbolImdg
@@ -37,7 +36,7 @@ public enum Sdf09ValidationRule implements IValidationRule<ImdgValidationContext
                 company = companyImdg.getSingleObjectByID(symbol.getCompanyId());
             }
             if (company == null) {
-                return of( BalanceError.CompanyNotFound);
+                return of(BalanceError.CompanyNotFound);
             }
             context.storeObject(ValidationStored.Company, company);
             return empty();
@@ -47,6 +46,9 @@ public enum Sdf09ValidationRule implements IValidationRule<ImdgValidationContext
         @Override
         public Optional<EnumMessage> validate(ImdgValidationContext<SDf09> context) {
             SDf09 sdf09 = context.getValidatedObject();
+            if (sdf09.getAccount() == null) {
+                return of(BalanceError.AccountNotPresent);
+            }
             Imdg<Account> accountImdg = context.obtainMap(IMDGDistributedNames.Map_Account, Account.class);
             Account account = accountImdg.getSingleObjectByFieldValues(Map.of("account", sdf09.getAccount(),
                     "accountType", AccountType.Clrn.getKey()));

clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/service/AbstractServiceTest.java

@@ -9,27 +9,30 @@ import org.springframework.test.context.junit.jupiter.SpringExtension;
 import ru.clearing.classes.statics.data.account.Account;
 import ru.clearing.classes.statics.data.account.AccountBalance;
 import ru.clearing.classes.statics.data.company.Company;
-import ru.clearing.classes.statics.data.sdf.SDf01;
+import ru.clearing.classes.statics.data.company.CompanySymbols;
 import ru.clearing.classes.statics.data.sdf.SDf02;
+import ru.clearing.classes.statics.data.sdf.SDf10;
 import ru.clearing.classes.statics.data.statement.Statement;
 import ru.spcex.clearing.balance.config.*;
+import ru.spcex.clearing.balance.utils.MatcherFactory;
 import ru.spcex.clearing.imdg.IMDGDistributedNames;
 import ru.spcex.platform.enumeration.*;
 import ru.spcex.platform.imdg.api.ImdgProvider;
 import ru.spcex.platform.imdg.iml.hazelcast.adapter.ImdgHazelcast;
-import ru.spcex.platform.utils.number.BigDecimalUtil;
 
 import javax.annotation.PostConstruct;
 import java.math.BigDecimal;
-import java.time.Instant;
+import java.math.RoundingMode;
-import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
 import java.util.concurrent.atomic.AtomicLong;
 
+import static ru.spcex.clearing.balance.utils.MatcherFactory.usingIgnoringFieldsComparator;
+
 @ExtendWith(SpringExtension.class)
 @ContextConfiguration(classes = {
         AccountBalanceService.class,
         Sdf01Executor.class,
+        Sdf09Executor.class,
         LoggingService.class,
         MessagesConfig.class,
         ValidationConfig.class,
@@ -37,19 +40,25 @@ import java.util.concurrent.atomic.AtomicLong;
         KafkaSenderConfig.class,
         KafkaTestConfig.class})
 public abstract class AbstractServiceTest {
+    protected static final MatcherFactory.Matcher<AccountBalance> ACCOUNT_BALANCE_MATCHER = usingIgnoringFieldsComparator("created", "updated", "clearingDate", "id");
+    protected static final MatcherFactory.Matcher<Result> RESULT_MATCHER = usingIgnoringFieldsComparator("account.created", "account.updated", "account.clearingDate", "generationId");
+    protected static final MatcherFactory.Matcher<Statement> STATEMENT_MATCHER = usingIgnoringFieldsComparator("created", "comment", "outSDfId", "updated", "id");
+
     protected final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
-    protected final Long accountIdNew = 1L;
+    protected final Long accountIdNew = 10L;
     protected final Long addresseeIdNew = 2L;
     protected final String deal = "111111111";
-    protected final String acc = "123456789";
+    protected final BigDecimal inn = new BigDecimal(987654321);
     protected final BigDecimal amountNew = new BigDecimal(1000);
     protected final String cashMovementCurrencyCode = CurrencyCode.RUB.getKey();
 
     protected AtomicLong currentId = new AtomicLong(0L);
     protected IMap<Long, Company> companyMap;
+    protected IMap<Long, CompanySymbols> companySymbolsMap;
     protected IMap<Long, Account> accountMap;
     protected ImdgHazelcast<Statement> statementImdg;
     protected ImdgHazelcast<SDf02> sdf02Imdg;
+    protected ImdgHazelcast<SDf10> sdf10Imdg;
     protected ImdgHazelcast<AccountBalance> accountBalanceImdg;
     @Autowired
     @Qualifier("hazelcastServiceTest")
@@ -59,11 +68,14 @@ public abstract class AbstractServiceTest {
     void init() {
         hazelcast.waitAvailable();
         ImdgHazelcast<Company> companyImdg = (ImdgHazelcast<Company>) hazelcast.getImdg(IMDGDistributedNames.Map_Company, Company.class);
+        ImdgHazelcast<CompanySymbols> companySymbolsImdg = (ImdgHazelcast<CompanySymbols>) hazelcast.getImdg(IMDGDistributedNames.Map_CompanySymbols, CompanySymbols.class);
         ImdgHazelcast<Account> accountImdg = (ImdgHazelcast<Account>) hazelcast.getImdg(IMDGDistributedNames.Map_Account, Account.class);
         statementImdg = (ImdgHazelcast<Statement>) hazelcast.getImdg(IMDGDistributedNames.Map_Statement, Statement.class);
         sdf02Imdg = (ImdgHazelcast<SDf02>) hazelcast.getImdg(IMDGDistributedNames.Map_SDf02, SDf02.class);
+        sdf10Imdg = (ImdgHazelcast<SDf10>) hazelcast.getImdg(IMDGDistributedNames.Map_SDf10, SDf10.class);
         accountBalanceImdg = (ImdgHazelcast<AccountBalance>) hazelcast.getImdg(IMDGDistributedNames.Map_AccountBalance, AccountBalance.class);
         companyMap = companyImdg.getMap();
+        companySymbolsMap = companySymbolsImdg.getMap();
         accountMap = accountImdg.getMap();
     }
 
@@ -76,7 +88,16 @@ public abstract class AbstractServiceTest {
         return company;
     }
 
-    protected Account getTestAccount(Long id) {
+    protected CompanySymbols getTestCompanySymbols() {
+        CompanySymbols companySymbols = new CompanySymbols();
+        companySymbols.setId(addresseeIdNew);
+        companySymbols.setCompanySymbol(CompanySymbol.INN.getKey());
+        companySymbols.setCompanySymbolValue(inn.setScale(0, RoundingMode.DOWN).toString());
+        companySymbols.setCompanyId(addresseeIdNew);
+        return companySymbols;
+    }
+
+    protected Account getTestAccount(Long id, String acc) {
         Account account = new Account();
         account.setId(id);
         account.setAccount(acc);
@@ -86,41 +107,25 @@ public abstract class AbstractServiceTest {
     }
 
     protected AccountResult getTestAccountResult(Long id, Account account, Company company) {
-        AccountBalance accountBalanceNew = new AccountBalance();
+        AccountBalance accountBalanceNew = getTestAccountBalance(id, account, company);
-        accountBalanceNew.setId(id);
-        accountBalanceNew.setCompanyId(addresseeIdNew);
-        accountBalanceNew.setAccountId(account.getId());
-        accountBalanceNew.setAccountType(account.getAccountType());
-        accountBalanceNew.setAccount(account.getAccount());
-        accountBalanceNew.setOpenBalanceAmount(amountNew);
-        accountBalanceNew.setFreeBalanceAmount(amountNew);
-        accountBalanceNew.setBalanceAmount(amountNew);
-        accountBalanceNew.setBalanceAccountType(BalanceAccountType.Active.getKey());
-        accountBalanceNew.setCurrencyCode(cashMovementCurrencyCode);
-        accountBalanceNew.setTradingCode(company.getTradingCode());
-        accountBalanceNew.setShortName(company.getShortName());
-        accountBalanceNew.setFullName(company.getFullName());
         return new AccountResult(accountBalanceNew);
     }
 
-    protected Statement getTestStatement(Long id, Company company, Account account, SDf01 sdf01) {
+    protected AccountBalance getTestAccountBalance(Long id, Account account, Company company) {
-        Statement statement = new Statement();
+        AccountBalance accountBalance = new AccountBalance();
-        statement.setId(id);
+        accountBalance.setId(id);
-        statement.setAddresseeId(company.getId());
+        accountBalance.setCompanyId(addresseeIdNew);
-        statement.setSenderId(Sender.Prc.getId());
+        accountBalance.setAccountId(account.getId());
-        statement.setCreated(Instant.now());
+        accountBalance.setAccountType(account.getAccountType());
-        statement.setClearingDate(LocalDate.now());
+        accountBalance.setAccount(account.getAccount());
-        statement.setStatementType(StatementType.full.getKey());
+        accountBalance.setOpenBalanceAmount(amountNew);
-        statement.setAccountId(account.getId());
+        accountBalance.setFreeBalanceAmount(amountNew);
-        statement.setAccount(sdf01.getAccount());
+        accountBalance.setBalanceAmount(amountNew);
-        statement.setInOutDirection(InOutDirection.in.getKey());
+        accountBalance.setBalanceAccountType(BalanceAccountType.Active.getKey());
-        statement.setSettlementDate(LocalDate.parse(sdf01.getDat(), datFormatter));
+        accountBalance.setCurrencyCode(cashMovementCurrencyCode);
-        statement.setAmount(BigDecimalUtil.parse(sdf01.getRemainder()));
+        accountBalance.setTradingCode(company.getTradingCode());
-        statement.setCashMovementCurrencyCode(cashMovementCurrencyCode);
+        accountBalance.setShortName(company.getShortName());
-        statement.setOperationStatus(OperationStatus.Pending.getKey());
+        accountBalance.setFullName(company.getFullName());
-        statement.setInSDfId(sdf01.getId());
+        return accountBalance;
-        statement.setInOutSDfType(InOutSDfType.type1.getKey());
-        return statement;
     }
-
 }

clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/service/AccountBalanceServiceTest.java

@@ -25,6 +25,7 @@ class AccountBalanceServiceTest extends AbstractServiceTest {
     private final Long addresseeIdUpdate = addresseeIdNew;
     private final BigDecimal amountUpdate = new BigDecimal(100000);
     private final String cashMovementCurrencyCodeUpdate = "cash";
+    private final String acc = "0123456789";
     @Autowired
     AccountBalanceService accountBalanceService;
 
@@ -41,7 +42,7 @@ class AccountBalanceServiceTest extends AbstractServiceTest {
     void createAccountBalance() {
         Company company = getTestCompany();
         companyMap.put(addresseeIdNew, company);
-        Account account = getTestAccount(accountIdNew);
+        Account account = getTestAccount(accountIdNew, acc);
         accountMap.put(accountIdNew, account);
 
         AccountResult predictableNewResult = getTestAccountResult(accountIdNew, account, company);

clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/service/Sdf01ExecutorTest.java

@@ -12,10 +12,9 @@ import ru.spcex.clearing.balance.errors.BalanceError;
 import ru.spcex.clearing.balance.utils.MatcherFactory;
 import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
 import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
-import ru.spcex.platform.enumeration.AccountType;
+import ru.spcex.platform.enumeration.*;
-import ru.spcex.platform.enumeration.OperationStatus;
-import ru.spcex.platform.enumeration.Status;
 import ru.spcex.platform.utils.enumeration.EnumMessage;
+import ru.spcex.platform.utils.number.BigDecimalUtil;
 
 import javax.annotation.PostConstruct;
 import java.time.Instant;
@@ -28,14 +27,10 @@ import java.util.Map;
 import static ru.spcex.clearing.balance.utils.MatcherFactory.usingIgnoringFieldsComparator;
 
 class Sdf01ExecutorTest extends AbstractServiceTest {
-
-    private static final MatcherFactory.Matcher<Result> RESULT_MATCHER = usingIgnoringFieldsComparator("account.created", "account.updated", "account.clearingDate", "generationId");
-    private static final MatcherFactory.Matcher<Statement> STATEMENT_MATCHER = usingIgnoringFieldsComparator("created", "comment", "outSDfId");
     private static final MatcherFactory.Matcher<SDf02> SDF_02_MATCHER = usingIgnoringFieldsComparator("created", "comment", "outSDfId", "generationTime", "generationId", "id");
-    private static final MatcherFactory.Matcher<AccountBalance> ACCOUNT_BALANCE_MATCHER = usingIgnoringFieldsComparator("created", "updated", "clearingDate");
-
     private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
-    private final Long id = currentId.getAndIncrement();
+    private final String acc = "123456789";
+    private final Long ID = 1L;
     @Autowired
     Sdf01Executor sdf01Executor;
     private SDf01 sdf01;
@@ -69,14 +64,14 @@ class Sdf01ExecutorTest extends AbstractServiceTest {
         Company company = getTestCompany();
         companyMap.put(addresseeIdNew, company);
 
-        Account account = getTestAccount(id);
+        Account account = getTestAccount(ID, acc);
         accountMap.put(accountIdNew, account);
 
         Result predictableResult = new Result();
-        predictableResult.setGenerationId(id);
+        predictableResult.setGenerationId(ID);
         Statement predictableStatement = getTestStatement(currentId.getAndIncrement(), company, account, sdf01);
         predictableStatement.setOperationStatus(OperationStatus.Executed.getKey());
-        SDf02 predictableSdf02 = getTestSdf02(currentId.getAndIncrement(), sdf01, id);
+        SDf02 predictableSdf02 = getTestSdf02(currentId.getAndIncrement(), sdf01, ID);
         predictableStatement.setOutSDfId(predictableSdf02.getId());
         AccountResult predictableNewResult = getTestAccountResult(currentId.getAndIncrement(), account, company);
 
@@ -137,7 +132,7 @@ class Sdf01ExecutorTest extends AbstractServiceTest {
         checkErrorAccountNotPresent(company);
 
         //CurrencyNotFound sdf01.curr_code =! "RUR"
-        accountMap.put(accountIdNew, getTestAccount(id));
+        accountMap.put(accountIdNew, getTestAccount(ID, acc));
         sdf01.setAccount(acc);
         sdf01.setCurr_code("RUB");
         checkError(new EnumMessage(BalanceError.CurrencyNotFound));
@@ -174,7 +169,7 @@ class Sdf01ExecutorTest extends AbstractServiceTest {
 
     private void checkError(EnumMessage enumMessage) {
 //        SDf01 sdf01 = getTestSdf01();
-        SDf02 predictableSdf02 = getTestErrorSdf02(sdf01, enumMessage, id);
+        SDf02 predictableSdf02 = getTestErrorSdf02(sdf01, enumMessage, ID);
         Result result = sdf01Executor.execute(Collections.singletonList(sdf01), statementRequest);
         Collection<SDf02> resultsSdf02 = sdf02Imdg.getCollectionObjectsByFieldValues(Map.of("account", acc));
         SDf02 resultSdf02 = resultsSdf02.stream().max((entry1, entry2) -> entry1.getId() > entry2.getId() ? 1 : -1).get();
@@ -213,7 +208,7 @@ class Sdf01ExecutorTest extends AbstractServiceTest {
 
     private SDf01 getTestSdf01() {
         SDf01 sdf01 = new SDf01();
-        sdf01.setId(id);
+        sdf01.setId(ID);
         sdf01.setMarket("U");
         sdf01.setDeal(deal);
         sdf01.setAccount(acc);
@@ -224,9 +219,29 @@ class Sdf01ExecutorTest extends AbstractServiceTest {
         return sdf01;
     }
 
+    private Statement getTestStatement(Long id, Company company, Account account, SDf01 sdf01) {
+        Statement statement = new Statement();
+        statement.setId(id);
+        statement.setAddresseeId(company.getId());
+        statement.setSenderId(Sender.Prc.getId());
+        statement.setCreated(Instant.now());
+        statement.setClearingDate(LocalDate.now());
+        statement.setStatementType(StatementType.full.getKey());
+        statement.setAccountId(account.getId());
+        statement.setAccount(sdf01.getAccount());
+        statement.setInOutDirection(InOutDirection.in.getKey());
+        statement.setSettlementDate(LocalDate.parse(sdf01.getDat(), datFormatter));
+        statement.setAmount(BigDecimalUtil.parse(sdf01.getRemainder()));
+        statement.setCashMovementCurrencyCode(cashMovementCurrencyCode);
+        statement.setOperationStatus(OperationStatus.Pending.getKey());
+        statement.setInSDfId(sdf01.getId());
+        statement.setInOutSDfType(InOutSDfType.type1.getKey());
+        return statement;
+    }
+
     private SDf02 getTestErrorSdf02(SDf01 sdf01, EnumMessage error, Long generationIdForGroup) {
         SDf02 sDf02 = new SDf02();
-        sDf02.setId(id);
+        sDf02.setId(ID);
         sDf02.setCurr_code(sdf01.getCurr_code());
         sDf02.setAccount(sdf01.getAccount());
         sDf02.setRemainder(sdf01.getRemainder());

clearing-parent/balance-service/src/test/java/ru/spcex/clearing/balance/service/Sdf09ExecutorTest.java

@@ -0,0 +1,242 @@
+package ru.spcex.clearing.balance.service;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import ru.clearing.classes.statics.data.account.Account;
+import ru.clearing.classes.statics.data.account.AccountBalance;
+import ru.clearing.classes.statics.data.company.Company;
+import ru.clearing.classes.statics.data.company.CompanySymbols;
+import ru.clearing.classes.statics.data.sdf.SDf09;
+import ru.clearing.classes.statics.data.sdf.SDf10;
+import ru.clearing.classes.statics.data.statement.Statement;
+import ru.spcex.clearing.balance.errors.BalanceError;
+import ru.spcex.clearing.balance.utils.MatcherFactory;
+import ru.spcex.clearing.platform.messaging.domain.cud.account.sdf01.AccountSdfRequestPart;
+import ru.spcex.clearing.platform.messaging.domain.cud.balance.StatementRequest;
+import ru.spcex.platform.enumeration.*;
+import ru.spcex.platform.utils.enumeration.EnumMessage;
+
+import javax.annotation.PostConstruct;
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+
+import static ru.spcex.clearing.balance.utils.MatcherFactory.usingIgnoringFieldsComparator;
+
+class Sdf09ExecutorTest extends AbstractServiceTest {
+    private static final MatcherFactory.Matcher<SDf10> SDF_10_MATCHER = usingIgnoringFieldsComparator("created", "comment", "outSDfId", "generationTime", "generationId", "id");
+
+    private final static DateTimeFormatter datFormatter = DateTimeFormatter.ofPattern("dd.MM.yy");
+    private final Long ID = 2L;
+    private final String acc = "213456789";
+    @Autowired
+    Sdf09Executor sdf09Executor;
+    private SDf09 sdf09;
+    private StatementRequest statementRequest;
+
+    @PostConstruct
+    void init() {
+        super.init();
+        sdf09 = getTestSdf09();
+        statementRequest = new StatementRequest();
+    }
+
+    /**
+     * {@link Sdf09Executor#execute(Collection collection, StatementRequest statementRequest)}<br>
+     * Тест проверяет генерацию сущностей {@link Result}, {@link Statement}, {@link SDf10}<br>
+     * Входные параметры:<br>
+     * accountId - {@link StatementRequest}: new StatementRequest()<br>
+     * addresseeId - {@link Collection<SDf09>}<br>
+     * addresseeId - {@link SDf09}<br>
+     * {@link SDf09#market} - "U"<br>
+     * {@link SDf09#account} - "123456789"<br>
+     * {@link SDf09#inn} - 987654321<br>
+     * {@link SDf09#sum} - 1000<br>
+     */
+    @Test
+    void execute() {
+        //check create statement, SDf10 and AccountBalance
+        Company company = getTestCompany();
+        companyMap.put(addresseeIdNew, company);
+
+        CompanySymbols companySymbols = getTestCompanySymbols();
+        companySymbolsMap.put(addresseeIdNew, companySymbols);
+
+        Account account = getTestAccount(ID, acc);
+        accountMap.put(accountIdNew, account);
+
+        Result predictableResult = new Result();
+        predictableResult.setGenerationId(ID);
+        Statement predictableStatement = getTestStatement(currentId.getAndIncrement(), company, account, sdf09);
+        predictableStatement.setOperationStatus(OperationStatus.Executed.getKey());
+        SDf10 predictableSdf10 = getTestSdf10(currentId.getAndIncrement(), sdf09, ID);
+        predictableStatement.setOutSDfId(predictableSdf10.getId());
+        AccountResult predictableNewResult = getTestAccountResult(currentId.getAndIncrement(), account, company);
+
+        Result result = sdf09Executor.execute(Collections.singletonList(sdf09), statementRequest);
+        Statement resultStatement = statementImdg.getSingleObjectByFieldValues(Map.of("account", acc));
+        SDf10 resultSdf10 = sdf10Imdg.getSingleObjectByFieldValues(Map.of("account", acc));
+        AccountBalance resultAccountBalance = accountBalanceImdg.getSingleObjectByFieldValues(Map.of("account", acc));
+
+        RESULT_MATCHER.assertMatch(result, predictableResult);
+        STATEMENT_MATCHER.assertMatch(resultStatement, predictableStatement);
+        SDF_10_MATCHER.assertMatch(resultSdf10, predictableSdf10);
+        ACCOUNT_BALANCE_MATCHER.assertMatch(resultAccountBalance, predictableNewResult.getAccount());
+    }
+
+    /**
+     * {@link Sdf09Executor#execute(Collection collection, StatementRequest statementRequest)}<br>
+     * Тест проверяет валидацию<br>
+     * Входные параметры:<br>
+     * accountId - {@link StatementRequest}: new StatementRequest()<br>
+     * addresseeId - {@link Collection<SDf09>}<br>
+     * addresseeId - {@link SDf09}<br>
+     * {@link SDf09#market} - "U"<br>
+     * {@link SDf09#account} - "123456789"<br>
+     * {@link SDf09#inn} - 987654321<br>
+     * {@link SDf09#sum} - 1000<br>
+     */
+    @Test
+    void validatedExecute() {
+        //CompanyNotFound
+        companyMap.delete(addresseeIdNew);
+        checkError(new EnumMessage(BalanceError.CompanyNotFound));
+
+        Company company = getTestCompany();
+        companyMap.put(addresseeIdNew, company);
+        companySymbolsMap.delete(addresseeIdNew);
+        checkError(new EnumMessage(BalanceError.CompanyNotFound));
+
+        CompanySymbols companySymbols = getTestCompanySymbols();
+        companySymbolsMap.put(addresseeIdNew, companySymbols);
+        sdf09.setInn(null);
+        checkError(new EnumMessage(BalanceError.CompanyNotFound));
+
+        //AccountNotPresent
+        sdf09.setInn(inn);
+        accountMap.delete(accountIdNew);
+        checkErrorAccountNotPresent(company);
+
+        //AccountNotPresent
+        Account account = new Account();
+        account.setAccount(null);
+        account.setAccountType(AccountType.Clrn.getKey());
+        account.setAccountStatus(Status.Active.getKey());
+        accountMap.put(accountIdNew, account);
+        checkErrorAccountNotPresent(company);
+
+        //AccountNotPresent
+        account = getTestAccount(ID, acc);
+        accountMap.put(accountIdNew, account);
+        sdf09.setAccount(null);
+        checkErrorAccountNotPresent(company);
+
+        //WrongMarket
+        sdf09.setAccount(acc);
+        sdf09.setMarket(null);
+        checkError(new EnumMessage(BalanceError.WrongMarket));
+
+        //BalanceNotEnough
+        sdf09.setMarket("U");
+        sdf09.setSum(null);
+        checkError(new EnumMessage(BalanceError.BalanceNotEnough));
+
+        //BalanceNotEnough
+        sdf09.setSum(new BigDecimal(-1000));
+        AccountBalance balance = accountBalanceImdg.getSingleObjectByFieldValues(Map.of("account", sdf09.getAccount(),
+                "accountType", AccountType.Clrn.getKey()));
+        if (balance != null) accountBalanceImdg.delete(balance);
+        else balance = getTestAccountBalance(ID, account, company);
+        checkError(new EnumMessage(BalanceError.BalanceNotEnough));
+
+        //BalanceNotEnough
+        balance.setFreeBalanceAmount(new BigDecimal(999));
+        accountBalanceImdg.insert(balance);
+        checkError(new EnumMessage(BalanceError.BalanceNotEnough));
+
+        balance.setFreeBalanceAmount(amountNew);
+        accountBalanceImdg.insert(balance);
+    }
+
+    private void checkError(EnumMessage enumMessage) {
+        SDf10 predictableSdf10 = getTestErrorSdf10(sdf09, enumMessage, ID);
+        Result result = sdf09Executor.execute(Collections.singletonList(sdf09), statementRequest);
+        Collection<SDf10> resultsSdf10 = sdf10Imdg.getCollectionObjectsByFieldValues(Map.of("account", acc));
+        SDf10 resultSdf10 = resultsSdf10.stream().max((entry1, entry2) -> entry1.getId() > entry2.getId() ? 1 : -1).get();
+        SDF_10_MATCHER.assertMatch(resultSdf10, predictableSdf10);
+    }
+
+    protected Statement getTestStatement(Long id, Company company, Account account, SDf09 sdf09) {
+        Statement statement = new Statement();
+        statement.setId(id);
+        statement.setAddresseeId(company.getId());
+        statement.setSenderId(Sender.Prc.getId());
+        statement.setCreated(Instant.now());
+        statement.setClearingDate(LocalDate.now());
+        statement.setStatementType(StatementType.incr.getKey());
+        statement.setAccountId(account.getId());
+        statement.setAccount(sdf09.getAccount());
+        statement.setInOutDirection(InOutDirection.in.getKey());
+        statement.setAmount(sdf09.getSum());
+        statement.setCashMovementCurrencyCode(CurrencyCode.RUB.getKey());
+        statement.setOperationStatus(OperationStatus.Pending.getKey());
+        statement.setInSDfId(sdf09.getId());
+        statement.setInOutSDfType(InOutSDfType.type9.getKey());
+        statementImdg.insert(statement);
+        return statement;
+    }
+
+    private SDf10 getTestSdf10(Long id, SDf09 sdf09, Long generationIdForGroup) {
+        SDf10 sDf10 = new SDf10();
+        sDf10.setId(id);
+        sDf10.setAccount(sdf09.getAccount());
+        sDf10.setSum(sdf09.getSum());
+        sDf10.setMarket(sdf09.getMarket());
+        sDf10.setType(sdf09.getType());
+        sDf10.setNumber(sdf09.getNumber());
+        sDf10.setInn(sdf09.getInn());
+        sDf10.setResult("OK");
+        sDf10.setGenerationId(generationIdForGroup);
+        sDf10.setGenerationTime(Instant.now());
+        sDf10.setInSDf09Id(sdf09.getId());
+        return sDf10;
+    }
+
+    private SDf09 getTestSdf09() {
+        SDf09 sdf09 = new SDf09();
+        sdf09.setId(ID);
+        sdf09.setMarket("U");
+        sdf09.setAccount(acc);
+        sdf09.setInn(inn);
+        sdf09.setSum(amountNew);
+        return sdf09;
+    }
+
+    private SDf10 getTestErrorSdf10(SDf09 sdf09, EnumMessage error, Long generationIdForGroup) {
+        SDf10 sDf10 = getTestSdf10(ID, sdf09, generationIdForGroup);
+        sDf10.setId(ID);
+        String errorId = error.getSubject().getId().toString();
+        sDf10.setResult(errorId.substring(errorId.length() - 3));
+        return sDf10;
+    }
+
+    private void checkErrorAccountNotPresent(Company company) {
+        Result predictableResult = new Result();
+        predictableResult.getAccountRequests().add(createAccountRequestPart(sdf09.getId(), sdf09.getAccount(), company.getId()));
+        Result result = sdf09Executor.execute(Collections.singletonList(sdf09), statementRequest);
+        RESULT_MATCHER.assertMatch(result, predictableResult);
+    }
+
+    private AccountSdfRequestPart createAccountRequestPart(Long sdf09Id, String account, Long companyId) {
+        AccountSdfRequestPart req = new AccountSdfRequestPart();
+        req.setAccount(account);
+        req.setCompanyId(companyId);
+//        req.setAccountType(AccountType.Clrn.getKey());
+        req.setSdfId(sdf09Id);
+        return req;
+    }
+}