2024-11-22 17:24:33 +00:00
25 changed files with 181 additions and 578 deletions
--- a/src/Api/KktMonitor.php
+++ b/src/Api/KktMonitor.php
@ -100,6 +100,7 @@ class KktMonitor extends AtolClient
    /**
     * Возвращает информацию о конкретной ККТ по её серийному номеру
     *
+     * @todo кастовать к отдельному классу со своими геттерами
     * @param string $serial_number
     * @return Kkt
     * @throws GuzzleException
--- a/src/Collections/EntityCollection.php
+++ b/src/Collections/EntityCollection.php
@ -22,12 +22,10 @@ abstract class EntityCollection extends Collection
 {
    /**
     * @inheritDoc
-     * @throws InvalidEntityInCollectionException
     */
    public function __construct($items = [])
    {
        $this->checkCount($items);
-        $this->checkItemsClasses($items);
        parent::__construct($items);
    }

@ -73,17 +71,19 @@ abstract class EntityCollection extends Collection
     */
    public function jsonSerialize(): array
    {
-        $this->checkItemsClasses();
+        $this->each(function ($item) {
+            $this->checkClass($item);
+        });
        return parent::jsonSerialize();
    }

    /**
-     * Проверяет количество элементов коллекции
+     * Проверяет количество ставок
     *
     * @param array $items Массив элементов, если пустой - проверит содержимое коллекции
     * @return void
     */
-    public function checkCount(array $items = []): void
+    private function checkCount(array $items = []): void
    {
        if (count($items) > static::MAX_COUNT || $this->count() === static::MAX_COUNT) {
            throw new (static::EXCEPTION_CLASS)(static::MAX_COUNT);
@ -91,24 +91,14 @@ abstract class EntityCollection extends Collection
    }

    /**
-     * Проверяет корректность класса элемента коллекции
+     * Проверяет корректность класса объекта
     *
     * @throws InvalidEntityInCollectionException
     */
-    public function checkItemClass(mixed $item): void
+    private function checkClass(mixed $item): void
    {
        if (!is_object($item) || $item::class !== static::ENTITY_CLASS) {
            throw new InvalidEntityInCollectionException(static::class, static::ENTITY_CLASS, $item);
        }
    }
-
-    /**
-     * Проверяет корректность классов элементов коллекции
-     *
-     * @throws InvalidEntityInCollectionException
-     */
-    public function checkItemsClasses(array $items = []): void
-    {
-        (empty($items) ? $this : collect($items))->each(fn ($item) => $this->checkItemClass($item));
-    }
 }
--- a/src/Entities/Receipt.php
+++ b/src/Entities/Receipt.php
@ -15,10 +15,7 @@ use AtolOnline\Collections\Items;
 use AtolOnline\Collections\Payments;
 use AtolOnline\Collections\Vats;
 use AtolOnline\Constants\Constraints;
-use AtolOnline\Exceptions\EmptyItemsException;
-use AtolOnline\Exceptions\EmptyPaymentsException;
-use AtolOnline\Exceptions\EmptyVatsException;
-use AtolOnline\Exceptions\InvalidEntityInCollectionException;
+use AtolOnline\Exceptions\TooHighPriceException;
 use AtolOnline\Exceptions\TooLongAddCheckPropException;
 use AtolOnline\Exceptions\TooLongCashierException;
 use Exception;
@ -78,26 +75,22 @@ class Receipt extends Entity
    /**
     * @var string|null Дополнительный реквизит
     */
-    protected ?string $add_check_props = null;
+    protected ?string $add_check_props;

    /**
     * @var AdditionalUserProps|null Дополнительный реквизит пользователя
     */
-    protected ?AdditionalUserProps $add_user_props = null;
+    protected ?AdditionalUserProps $add_user_props;

    /**
     * Конструктор
-     *
-     * @param Client $client
-     * @param Company $company
-     * @param Items $items
-     * @param Payments $payments
-     * @throws EmptyItemsException
-     * @throws EmptyPaymentsException
-     * @throws InvalidEntityInCollectionException
     */
-    public function __construct(Client $client, Company $company, Items $items, Payments $payments)
-    {
+    public function __construct(
+        Client $client,
+        Company $company,
+        Items $items,
+        Payments $payments,
+    ) {
        $this->setClient($client)->setCompany($company)->setItems($items)->setPayments($payments);
    }

@ -148,7 +141,7 @@ class Receipt extends Entity
    /**
     * Возвращает установленного агента
     *
-     * @return AgentInfo|null
+     * @return AgentInfo
     */
    public function getAgentInfo(): ?AgentInfo
    {
@ -205,15 +198,9 @@ class Receipt extends Entity
     * @todo исключение при пустой коллекции
     * @param Items $items
     * @return Receipt
-     * @throws EmptyItemsException
-     * @throws InvalidEntityInCollectionException
     */
    public function setItems(Items $items): self
    {
-        if ($items->isEmpty()) {
-            throw new EmptyItemsException();
-        }
-        $items->checkItemsClasses();
        $this->items = $items;
        return $this;
    }
@ -231,15 +218,12 @@ class Receipt extends Entity
    /**
     * Устанаваливает коллекцию оплат
     *
+     * @todo исключение при пустой коллекции
     * @param Payments $payments
     * @return Receipt
-     * @throws EmptyPaymentsException
     */
    public function setPayments(Payments $payments): self
    {
-        if ($payments->isEmpty()) {
-            throw new EmptyPaymentsException();
-        }
        $this->payments = $payments;
        return $this;
    }
@ -259,13 +243,9 @@ class Receipt extends Entity
     *
     * @param Vats|null $vats
     * @return Receipt
-     * @throws EmptyVatsException
     */
    public function setVats(?Vats $vats): self
    {
-        if ($vats->isEmpty()) {
-            throw new EmptyVatsException();
-        }
        $this->vats = $vats;
        return $this;
    }
@ -317,7 +297,7 @@ class Receipt extends Entity
                throw new TooLongCashierException($cashier);
            }
        }
-        $this->cashier = $cashier ?: null;
+        $this->cashier = empty($cashier) ? null : $cashier;
        return $this;
    }

@ -384,7 +364,7 @@ class Receipt extends Entity
            'company' => $this->getCompany(),
            'items' => $this->getItems(),
            'total' => $this->getTotal(),
-            'payments' => $this->getPayments(),
+            'payment' => $this->getPayments(),
        ];
        $this->getAgentInfo()?->jsonSerialize() && $json['agent_info'] = $this->getAgentInfo();
        $this->getSupplier()?->jsonSerialize() && $json['vats'] = $this->getVats();
--- a/src/Exceptions/EmptyItemsException.php
+++ b/src/Exceptions/EmptyItemsException.php
@ -1,22 +0,0 @@
-<?php
-/*
- * Copyright (c) 2020-2021 Антон Аксенов (Anthony Axenov)
- *
- * This code is licensed under MIT.
- * Этот код распространяется по лицензии MIT.
- * https://github.com/anthonyaxenov/atol-online/blob/master/LICENSE
- */
-
-declare(strict_types = 1);
-
-namespace AtolOnline\Exceptions;
-
-/**
- * Исключение, возникающее при попытке указать документу пустую коллекцию предметов расчёта
- *
- * @see https://online.atol.ru/files/API_atol_online_v4.pdf Документация, стр 21
- */
-class EmptyItemsException extends AtolException
-{
-    protected $message = 'Документ не может содержать пустую коллекцию предметов расчёта';
-}
--- a/src/Exceptions/EmptyPaymentsException.php
+++ b/src/Exceptions/EmptyPaymentsException.php
@ -1,22 +0,0 @@
-<?php
-/*
- * Copyright (c) 2020-2021 Антон Аксенов (Anthony Axenov)
- *
- * This code is licensed under MIT.
- * Этот код распространяется по лицензии MIT.
- * https://github.com/anthonyaxenov/atol-online/blob/master/LICENSE
- */
-
-declare(strict_types = 1);
-
-namespace AtolOnline\Exceptions;
-
-/**
- * Исключение, возникающее при попытке указать документу пустую коллекцию оплат
- *
- * @see https://online.atol.ru/files/API_atol_online_v4.pdf Документация, стр 30
- */
-class EmptyPaymentsException extends AtolException
-{
-    protected $message = 'Документ не может содержать пустую коллекцию оплат';
-}
--- a/src/Exceptions/EmptyVatsException.php
+++ b/src/Exceptions/EmptyVatsException.php
@ -1,22 +0,0 @@
-<?php
-/*
- * Copyright (c) 2020-2021 Антон Аксенов (Anthony Axenov)
- *
- * This code is licensed under MIT.
- * Этот код распространяется по лицензии MIT.
- * https://github.com/anthonyaxenov/atol-online/blob/master/LICENSE
- */
-
-declare(strict_types = 1);
-
-namespace AtolOnline\Exceptions;
-
-/**
- * Исключение, возникающее при попытке указать документу пустую коллекцию ставок НДС
- *
- * @see https://online.atol.ru/files/API_atol_online_v4.pdf Документация, стр 31
- */
-class EmptyVatsException extends AtolException
-{
-    protected $message = 'Документ не может содержать пустую коллекцию ставок НДС';
-}
--- a/tests/AtolOnline/Tests/Api/KktMonitorTest.php
+++ b/tests/AtolOnline/Tests/Api/KktMonitorTest.php
@ -339,7 +339,7 @@ class KktMonitorTest extends BasicTestCase
        $kkt = $client->getOne($serial_number);
        $this->assertNotEmpty($client->getResponse());
        $this->assertIsSameClass(Kkt::class, $kkt);
-        $this->assertIsAtolable($kkt);
+        $this->assertAtolable($kkt);
        $this->assertNotNull($kkt->serialNumber);
        $this->assertEquals($serial_number, $kkt->serialNumber);
    }
--- a/tests/AtolOnline/Tests/BasicTestCase.php
+++ b/tests/AtolOnline/Tests/BasicTestCase.php
@ -13,20 +13,6 @@ namespace AtolOnline\Tests;

 use AtolOnline\Collections\EntityCollection;
 use AtolOnline\Entities\Entity;
-use AtolOnline\Entities\Item;
-use AtolOnline\Entities\Payment;
-use AtolOnline\Entities\Vat;
-use AtolOnline\Enums\PaymentTypes;
-use AtolOnline\Enums\VatTypes;
-use AtolOnline\Exceptions\EmptyItemNameException;
-use AtolOnline\Exceptions\InvalidEnumValueException;
-use AtolOnline\Exceptions\NegativeItemPriceException;
-use AtolOnline\Exceptions\NegativeItemQuantityException;
-use AtolOnline\Exceptions\NegativePaymentSumException;
-use AtolOnline\Exceptions\TooHighItemPriceException;
-use AtolOnline\Exceptions\TooHighPaymentSumException;
-use AtolOnline\Exceptions\TooLongItemNameException;
-use AtolOnline\Exceptions\TooManyException;
 use AtolOnline\Helpers;
 use Exception;
 use GuzzleHttp\Client;
@ -39,10 +25,6 @@ use PHPUnit\Framework\TestCase;
 */
 class BasicTestCase extends TestCase
 {
-    //------------------------------------------------------------------------------------------------------------------
-    // Методы для управления тестами, использующими тестовый АТОЛ API
-    //------------------------------------------------------------------------------------------------------------------
-
    /**
     * Проверяет наличие подключения к ресурсу по URL
     *
@ -83,10 +65,6 @@ class BasicTestCase extends TestCase
        }
    }

-    //------------------------------------------------------------------------------------------------------------------
-    // Дополнительные ассерты
-    //------------------------------------------------------------------------------------------------------------------
-
    /**
     * Тестирует является ли объект приводимым к json-строке согласно схеме АТОЛ Онлайн
     *
@ -97,7 +75,7 @@ class BasicTestCase extends TestCase
     * @covers \AtolOnline\Collections\EntityCollection::jsonSerialize
     * @throws Exception
     */
-    public function assertIsAtolable(Entity|EntityCollection $entity, ?array $json_structure = null): void
+    public function assertAtolable(Entity|EntityCollection $entity, ?array $json_structure = null): void
    {
        $this->assertIsArray($entity->jsonSerialize());
        $this->assertIsString((string)$entity);
@ -107,8 +85,6 @@ class BasicTestCase extends TestCase
        }
    }

-    //------------------------------------------------------------------------------------------------------------------
-    // Ассерты проверки наследования
    //------------------------------------------------------------------------------------------------------------------

    /**
@ -227,8 +203,6 @@ class BasicTestCase extends TestCase
        );
    }

-    //------------------------------------------------------------------------------------------------------------------
-    // Провайдеры данных для прогона тестов
    //------------------------------------------------------------------------------------------------------------------

    /**
@ -314,74 +288,4 @@ class BasicTestCase extends TestCase
            ['abc.def@mail#archive.com'],
        ];
    }
-
-    //------------------------------------------------------------------------------------------------------------------
-    // Генераторы тестовых объектов
-    //------------------------------------------------------------------------------------------------------------------
-
-    /**
-     * Генерирует массив тестовых объектов предметов расчёта
-     *
-     * @param int $count
-     * @return Item[]
-     * @throws EmptyItemNameException
-     * @throws NegativeItemPriceException
-     * @throws NegativeItemQuantityException
-     * @throws TooHighItemPriceException
-     * @throws TooLongItemNameException
-     * @throws TooManyException
-     * @throws Exception
-     */
-    protected function generateItemObjects(int $count = 1): array
-    {
-        $result = [];
-        for ($i = 0; $i < abs($count); ++$i) {
-            $result[] = new Item(Helpers::randomStr(), random_int(1, 100), random_int(1, 10));
-        }
-        return $result;
-    }
-
-    /**
-     * Генерирует массив тестовых объектов оплаты
-     *
-     * @param int $count
-     * @return Payment[]
-     * @throws InvalidEnumValueException
-     * @throws NegativePaymentSumException
-     * @throws TooHighPaymentSumException
-     * @throws Exception
-     */
-    protected function generatePaymentObjects(int $count = 1): array
-    {
-        $types = PaymentTypes::toArray();
-        $result = [];
-        for ($i = 0; $i < abs($count); ++$i) {
-            $result[] = new Payment(
-                array_values($types)[random_int(min($types), max($types))],
-                random_int(1, 100) * 2 / 3
-            );
-        }
-        return $result;
-    }
-
-    /**
-     * Генерирует массив тестовых объектов ставок НДС
-     *
-     * @param int $count
-     * @return Vat[]
-     * @throws InvalidEnumValueException
-     * @throws Exception
-     */
-    protected function generateVatObjects(int $count = 1): array
-    {
-        $types = VatTypes::toArray();
-        $result = [];
-        for ($i = 0; $i < abs($count); ++$i) {
-            $result[] = new Vat(
-                array_values($types)[random_int(0, count($types) - 1)],
-                random_int(1, 100) * 2 / 3
-            );
-        }
-        return $result;
-    }
 }
--- a/tests/AtolOnline/Tests/Collections/ItemsTest.php
+++ b/tests/AtolOnline/Tests/Collections/ItemsTest.php
@ -12,16 +12,18 @@ namespace AtolOnline\Tests\Collections;
 use AtolOnline\{
    Collections\Items,
    Constants\Constraints,
+    Entities\Item,
+    Helpers,
    Tests\BasicTestCase};
 use AtolOnline\Exceptions\{
    EmptyItemNameException,
-    InvalidEntityInCollectionException,
    NegativeItemPriceException,
    NegativeItemQuantityException,
    TooHighItemPriceException,
    TooLongItemNameException,
    TooManyException,
-    TooManyItemsException};
+    TooManyItemsException,};
+use Exception;

 /**
 * Набор тестов для проверки работы класса коллекции предметов расчёта
@ -40,12 +42,11 @@ class ItemsTest extends BasicTestCase
     * @throws TooHighItemPriceException
     * @throws TooLongItemNameException
     * @throws TooManyException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyItemsExceptionByConstructor()
    {
        $this->expectException(TooManyItemsException::class);
-        new Items($this->generateItemObjects(Constraints::MAX_COUNT_DOC_ITEMS + 1));
+        new Items($this->generateObjects(Constraints::MAX_COUNT_DOC_ITEMS + 1));
    }

    /**
@ -60,13 +61,12 @@ class ItemsTest extends BasicTestCase
     * @throws TooHighItemPriceException
     * @throws TooLongItemNameException
     * @throws TooManyException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyItemsExceptionByPrepend()
    {
        $this->expectException(TooManyItemsException::class);
-        (new Items($this->generateItemObjects(Constraints::MAX_COUNT_DOC_ITEMS)))
-            ->prepend($this->generateItemObjects());
+        (new Items($this->generateObjects(Constraints::MAX_COUNT_DOC_ITEMS)))
+            ->prepend($this->generateObjects());
    }

    /**
@ -82,13 +82,12 @@ class ItemsTest extends BasicTestCase
     * @throws TooHighItemPriceException
     * @throws TooLongItemNameException
     * @throws TooManyException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyItemsExceptionByAdd()
    {
        $this->expectException(TooManyItemsException::class);
-        (new Items($this->generateItemObjects(Constraints::MAX_COUNT_DOC_ITEMS)))
-            ->add($this->generateItemObjects());
+        (new Items($this->generateObjects(Constraints::MAX_COUNT_DOC_ITEMS)))
+            ->add($this->generateObjects());
    }

    /**
@ -104,13 +103,12 @@ class ItemsTest extends BasicTestCase
     * @throws TooHighItemPriceException
     * @throws TooLongItemNameException
     * @throws TooManyException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyItemsExceptionByPush()
    {
        $this->expectException(TooManyItemsException::class);
-        (new Items($this->generateItemObjects(Constraints::MAX_COUNT_DOC_ITEMS)))
-            ->push(...$this->generateItemObjects());
+        (new Items($this->generateObjects(Constraints::MAX_COUNT_DOC_ITEMS)))
+            ->push(...$this->generateObjects());
    }

    /**
@ -126,12 +124,33 @@ class ItemsTest extends BasicTestCase
     * @throws TooHighItemPriceException
     * @throws TooLongItemNameException
     * @throws TooManyException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyItemsExceptionByMerge()
    {
        $this->expectException(TooManyItemsException::class);
-        (new Items($this->generateItemObjects(Constraints::MAX_COUNT_DOC_ITEMS)))
-            ->merge($this->generateItemObjects(2));
+        (new Items($this->generateObjects(Constraints::MAX_COUNT_DOC_ITEMS)))
+            ->merge($this->generateObjects(2));
+    }
+
+    /**
+     * Генерирует массив тестовых объектов предметов расчёта
+     *
+     * @param int $count
+     * @return Item[]
+     * @throws EmptyItemNameException
+     * @throws NegativeItemPriceException
+     * @throws NegativeItemQuantityException
+     * @throws TooHighItemPriceException
+     * @throws TooLongItemNameException
+     * @throws TooManyException
+     * @throws Exception
+     */
+    protected function generateObjects(int $count = 1): array
+    {
+        $result = [];
+        for ($i = 0; $i < abs($count); ++$i) {
+            $result[] = new Item(Helpers::randomStr(), random_int(1, 100), random_int(1, 10));
+        }
+        return $result;
    }
 }
--- a/tests/AtolOnline/Tests/Collections/PaymentsTest.php
+++ b/tests/AtolOnline/Tests/Collections/PaymentsTest.php
@ -12,12 +12,14 @@ namespace AtolOnline\Tests\Collections;
 use AtolOnline\{
    Collections\Payments,
    Constants\Constraints,
-    Exceptions\InvalidEntityInCollectionException,
+    Entities\Payment,
+    Enums\PaymentTypes,
    Exceptions\InvalidEnumValueException,
    Exceptions\NegativePaymentSumException,
    Exceptions\TooHighPaymentSumException,
    Exceptions\TooManyPaymentsException,
    Tests\BasicTestCase};
+use Exception;

 /**
 * Набор тестов для проверки работы класса коллекции оплат
@ -33,12 +35,11 @@ class PaymentsTest extends BasicTestCase
     * @throws InvalidEnumValueException
     * @throws NegativePaymentSumException
     * @throws TooHighPaymentSumException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyPaymentsExceptionByConstructor()
    {
        $this->expectException(TooManyPaymentsException::class);
-        new Payments($this->generatePaymentObjects(Constraints::MAX_COUNT_DOC_PAYMENTS + 1));
+        new Payments($this->generateObjects(Constraints::MAX_COUNT_DOC_PAYMENTS + 1));
    }

    /**
@ -50,13 +51,12 @@ class PaymentsTest extends BasicTestCase
     * @throws InvalidEnumValueException
     * @throws NegativePaymentSumException
     * @throws TooHighPaymentSumException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyPaymentsExceptionByPrepend()
    {
        $this->expectException(TooManyPaymentsException::class);
-        (new Payments($this->generatePaymentObjects(Constraints::MAX_COUNT_DOC_PAYMENTS)))
-            ->prepend($this->generatePaymentObjects());
+        (new Payments($this->generateObjects(Constraints::MAX_COUNT_DOC_PAYMENTS)))
+            ->prepend($this->generateObjects());
    }

    /**
@ -69,13 +69,12 @@ class PaymentsTest extends BasicTestCase
     * @throws InvalidEnumValueException
     * @throws NegativePaymentSumException
     * @throws TooHighPaymentSumException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyPaymentsExceptionByAdd()
    {
        $this->expectException(TooManyPaymentsException::class);
-        (new Payments($this->generatePaymentObjects(Constraints::MAX_COUNT_DOC_PAYMENTS)))
-            ->add($this->generatePaymentObjects());
+        (new Payments($this->generateObjects(Constraints::MAX_COUNT_DOC_PAYMENTS)))
+            ->add($this->generateObjects());
    }

    /**
@ -88,13 +87,12 @@ class PaymentsTest extends BasicTestCase
     * @throws InvalidEnumValueException
     * @throws NegativePaymentSumException
     * @throws TooHighPaymentSumException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyPaymentsExceptionByPush()
    {
        $this->expectException(TooManyPaymentsException::class);
-        (new Payments($this->generatePaymentObjects(Constraints::MAX_COUNT_DOC_PAYMENTS + 1)))
-            ->push(...$this->generatePaymentObjects());
+        (new Payments($this->generateObjects(Constraints::MAX_COUNT_DOC_PAYMENTS + 1)))
+            ->push(...$this->generateObjects());
    }

    /**
@ -107,12 +105,34 @@ class PaymentsTest extends BasicTestCase
     * @throws InvalidEnumValueException
     * @throws NegativePaymentSumException
     * @throws TooHighPaymentSumException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyPaymentsExceptionByMerge()
    {
        $this->expectException(TooManyPaymentsException::class);
-        (new Payments($this->generatePaymentObjects(Constraints::MAX_COUNT_DOC_PAYMENTS - 1)))
-            ->merge($this->generatePaymentObjects(2));
+        (new Payments($this->generateObjects(Constraints::MAX_COUNT_DOC_PAYMENTS - 1)))
+            ->merge($this->generateObjects(2));
+    }
+
+    /**
+     * Генерирует массив тестовых объектов оплаты
+     *
+     * @param int $count
+     * @return Payment[]
+     * @throws InvalidEnumValueException
+     * @throws NegativePaymentSumException
+     * @throws TooHighPaymentSumException
+     * @throws Exception
+     */
+    protected function generateObjects(int $count = 1): array
+    {
+        $types = PaymentTypes::toArray();
+        $result = [];
+        for ($i = 0; $i < abs($count); ++$i) {
+            $result[] = new Payment(
+                array_values($types)[random_int(min($types), max($types))],
+                random_int(1, 100) * 2 / 3
+            );
+        }
+        return $result;
    }
 }
--- a/tests/AtolOnline/Tests/Collections/VatsTest.php
+++ b/tests/AtolOnline/Tests/Collections/VatsTest.php
@ -13,7 +13,9 @@ use AtolOnline\{
    Collections\Vats,
    Constants\Constraints,
    Entities\Payment,
+    Entities\Vat,
    Enums\PaymentTypes,
+    Enums\VatTypes,
    Exceptions\InvalidEntityInCollectionException,
    Exceptions\InvalidEnumValueException,
    Exceptions\NegativePaymentSumException,
@ -37,10 +39,10 @@ class VatsTest extends BasicTestCase
     */
    public function testConstructor()
    {
-        $vats = new Vats($this->generateVatObjects(3));
+        $vats = new Vats($this->generateObjects(3));
        $this->assertIsCollection($vats);
        $this->assertEquals(3, $vats->count());
-        $this->assertIsAtolable($vats);
+        $this->assertAtolable($vats);
    }

    /**
@ -50,12 +52,11 @@ class VatsTest extends BasicTestCase
     * @covers \AtolOnline\Collections\EntityCollection::checkCount
     * @covers \AtolOnline\Exceptions\TooManyVatsException
     * @throws InvalidEnumValueException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyVatsExceptionByConstructor()
    {
        $this->expectException(TooManyVatsException::class);
-        new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS + 1));
+        new Vats($this->generateObjects(Constraints::MAX_COUNT_DOC_VATS + 1));
    }

    /**
@ -65,12 +66,11 @@ class VatsTest extends BasicTestCase
     * @covers \AtolOnline\Collections\EntityCollection::prepend
     * @covers \AtolOnline\Collections\EntityCollection::checkCount
     * @throws InvalidEnumValueException
-     * @throws InvalidEntityInCollectionException
     */
    public function testPrepend()
    {
-        $vats = (new Vats($this->generateVatObjects(3)))
-            ->prepend($this->generateVatObjects());
+        $vats = (new Vats($this->generateObjects(3)))
+            ->prepend($this->generateObjects());
        $this->assertEquals(4, $vats->count());
    }

@ -82,13 +82,12 @@ class VatsTest extends BasicTestCase
     * @covers \AtolOnline\Collections\EntityCollection::checkCount
     * @covers \AtolOnline\Exceptions\TooManyVatsException
     * @throws InvalidEnumValueException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyVatsExceptionByPrepend()
    {
        $this->expectException(TooManyVatsException::class);
-        (new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS)))
-            ->prepend($this->generateVatObjects());
+        (new Vats($this->generateObjects(Constraints::MAX_COUNT_DOC_VATS)))
+            ->prepend($this->generateObjects());
    }

    /**
@ -98,12 +97,11 @@ class VatsTest extends BasicTestCase
     * @covers \AtolOnline\Collections\EntityCollection::add
     * @covers \AtolOnline\Collections\EntityCollection::checkCount
     * @throws InvalidEnumValueException
-     * @throws InvalidEntityInCollectionException
     */
    public function testAdd()
    {
-        $vats = (new Vats($this->generateVatObjects(3)))
-            ->add($this->generateVatObjects());
+        $vats = (new Vats($this->generateObjects(3)))
+            ->add($this->generateObjects());
        $this->assertEquals(4, $vats->count());
    }

@ -115,13 +113,12 @@ class VatsTest extends BasicTestCase
     * @covers \AtolOnline\Collections\EntityCollection::checkCount
     * @covers \AtolOnline\Exceptions\TooManyVatsException
     * @throws InvalidEnumValueException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyVatsExceptionByAdd()
    {
        $this->expectException(TooManyVatsException::class);
-        (new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS)))
-            ->add($this->generateVatObjects());
+        (new Vats($this->generateObjects(Constraints::MAX_COUNT_DOC_VATS)))
+            ->add($this->generateObjects());
    }

    /**
@ -131,12 +128,11 @@ class VatsTest extends BasicTestCase
     * @covers \AtolOnline\Collections\EntityCollection::push
     * @covers \AtolOnline\Collections\EntityCollection::checkCount
     * @throws InvalidEnumValueException
-     * @throws InvalidEntityInCollectionException
     */
    public function testPush()
    {
-        $vats = (new Vats($this->generateVatObjects(3)))
-            ->push(...$this->generateVatObjects(3));
+        $vats = (new Vats($this->generateObjects(3)))
+            ->push(...$this->generateObjects(3));
        $this->assertEquals(6, $vats->count());
    }

@ -148,13 +144,12 @@ class VatsTest extends BasicTestCase
     * @covers \AtolOnline\Collections\EntityCollection::checkCount
     * @covers \AtolOnline\Exceptions\TooManyVatsException
     * @throws InvalidEnumValueException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyVatsExceptionByPush()
    {
        $this->expectException(TooManyVatsException::class);
-        (new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS)))
-            ->push(...$this->generateVatObjects());
+        (new Vats($this->generateObjects(Constraints::MAX_COUNT_DOC_VATS)))
+            ->push(...$this->generateObjects());
    }

    /**
@ -164,12 +159,11 @@ class VatsTest extends BasicTestCase
     * @covers \AtolOnline\Collections\EntityCollection::merge
     * @covers \AtolOnline\Collections\EntityCollection::checkCount
     * @throws InvalidEnumValueException
-     * @throws InvalidEntityInCollectionException
     */
    public function testMerge()
    {
-        $vats = (new Vats($this->generateVatObjects(3)))
-            ->merge($this->generateVatObjects(3));
+        $vats = (new Vats($this->generateObjects(3)))
+            ->merge($this->generateObjects(3));
        $this->assertEquals(6, $vats->count());
    }

@ -181,20 +175,19 @@ class VatsTest extends BasicTestCase
     * @covers \AtolOnline\Collections\EntityCollection::checkCount
     * @covers \AtolOnline\Exceptions\TooManyVatsException
     * @throws InvalidEnumValueException
-     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyVatsExceptionByMerge()
    {
        $this->expectException(TooManyVatsException::class);
-        (new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS - 1)))
-            ->merge($this->generateVatObjects(2));
+        (new Vats($this->generateObjects(Constraints::MAX_COUNT_DOC_VATS - 1)))
+            ->merge($this->generateObjects(2));
    }

    /**
     * Тестирует выброс исключения при наличии скаляров в коллекции
     *
     * @covers \AtolOnline\Collections\EntityCollection
-     * @covers \AtolOnline\Collections\EntityCollection::checkItemClass
+     * @covers \AtolOnline\Collections\EntityCollection::checkClass
     * @covers \AtolOnline\Collections\EntityCollection::jsonSerialize
     * @covers \AtolOnline\Exceptions\InvalidEntityInCollectionException
     * @throws InvalidEnumValueException
@ -204,7 +197,7 @@ class VatsTest extends BasicTestCase
    {
        $this->expectException(InvalidEntityInCollectionException::class);
        $this->expectExceptionMessage("(string)'bad element'");
-        (new Vats($this->generateVatObjects(2)))
+        (new Vats($this->generateObjects(2)))
            ->merge('bad element')
            ->jsonSerialize();
    }
@ -221,8 +214,29 @@ class VatsTest extends BasicTestCase
    {
        $this->expectException(InvalidEntityInCollectionException::class);
        $this->expectExceptionMessage(Payment::class);
-        (new Vats($this->generateVatObjects()))
+        (new Vats($this->generateObjects()))
            ->merge([new Payment(PaymentTypes::PREPAID, 1)])
            ->jsonSerialize();
    }
+
+    /**
+     * Генерирует массив тестовых объектов ставок НДС
+     *
+     * @param int $count
+     * @return Vat[]
+     * @throws InvalidEnumValueException
+     * @throws Exception
+     */
+    protected function generateObjects(int $count = 1): array
+    {
+        $types = VatTypes::toArray();
+        $result = [];
+        for ($i = 0; $i < abs($count); ++$i) {
+            $result[] = new Vat(
+                array_values($types)[random_int(0, count($types) - 1)],
+                random_int(1, 100) * 2 / 3
+            );
+        }
+        return $result;
+    }
 }
--- a/tests/AtolOnline/Tests/Entities/AdditionalUserPropsTest.php
+++ b/tests/AtolOnline/Tests/Entities/AdditionalUserPropsTest.php
@ -38,7 +38,7 @@ class AdditionalUserPropsTest extends BasicTestCase
     */
    public function testConstructor(): void
    {
-        $this->assertIsAtolable(
+        $this->assertAtolable(
            new AdditionalUserProps('name', 'value'),
            [
                'name' => 'name',
--- a/tests/AtolOnline/Tests/Entities/AgentInfoTest.php
+++ b/tests/AtolOnline/Tests/Entities/AgentInfoTest.php
@ -36,7 +36,7 @@ class AgentInfoTest extends BasicTestCase
     */
    public function testConstructorWithoutArgs(): void
    {
-        $this->assertIsAtolable(new AgentInfo(), []);
+        $this->assertAtolable(new AgentInfo(), []);
    }

    /**
@ -63,20 +63,20 @@ class AgentInfoTest extends BasicTestCase
     */
    public function testConstructorWithArgs(): void
    {
-        $this->assertIsAtolable(new AgentInfo(null), []);
-        $this->assertIsAtolable(new AgentInfo(AgentTypes::ANOTHER), ['type' => AgentTypes::ANOTHER]);
-        $this->assertIsAtolable(new AgentInfo(pagent: new PayingAgent()), []);
-        $this->assertIsAtolable(new AgentInfo(mt_operator: new MoneyTransferOperator()), []);
-        $this->assertIsAtolable(new AgentInfo(rp_operator: new ReceivePaymentsOperator()), []);
+        $this->assertAtolable(new AgentInfo(null), []);
+        $this->assertAtolable(new AgentInfo(AgentTypes::ANOTHER), ['type' => AgentTypes::ANOTHER]);
+        $this->assertAtolable(new AgentInfo(pagent: new PayingAgent()), []);
+        $this->assertAtolable(new AgentInfo(mt_operator: new MoneyTransferOperator()), []);
+        $this->assertAtolable(new AgentInfo(rp_operator: new ReceivePaymentsOperator()), []);

-        $this->assertIsAtolable(new AgentInfo(
+        $this->assertAtolable(new AgentInfo(
            AgentTypes::ANOTHER,
            new PayingAgent(),
            new ReceivePaymentsOperator(),
            new MoneyTransferOperator(),
        ), ['type' => AgentTypes::ANOTHER]);

-        $this->assertIsAtolable(new AgentInfo(
+        $this->assertAtolable(new AgentInfo(
            AgentTypes::ANOTHER,
            new PayingAgent('test', ['+79518888888']),
            new ReceivePaymentsOperator(['+79519999999']),
--- a/tests/AtolOnline/Tests/Entities/ClientTest.php
+++ b/tests/AtolOnline/Tests/Entities/ClientTest.php
@ -34,7 +34,7 @@ class ClientTest extends BasicTestCase
     */
    public function testConstructorWithoutArgs(): void
    {
-        $this->assertIsAtolable(new Client(), []);
+        $this->assertAtolable(new Client(), []);
    }

    /**
@ -54,11 +54,11 @@ class ClientTest extends BasicTestCase
     */
    public function testConstructorWithArgs(): void
    {
-        $this->assertIsAtolable(new Client('John Doe'), ['name' => 'John Doe']);
-        $this->assertIsAtolable(new Client(email: 'john@example.com'), ['email' => 'john@example.com']);
-        $this->assertIsAtolable(new Client(phone: '+1/22/99*73s dsdas654 5s6'), ['phone' => '+122997365456']);
-        $this->assertIsAtolable(new Client(inn: '+fasd3\qe3fs_=nac99013928czc'), ['inn' => '3399013928']);
-        $this->assertIsAtolable(new Client(
+        $this->assertAtolable(new Client('John Doe'), ['name' => 'John Doe']);
+        $this->assertAtolable(new Client(email: 'john@example.com'), ['email' => 'john@example.com']);
+        $this->assertAtolable(new Client(phone: '+1/22/99*73s dsdas654 5s6'), ['phone' => '+122997365456']);
+        $this->assertAtolable(new Client(inn: '+fasd3\qe3fs_=nac99013928czc'), ['inn' => '3399013928']);
+        $this->assertAtolable(new Client(
            'John Doe',
            'john@example.com',
            '+1/22/99*73s dsdas654 5s6', // +122997365456
--- a/tests/AtolOnline/Tests/Entities/CompanyTest.php
+++ b/tests/AtolOnline/Tests/Entities/CompanyTest.php
@ -44,7 +44,7 @@ class CompanyTest extends BasicTestCase
     */
    public function testConstructor()
    {
-        $this->assertIsAtolable(new Company(
+        $this->assertAtolable(new Company(
            $email = 'company@example.com',
            $sno = SnoTypes::OSN,
            $inn = '1234567890',
--- a/tests/AtolOnline/Tests/Entities/CorrectionInfoTest.php
+++ b/tests/AtolOnline/Tests/Entities/CorrectionInfoTest.php
@ -43,7 +43,7 @@ class CorrectionInfoTest extends BasicTestCase
     */
    public function testConstructor(): void
    {
-        $this->assertIsAtolable(
+        $this->assertAtolable(
            new CorrectionInfo(CorrectionTypes::SELF, '01.01.2021', $number = Helpers::randomStr()),
            [
                'type' => CorrectionTypes::SELF,
--- a/tests/AtolOnline/Tests/Entities/ItemTest.php
+++ b/tests/AtolOnline/Tests/Entities/ItemTest.php
@ -71,7 +71,7 @@ class ItemTest extends BasicTestCase
     */
    public function testConstructor(): void
    {
-        $this->assertIsAtolable(
+        $this->assertAtolable(
            new Item('test item', 2, 3),
            [
                'name' => 'test item',
@ -277,7 +277,7 @@ class ItemTest extends BasicTestCase
            PaymentObjects::COMMODITY,
            $item->setPaymentObject(PaymentObjects::COMMODITY)->getPaymentObject()
        );
-        $this->assertIsAtolable($item, [
+        $this->assertAtolable($item, [
            'name' => 'test item',
            'price' => 2,
            'quantity' => 3,
@ -349,7 +349,7 @@ class ItemTest extends BasicTestCase
        $this->assertIsSameClass(Vat::class, $item->getVat());
        $this->assertEquals(VatTypes::VAT20, $item->getVat()->getType());
        $this->assertEquals($item->getSum(), $item->getVat()->getSum());
-        $this->assertIsAtolable($item, [
+        $this->assertAtolable($item, [
            'name' => 'test item',
            'price' => 2,
            'quantity' => 3,
@ -384,7 +384,7 @@ class ItemTest extends BasicTestCase
        $this->assertIsSameClass(Vat::class, $item->getVat());
        $this->assertEquals(VatTypes::VAT20, $item->getVat()->getType());
        $this->assertEquals($item->getSum(), $item->getVat()->getSum());
-        $this->assertIsAtolable($item, [
+        $this->assertAtolable($item, [
            'name' => 'test item',
            'price' => 2,
            'quantity' => 3,
@ -472,7 +472,7 @@ class ItemTest extends BasicTestCase
        );
        $item = (new Item('test item', 2, 3))->setSupplier($supplier);
        $this->assertEquals($supplier, $item->getSupplier());
-        $this->assertIsAtolable($item, [
+        $this->assertAtolable($item, [
            'name' => 'test item',
            'price' => 2,
            'quantity' => 3,
@ -502,7 +502,7 @@ class ItemTest extends BasicTestCase
     */
    public function testValidUserdata(): void
    {
-        $this->assertIsAtolable(
+        $this->assertAtolable(
            (new Item('test item', 2, 3))
                ->setUserData($user_data = Helpers::randomStr(Constraints::MAX_LENGTH_USER_DATA)),
            [
@ -572,7 +572,7 @@ class ItemTest extends BasicTestCase
     */
    public function testCountryCode(): void
    {
-        $this->assertIsAtolable(
+        $this->assertAtolable(
            (new Item('test item', 2, 3))->setCountryCode('800'),
            [
                'name' => 'test item',
@ -620,7 +620,7 @@ class ItemTest extends BasicTestCase
     */
    public function testValidDeclarationNumber(): void
    {
-        $this->assertIsAtolable(
+        $this->assertAtolable(
            (new Item('test item', 2, 3))
                ->setDeclarationNumber($code = Helpers::randomStr()),
            [
@ -691,7 +691,7 @@ class ItemTest extends BasicTestCase
     */
    public function testExcise(): void
    {
-        $this->assertIsAtolable(
+        $this->assertAtolable(
            (new Item('test item', 2, 3))->setExcise(1),
            [
                'name' => 'test item',
@ -750,7 +750,7 @@ class ItemTest extends BasicTestCase
        $decoded = hex2bin(str_replace(' ', '', $item->getCodeHex()));
        $this->assertEquals($decoded, $item->getCode());

-        $this->assertIsAtolable($item, [
+        $this->assertAtolable($item, [
            'name' => 'test item',
            'price' => 2,
            'quantity' => 3,
--- a/tests/AtolOnline/Tests/Entities/KktEntityTest.php
+++ b/tests/AtolOnline/Tests/Entities/KktEntityTest.php
@ -57,7 +57,7 @@ class KktEntityTest extends BasicTestCase
    {
        $kkt = new Kkt((object)$this->sample_data);
        $this->assertIsSameClass(Kkt::class, $kkt);
-        $this->assertIsAtolable($kkt);
+        $this->assertAtolable($kkt);
    }

    /**
--- a/tests/AtolOnline/Tests/Entities/MoneyTransferOperatorTest.php
+++ b/tests/AtolOnline/Tests/Entities/MoneyTransferOperatorTest.php
@ -51,11 +51,11 @@ class MoneyTransferOperatorTest extends BasicTestCase
     */
    public function testConstructorWithArgs(): void
    {
-        $this->assertIsAtolable(new MoneyTransferOperator('some name'), ['name' => 'some name']);
-        $this->assertIsAtolable(new MoneyTransferOperator(inn: '+fasd3\qe3fs_=nac99013928czc'), ['inn' => '3399013928']);
-        $this->assertIsAtolable(new MoneyTransferOperator(address: 'London'), ['address' => 'London']);
-        $this->assertIsAtolable(new MoneyTransferOperator(phones: ['+122997365456']), ['phones' => ['+122997365456']]);
-        $this->assertIsAtolable(new MoneyTransferOperator(
+        $this->assertAtolable(new MoneyTransferOperator('some name'), ['name' => 'some name']);
+        $this->assertAtolable(new MoneyTransferOperator(inn: '+fasd3\qe3fs_=nac99013928czc'), ['inn' => '3399013928']);
+        $this->assertAtolable(new MoneyTransferOperator(address: 'London'), ['address' => 'London']);
+        $this->assertAtolable(new MoneyTransferOperator(phones: ['+122997365456']), ['phones' => ['+122997365456']]);
+        $this->assertAtolable(new MoneyTransferOperator(
            'some name',
            '+fasd3\qe3fs_=nac99013928czc',
            'London',
--- a/tests/AtolOnline/Tests/Entities/PayingAgentTest.php
+++ b/tests/AtolOnline/Tests/Entities/PayingAgentTest.php
@ -49,18 +49,18 @@ class PayingAgentTest extends BasicTestCase
    public function testConstructorWithArgs(): void
    {
        $operation = Helpers::randomStr();
-        $this->assertIsAtolable(new PayingAgent(
+        $this->assertAtolable(new PayingAgent(
            $operation,
            ['+122997365456'],
        ), [
            'operation' => $operation,
            'phones' => ['+122997365456'],
        ]);
-        $this->assertIsAtolable(
+        $this->assertAtolable(
            new PayingAgent($operation),
            ['operation' => $operation]
        );
-        $this->assertIsAtolable(
+        $this->assertAtolable(
            new PayingAgent(phones: ['+122997365456']),
            ['phones' => ['+122997365456']]
        );
--- a/tests/AtolOnline/Tests/Entities/PaymentTest.php
+++ b/tests/AtolOnline/Tests/Entities/PaymentTest.php
@ -42,7 +42,7 @@ class PaymentTest extends BasicTestCase
     */
    public function testConstructor(): void
    {
-        $this->assertIsAtolable(
+        $this->assertAtolable(
            new Payment(PaymentTypes::ELECTRON, 123.456789),
            [
                'type' => PaymentTypes::ELECTRON,
--- a/tests/AtolOnline/Tests/Entities/ReceiptTest.php
+++ b/tests/AtolOnline/Tests/Entities/ReceiptTest.php
@ -1,259 +0,0 @@
-<?php
-/*
- * Copyright (c) 2020-2021 Антон Аксенов (Anthony Axenov)
- *
- * This code is licensed under MIT.
- * Этот код распространяется по лицензии MIT.
- * https://github.com/anthonyaxenov/atol-online/blob/master/LICENSE
- */
-
-namespace AtolOnline\Tests\Entities;
-
-use AtolOnline\{
-    Collections\Items,
-    Collections\Payments,
-    Entities\AgentInfo,
-    Entities\Client,
-    Entities\Company,
-    Entities\Item,
-    Entities\MoneyTransferOperator,
-    Entities\PayingAgent,
-    Entities\Receipt,
-    Entities\ReceivePaymentsOperator,
-    Enums\AgentTypes,
-    Enums\SnoTypes,
-    Tests\BasicTestCase};
-use AtolOnline\Exceptions\{
-    EmptyItemNameException,
-    EmptyItemsException,
-    EmptyPaymentsException,
-    InvalidEntityInCollectionException,
-    InvalidEnumValueException,
-    InvalidInnLengthException,
-    InvalidPhoneException,
-    NegativeItemPriceException,
-    NegativeItemQuantityException,
-    NegativePaymentSumException,
-    TooHighItemPriceException,
-    TooHighPaymentSumException,
-    TooLongItemNameException,
-    TooLongPayingAgentOperationException,
-    TooManyException};
-use Exception;
-
-/**
- * Набор тестов для проверки работы класса чека прихода, расхода, возврата прихода, возврата расхода
- */
-class ReceiptTest extends BasicTestCase
-{
-    /**
-     * Тестирует конструктор и корректное приведение к json
-     *
-     * @covers \AtolOnline\Entities\Receipt
-     * @covers \AtolOnline\Entities\Receipt::setClient
-     * @covers \AtolOnline\Entities\Receipt::setCompany
-     * @covers \AtolOnline\Entities\Receipt::setItems
-     * @covers \AtolOnline\Entities\Receipt::setPayments
-     * @covers \AtolOnline\Entities\Receipt::getClient
-     * @covers \AtolOnline\Entities\Receipt::getCompany
-     * @covers \AtolOnline\Entities\Receipt::getItems
-     * @covers \AtolOnline\Entities\Receipt::getPayments
-     * @covers \AtolOnline\Entities\Receipt::getTotal
-     * @covers \AtolOnline\Entities\Receipt::jsonSerialize
-     * @throws TooHighItemPriceException
-     * @throws NegativePaymentSumException
-     * @throws NegativeItemPriceException
-     * @throws EmptyPaymentsException
-     * @throws TooHighPaymentSumException
-     * @throws EmptyItemsException
-     * @throws EmptyItemNameException
-     * @throws TooManyException
-     * @throws InvalidEnumValueException
-     * @throws InvalidEntityInCollectionException
-     * @throws TooLongItemNameException
-     * @throws NegativeItemQuantityException
-     * @throws Exception
-     */
-    public function testConstructor(): void
-    {
-        $receipt = $this->validReceipt();
-        $this->assertIsAtolable($receipt);
-    }
-
-    /**
-     * Тестирует установку данных агента
-     *
-     * @return void
-     * @covers \AtolOnline\Entities\Receipt::setAgentInfo
-     * @covers \AtolOnline\Entities\Receipt::getAgentInfo
-     * @covers \AtolOnline\Entities\Receipt::jsonSerialize
-     * @throws EmptyItemNameException
-     * @throws EmptyItemsException
-     * @throws EmptyPaymentsException
-     * @throws InvalidEntityInCollectionException
-     * @throws InvalidEnumValueException
-     * @throws NegativeItemPriceException
-     * @throws NegativeItemQuantityException
-     * @throws NegativePaymentSumException
-     * @throws TooHighItemPriceException
-     * @throws TooHighPaymentSumException
-     * @throws TooLongItemNameException
-     * @throws TooManyException
-     * @throws InvalidInnLengthException
-     * @throws InvalidPhoneException
-     * @throws TooLongPayingAgentOperationException
-     * @throws Exception
-     */
-    public function testSetAgentInfo(): void
-    {
-        $agent_info = new AgentInfo(
-            AgentTypes::ANOTHER,
-            new PayingAgent('test', ['+79518888888']),
-            new ReceivePaymentsOperator(['+79519999999']),
-            new MoneyTransferOperator('MTO Name', '9876543210', 'London', ['+79517777777']),
-        );
-        $receipt = $this->validReceipt()->setAgentInfo($agent_info);
-        $this->assertArrayHasKey('agent_info', $receipt->jsonSerialize());
-        $this->assertEquals($receipt->getAgentInfo(), $receipt->jsonSerialize()['agent_info']);
-    }
-
-    /**
-     * Тестирует выброс исключения при передаче пустой коллекции предметов расчёта
-     *
-     * @return void
-     * @covers \AtolOnline\Entities\Receipt
-     * @covers \AtolOnline\Entities\Receipt::setVats
-     * @covers \AtolOnline\Collections\Items::checkCount
-     * @covers \AtolOnline\Exceptions\EmptyItemsException
-     * @throws InvalidEnumValueException
-     * @throws NegativePaymentSumException
-     * @throws TooHighPaymentSumException
-     * @throws InvalidEntityInCollectionException
-     * @throws EmptyPaymentsException
-     */
-    public function testEmptyItemsException(): void
-    {
-        $this->expectException(EmptyItemsException::class);
-        new Receipt(
-            new Client('John Doe', 'john@example.com', '+1/22/99*73s dsdas654 5s6', '+fasd3\qe3fs_=nac99013928czc'),
-            new Company('company@example.com', SnoTypes::OSN, '1234567890', 'https://example.com'),
-            new Items([]),
-            new Payments($this->generatePaymentObjects())
-        );
-    }
-
-    /**
-     * Тестирует выброс исключения при передаче коллекции предметов расчёта с некорректным содержимым
-     *
-     * @return void
-     * @covers \AtolOnline\Entities\Receipt
-     * @covers \AtolOnline\Entities\Receipt::setVats
-     * @covers \AtolOnline\Collections\Items::checkItemsClasses
-     * @covers \AtolOnline\Collections\Items::checkItemClass
-     * @covers \AtolOnline\Exceptions\InvalidEntityInCollectionException
-     * @throws EmptyItemsException
-     * @throws EmptyPaymentsException
-     * @throws InvalidEntityInCollectionException
-     * @throws InvalidEnumValueException
-     * @throws NegativePaymentSumException
-     * @throws TooHighPaymentSumException
-     */
-    public function testInvalidItemInCollectionException(): void
-    {
-        $this->expectException(InvalidEntityInCollectionException::class);
-        $this->expectErrorMessage('Коллекция AtolOnline\Collections\Items должна содержать объекты AtolOnline\Entities\Item');
-        new Receipt(
-            new Client('John Doe', 'john@example.com', '+1/22/99*73s dsdas654 5s6', '+fasd3\qe3fs_=nac99013928czc'),
-            new Company('company@example.com', SnoTypes::OSN, '1234567890', 'https://example.com'),
-            new Items(['qwerty']),
-            new Payments($this->generatePaymentObjects())
-        );
-    }
-
-    /**
-     * Тестирует выброс исключения при передаче пустой коллекции оплат
-     *
-     * @return void
-     * @covers \AtolOnline\Entities\Receipt
-     * @covers \AtolOnline\Entities\Receipt::setPayments
-     * @covers \AtolOnline\Collections\Payments::checkCount
-     * @covers \AtolOnline\Exceptions\EmptyPaymentsException
-     * @throws TooHighPaymentSumException
-     * @throws EmptyItemNameException
-     * @throws NegativeItemPriceException
-     * @throws NegativeItemQuantityException
-     * @throws TooHighItemPriceException
-     * @throws TooLongItemNameException
-     * @throws TooManyException
-     * @throws InvalidEntityInCollectionException
-     * @throws EmptyItemsException
-     */
-    public function testEmptyPaymentsException(): void
-    {
-        $this->expectException(EmptyPaymentsException::class);
-        new Receipt(
-            new Client('John Doe', 'john@example.com', '+1/22/99*73s dsdas654 5s6', '+fasd3\qe3fs_=nac99013928czc'),
-            new Company('company@example.com', SnoTypes::OSN, '1234567890', 'https://example.com'),
-            new Items([new Item('test item', 2, 3)]),
-            new Payments([])
-        );
-    }
-
-    /**
-     * Тестирует выброс исключения при передаче коллекции предметов расчёта с некорректным содержимым
-     *
-     * @return void
-     * @covers \AtolOnline\Entities\Receipt
-     * @covers \AtolOnline\Entities\Receipt::setVats
-     * @covers \AtolOnline\Collections\Items::checkItemsClasses
-     * @covers \AtolOnline\Collections\Items::checkItemClass
-     * @covers \AtolOnline\Exceptions\InvalidEntityInCollectionException
-     * @throws EmptyItemNameException
-     * @throws EmptyItemsException
-     * @throws EmptyPaymentsException
-     * @throws InvalidEntityInCollectionException
-     * @throws NegativeItemPriceException
-     * @throws NegativeItemQuantityException
-     * @throws TooHighItemPriceException
-     * @throws TooLongItemNameException
-     * @throws TooManyException
-     */
-    public function testInvalidPaymentInCollectionException(): void
-    {
-        $this->expectException(InvalidEntityInCollectionException::class);
-        $this->expectErrorMessage('Коллекция AtolOnline\Collections\Payments должна содержать объекты AtolOnline\Entities\Payment');
-        new Receipt(
-            new Client('John Doe', 'john@example.com', '+1/22/99*73s dsdas654 5s6', '+fasd3\qe3fs_=nac99013928czc'),
-            new Company('company@example.com', SnoTypes::OSN, '1234567890', 'https://example.com'),
-            new Items([new Item('test item', 2, 3)]),
-            new Payments(['qwerty'])
-        );
-    }
-
-    /**
-     * Возвращает валидный тестовый объект чека
-     *
-     * @return Receipt
-     * @throws EmptyItemNameException
-     * @throws EmptyItemsException
-     * @throws EmptyPaymentsException
-     * @throws InvalidEntityInCollectionException
-     * @throws InvalidEnumValueException
-     * @throws NegativeItemPriceException
-     * @throws NegativeItemQuantityException
-     * @throws NegativePaymentSumException
-     * @throws TooHighItemPriceException
-     * @throws TooHighPaymentSumException
-     * @throws TooLongItemNameException
-     * @throws TooManyException
-     */
-    protected function validReceipt(): Receipt
-    {
-        return new Receipt(
-            new Client('John Doe', 'john@example.com', '+1/22/99*73s dsdas654 5s6', '+fasd3\qe3fs_=nac99013928czc'),
-            new Company('company@example.com', SnoTypes::OSN, '1234567890', 'https://example.com'),
-            new Items($this->generateItemObjects()),
-            new Payments($this->generatePaymentObjects())
-        );
-    }
-}
--- a/tests/AtolOnline/Tests/Entities/ReceivePaymentsOperatorTest.php
+++ b/tests/AtolOnline/Tests/Entities/ReceivePaymentsOperatorTest.php
@ -43,7 +43,7 @@ class ReceivePaymentsOperatorTest extends BasicTestCase
     */
    public function testConstructorWithArgs(): void
    {
-        $this->assertIsAtolable(new ReceivePaymentsOperator(['+122997365456']), ['phones' => ['+122997365456']]);
+        $this->assertAtolable(new ReceivePaymentsOperator(['+122997365456']), ['phones' => ['+122997365456']]);
    }

    /**
--- a/tests/AtolOnline/Tests/Entities/SupplierTest.php
+++ b/tests/AtolOnline/Tests/Entities/SupplierTest.php
@ -49,10 +49,10 @@ class SupplierTest extends BasicTestCase
     */
    public function testConstructorWithArgs(): void
    {
-        $this->assertIsAtolable(new Supplier('some name'), ['name' => 'some name']);
-        $this->assertIsAtolable(new Supplier(inn: '+fasd3\qe3fs_=nac99013928czc'), ['inn' => '3399013928']);
-        $this->assertIsAtolable(new Supplier(phones: ['+122997365456']), ['phones' => ['+122997365456']]);
-        $this->assertIsAtolable(new Supplier(
+        $this->assertAtolable(new Supplier('some name'), ['name' => 'some name']);
+        $this->assertAtolable(new Supplier(inn: '+fasd3\qe3fs_=nac99013928czc'), ['inn' => '3399013928']);
+        $this->assertAtolable(new Supplier(phones: ['+122997365456']), ['phones' => ['+122997365456']]);
+        $this->assertAtolable(new Supplier(
            'some name',
            '+fasd3\qe3fs_=nac99013928czc',
            ['+122997365456'],
--- a/tests/AtolOnline/Tests/Entities/VatTest.php
+++ b/tests/AtolOnline/Tests/Entities/VatTest.php
@ -76,7 +76,7 @@ class VatTest extends BasicTestCase
    public function testConstructor(string $type, float $sum): void
    {
        $vat = new Vat($type, $sum);
-        $this->assertIsAtolable($vat, [
+        $this->assertAtolable($vat, [
            'type' => $vat->getType(),
            'sum' => $vat->getCalculated(),
        ]);