Вторая итерация Receipt

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

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

    /**
-     * Проверяет количество ставок
+     * Проверяет количество элементов коллекции
     *
     * @param array $items Массив элементов, если пустой - проверит содержимое коллекции
     * @return void
     */
-    private function checkCount(array $items = []): void
+    public 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,14 +91,24 @@ abstract class EntityCollection extends Collection
    }

    /**
-     * Проверяет корректность класса объекта
+     * Проверяет корректность класса элемента коллекции
     *
     * @throws InvalidEntityInCollectionException
     */
-    private function checkClass(mixed $item): void
+    public function checkItemClass(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,7 +15,10 @@ use AtolOnline\Collections\Items;
 use AtolOnline\Collections\Payments;
 use AtolOnline\Collections\Vats;
 use AtolOnline\Constants\Constraints;
-use AtolOnline\Exceptions\TooHighPriceException;
+use AtolOnline\Exceptions\EmptyItemsException;
+use AtolOnline\Exceptions\EmptyPaymentsException;
+use AtolOnline\Exceptions\EmptyVatsException;
+use AtolOnline\Exceptions\InvalidEntityInCollectionException;
 use AtolOnline\Exceptions\TooLongAddCheckPropException;
 use AtolOnline\Exceptions\TooLongCashierException;
 use Exception;
@ -75,22 +78,26 @@ class Receipt extends Entity
    /**
     * @var string|null Дополнительный реквизит
     */
-    protected ?string $add_check_props;
+    protected ?string $add_check_props = null;

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

    /**
     * Конструктор
+     *
+     * @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);
    }

@ -141,7 +148,7 @@ class Receipt extends Entity
    /**
     * Возвращает установленного агента
     *
-     * @return AgentInfo
+     * @return AgentInfo|null
     */
    public function getAgentInfo(): ?AgentInfo
    {
@ -198,9 +205,15 @@ 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;
    }
@ -218,12 +231,15 @@ 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;
    }
@ -243,9 +259,13 @@ 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;
    }
@ -297,7 +317,7 @@ class Receipt extends Entity
                throw new TooLongCashierException($cashier);
            }
        }
-        $this->cashier = empty($cashier) ? null : $cashier;
+        $this->cashier = $cashier ?: null;
        return $this;
    }

@ -364,7 +384,7 @@ class Receipt extends Entity
            'company' => $this->getCompany(),
            'items' => $this->getItems(),
            'total' => $this->getTotal(),
-            'payment' => $this->getPayments(),
+            'payments' => $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
@ -0,0 +1,22 @@
+<?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
@ -0,0 +1,22 @@
+<?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
@ -0,0 +1,22 @@
+<?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->assertAtolable($kkt);
+        $this->assertIsAtolable($kkt);
        $this->assertNotNull($kkt->serialNumber);
        $this->assertEquals($serial_number, $kkt->serialNumber);
    }
--- a/tests/AtolOnline/Tests/BasicTestCase.php
+++ b/tests/AtolOnline/Tests/BasicTestCase.php
@ -13,6 +13,20 @@ 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;
@ -25,6 +39,10 @@ use PHPUnit\Framework\TestCase;
 */
 class BasicTestCase extends TestCase
 {
+    //------------------------------------------------------------------------------------------------------------------
+    // Методы для управления тестами, использующими тестовый АТОЛ API
+    //------------------------------------------------------------------------------------------------------------------
+
    /**
     * Проверяет наличие подключения к ресурсу по URL
     *
@ -65,6 +83,10 @@ class BasicTestCase extends TestCase
        }
    }

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

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

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

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

    /**
@ -288,4 +314,74 @@ 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,18 +12,16 @@ 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,};
-use Exception;
+    TooManyItemsException};

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

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

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

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

    /**
@ -124,33 +126,12 @@ class ItemsTest extends BasicTestCase
     * @throws TooHighItemPriceException
     * @throws TooLongItemNameException
     * @throws TooManyException
+     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyItemsExceptionByMerge()
    {
        $this->expectException(TooManyItemsException::class);
-        (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;
+        (new Items($this->generateItemObjects(Constraints::MAX_COUNT_DOC_ITEMS)))
+            ->merge($this->generateItemObjects(2));
    }
 }
--- a/tests/AtolOnline/Tests/Collections/PaymentsTest.php
+++ b/tests/AtolOnline/Tests/Collections/PaymentsTest.php
@ -12,14 +12,12 @@ namespace AtolOnline\Tests\Collections;
 use AtolOnline\{
    Collections\Payments,
    Constants\Constraints,
-    Entities\Payment,
-    Enums\PaymentTypes,
+    Exceptions\InvalidEntityInCollectionException,
    Exceptions\InvalidEnumValueException,
    Exceptions\NegativePaymentSumException,
    Exceptions\TooHighPaymentSumException,
    Exceptions\TooManyPaymentsException,
    Tests\BasicTestCase};
-use Exception;

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

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

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

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

    /**
@ -105,34 +107,12 @@ class PaymentsTest extends BasicTestCase
     * @throws InvalidEnumValueException
     * @throws NegativePaymentSumException
     * @throws TooHighPaymentSumException
+     * @throws InvalidEntityInCollectionException
     */
    public function testTooManyPaymentsExceptionByMerge()
    {
        $this->expectException(TooManyPaymentsException::class);
-        (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;
+        (new Payments($this->generatePaymentObjects(Constraints::MAX_COUNT_DOC_PAYMENTS - 1)))
+            ->merge($this->generatePaymentObjects(2));
    }
 }
--- a/tests/AtolOnline/Tests/Collections/VatsTest.php
+++ b/tests/AtolOnline/Tests/Collections/VatsTest.php
@ -13,9 +13,7 @@ use AtolOnline\{
    Collections\Vats,
    Constants\Constraints,
    Entities\Payment,
-    Entities\Vat,
    Enums\PaymentTypes,
-    Enums\VatTypes,
    Exceptions\InvalidEntityInCollectionException,
    Exceptions\InvalidEnumValueException,
    Exceptions\NegativePaymentSumException,
@ -39,10 +37,10 @@ class VatsTest extends BasicTestCase
     */
    public function testConstructor()
    {
-        $vats = new Vats($this->generateObjects(3));
+        $vats = new Vats($this->generateVatObjects(3));
        $this->assertIsCollection($vats);
        $this->assertEquals(3, $vats->count());
-        $this->assertAtolable($vats);
+        $this->assertIsAtolable($vats);
    }

    /**
@ -52,11 +50,12 @@ 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->generateObjects(Constraints::MAX_COUNT_DOC_VATS + 1));
+        new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS + 1));
    }

    /**
@ -66,11 +65,12 @@ 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->generateObjects(3)))
-            ->prepend($this->generateObjects());
+        $vats = (new Vats($this->generateVatObjects(3)))
+            ->prepend($this->generateVatObjects());
        $this->assertEquals(4, $vats->count());
    }

@ -82,12 +82,13 @@ 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->generateObjects(Constraints::MAX_COUNT_DOC_VATS)))
-            ->prepend($this->generateObjects());
+        (new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS)))
+            ->prepend($this->generateVatObjects());
    }

    /**
@ -97,11 +98,12 @@ 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->generateObjects(3)))
-            ->add($this->generateObjects());
+        $vats = (new Vats($this->generateVatObjects(3)))
+            ->add($this->generateVatObjects());
        $this->assertEquals(4, $vats->count());
    }

@ -113,12 +115,13 @@ 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->generateObjects(Constraints::MAX_COUNT_DOC_VATS)))
-            ->add($this->generateObjects());
+        (new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS)))
+            ->add($this->generateVatObjects());
    }

    /**
@ -128,11 +131,12 @@ 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->generateObjects(3)))
-            ->push(...$this->generateObjects(3));
+        $vats = (new Vats($this->generateVatObjects(3)))
+            ->push(...$this->generateVatObjects(3));
        $this->assertEquals(6, $vats->count());
    }

@ -144,12 +148,13 @@ 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->generateObjects(Constraints::MAX_COUNT_DOC_VATS)))
-            ->push(...$this->generateObjects());
+        (new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS)))
+            ->push(...$this->generateVatObjects());
    }

    /**
@ -159,11 +164,12 @@ 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->generateObjects(3)))
-            ->merge($this->generateObjects(3));
+        $vats = (new Vats($this->generateVatObjects(3)))
+            ->merge($this->generateVatObjects(3));
        $this->assertEquals(6, $vats->count());
    }

@ -175,19 +181,20 @@ 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->generateObjects(Constraints::MAX_COUNT_DOC_VATS - 1)))
-            ->merge($this->generateObjects(2));
+        (new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS - 1)))
+            ->merge($this->generateVatObjects(2));
    }

    /**
     * Тестирует выброс исключения при наличии скаляров в коллекции
     *
     * @covers \AtolOnline\Collections\EntityCollection
-     * @covers \AtolOnline\Collections\EntityCollection::checkClass
+     * @covers \AtolOnline\Collections\EntityCollection::checkItemClass
     * @covers \AtolOnline\Collections\EntityCollection::jsonSerialize
     * @covers \AtolOnline\Exceptions\InvalidEntityInCollectionException
     * @throws InvalidEnumValueException
@ -197,7 +204,7 @@ class VatsTest extends BasicTestCase
    {
        $this->expectException(InvalidEntityInCollectionException::class);
        $this->expectExceptionMessage("(string)'bad element'");
-        (new Vats($this->generateObjects(2)))
+        (new Vats($this->generateVatObjects(2)))
            ->merge('bad element')
            ->jsonSerialize();
    }
@ -214,29 +221,8 @@ class VatsTest extends BasicTestCase
    {
        $this->expectException(InvalidEntityInCollectionException::class);
        $this->expectExceptionMessage(Payment::class);
-        (new Vats($this->generateObjects()))
+        (new Vats($this->generateVatObjects()))
            ->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->assertAtolable(
+        $this->assertIsAtolable(
            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->assertAtolable(new AgentInfo(), []);
+        $this->assertIsAtolable(new AgentInfo(), []);
    }

    /**
@ -63,20 +63,20 @@ class AgentInfoTest extends BasicTestCase
     */
    public function testConstructorWithArgs(): void
    {
-        $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(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(
+        $this->assertIsAtolable(new AgentInfo(
            AgentTypes::ANOTHER,
            new PayingAgent(),
            new ReceivePaymentsOperator(),
            new MoneyTransferOperator(),
        ), ['type' => AgentTypes::ANOTHER]);

-        $this->assertAtolable(new AgentInfo(
+        $this->assertIsAtolable(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->assertAtolable(new Client(), []);
+        $this->assertIsAtolable(new Client(), []);
    }

    /**
@ -54,11 +54,11 @@ class ClientTest extends BasicTestCase
     */
    public function testConstructorWithArgs(): void
    {
-        $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(
+        $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(
            '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->assertAtolable(new Company(
+        $this->assertIsAtolable(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->assertAtolable(
+        $this->assertIsAtolable(
            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->assertAtolable(
+        $this->assertIsAtolable(
            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->assertAtolable($item, [
+        $this->assertIsAtolable($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->assertAtolable($item, [
+        $this->assertIsAtolable($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->assertAtolable($item, [
+        $this->assertIsAtolable($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->assertAtolable($item, [
+        $this->assertIsAtolable($item, [
            'name' => 'test item',
            'price' => 2,
            'quantity' => 3,
@ -502,7 +502,7 @@ class ItemTest extends BasicTestCase
     */
    public function testValidUserdata(): void
    {
-        $this->assertAtolable(
+        $this->assertIsAtolable(
            (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->assertAtolable(
+        $this->assertIsAtolable(
            (new Item('test item', 2, 3))->setCountryCode('800'),
            [
                'name' => 'test item',
@ -620,7 +620,7 @@ class ItemTest extends BasicTestCase
     */
    public function testValidDeclarationNumber(): void
    {
-        $this->assertAtolable(
+        $this->assertIsAtolable(
            (new Item('test item', 2, 3))
                ->setDeclarationNumber($code = Helpers::randomStr()),
            [
@ -691,7 +691,7 @@ class ItemTest extends BasicTestCase
     */
    public function testExcise(): void
    {
-        $this->assertAtolable(
+        $this->assertIsAtolable(
            (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->assertAtolable($item, [
+        $this->assertIsAtolable($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->assertAtolable($kkt);
+        $this->assertIsAtolable($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->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(
+        $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(
            '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->assertAtolable(new PayingAgent(
+        $this->assertIsAtolable(new PayingAgent(
            $operation,
            ['+122997365456'],
        ), [
            'operation' => $operation,
            'phones' => ['+122997365456'],
        ]);
-        $this->assertAtolable(
+        $this->assertIsAtolable(
            new PayingAgent($operation),
            ['operation' => $operation]
        );
-        $this->assertAtolable(
+        $this->assertIsAtolable(
            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->assertAtolable(
+        $this->assertIsAtolable(
            new Payment(PaymentTypes::ELECTRON, 123.456789),
            [
                'type' => PaymentTypes::ELECTRON,
--- a/tests/AtolOnline/Tests/Entities/ReceiptTest.php
+++ b/tests/AtolOnline/Tests/Entities/ReceiptTest.php
@ -0,0 +1,259 @@
+<?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->assertAtolable(new ReceivePaymentsOperator(['+122997365456']), ['phones' => ['+122997365456']]);
+        $this->assertIsAtolable(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->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(
+        $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(
            '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->assertAtolable($vat, [
+        $this->assertIsAtolable($vat, [
            'type' => $vat->getType(),
            'sum' => $vat->getCalculated(),
        ]);