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

- фикс nullable-свойств и геттеров
- проверка на пустоту в `setPayments()`, `setItems()` и `setVats()`
- часть тестов с покрытием (конструктор, агент, исключения при пустых коллекциях)

src/Api/KktMonitor.php

@@ -100,7 +100,6 @@ class KktMonitor extends AtolClient
     /**
      * Возвращает информацию о конкретной ККТ по её серийному номеру
      *
-     * @todo кастовать к отдельному классу со своими геттерами
      * @param string $serial_number
      * @return Kkt
      * @throws GuzzleException

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->checkItemsClasses();
-            $this->checkClass($item);
-        });
         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));
+    }
 }

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(
+    public function __construct(Client $client, Company $company, Items $items, Payments $payments)
-        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();

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 = 'Документ не может содержать пустую коллекцию предметов расчёта';
+}

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 = 'Документ не может содержать пустую коллекцию оплат';
+}

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 = 'Документ не может содержать пустую коллекцию ставок НДС';
+}

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);
     }

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;
+    }
 }

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,};
+    TooManyItemsException};
-use Exception;
 
 /**
  * Набор тестов для проверки работы класса коллекции предметов расчёта
@@ -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)))
+        (new Items($this->generateItemObjects(Constraints::MAX_COUNT_DOC_ITEMS)))
-            ->prepend($this->generateObjects());
+            ->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)))
+        (new Items($this->generateItemObjects(Constraints::MAX_COUNT_DOC_ITEMS)))
-            ->add($this->generateObjects());
+            ->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)))
+        (new Items($this->generateItemObjects(Constraints::MAX_COUNT_DOC_ITEMS)))
-            ->push(...$this->generateObjects());
+            ->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)))
+        (new Items($this->generateItemObjects(Constraints::MAX_COUNT_DOC_ITEMS)))
-            ->merge($this->generateObjects(2));
+            ->merge($this->generateItemObjects(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;
     }
 }

tests/AtolOnline/Tests/Collections/PaymentsTest.php

@@ -12,14 +12,12 @@ namespace AtolOnline\Tests\Collections;
 use AtolOnline\{
     Collections\Payments,
     Constants\Constraints,
-    Entities\Payment,
+    Exceptions\InvalidEntityInCollectionException,
-    Enums\PaymentTypes,
     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)))
+        (new Payments($this->generatePaymentObjects(Constraints::MAX_COUNT_DOC_PAYMENTS)))
-            ->prepend($this->generateObjects());
+            ->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)))
+        (new Payments($this->generatePaymentObjects(Constraints::MAX_COUNT_DOC_PAYMENTS)))
-            ->add($this->generateObjects());
+            ->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)))
+        (new Payments($this->generatePaymentObjects(Constraints::MAX_COUNT_DOC_PAYMENTS + 1)))
-            ->push(...$this->generateObjects());
+            ->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)))
+        (new Payments($this->generatePaymentObjects(Constraints::MAX_COUNT_DOC_PAYMENTS - 1)))
-            ->merge($this->generateObjects(2));
+            ->merge($this->generatePaymentObjects(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;
     }
 }

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)))
+        $vats = (new Vats($this->generateVatObjects(3)))
-            ->prepend($this->generateObjects());
+            ->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)))
+        (new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS)))
-            ->prepend($this->generateObjects());
+            ->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)))
+        $vats = (new Vats($this->generateVatObjects(3)))
-            ->add($this->generateObjects());
+            ->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)))
+        (new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS)))
-            ->add($this->generateObjects());
+            ->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)))
+        $vats = (new Vats($this->generateVatObjects(3)))
-            ->push(...$this->generateObjects(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)))
+        (new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS)))
-            ->push(...$this->generateObjects());
+            ->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)))
+        $vats = (new Vats($this->generateVatObjects(3)))
-            ->merge($this->generateObjects(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)))
+        (new Vats($this->generateVatObjects(Constraints::MAX_COUNT_DOC_VATS - 1)))
-            ->merge($this->generateObjects(2));
+            ->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;
-    }
 }

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',

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->assertIsAtolable(new AgentInfo(null), []);
-        $this->assertAtolable(new AgentInfo(AgentTypes::ANOTHER), ['type' => AgentTypes::ANOTHER]);
+        $this->assertIsAtolable(new AgentInfo(AgentTypes::ANOTHER), ['type' => AgentTypes::ANOTHER]);
-        $this->assertAtolable(new AgentInfo(pagent: new PayingAgent()), []);
+        $this->assertIsAtolable(new AgentInfo(pagent: new PayingAgent()), []);
-        $this->assertAtolable(new AgentInfo(mt_operator: new MoneyTransferOperator()), []);
+        $this->assertIsAtolable(new AgentInfo(mt_operator: new MoneyTransferOperator()), []);
-        $this->assertAtolable(new AgentInfo(rp_operator: new ReceivePaymentsOperator()), []);
+        $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']),

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->assertIsAtolable(new Client('John Doe'), ['name' => 'John Doe']);
-        $this->assertAtolable(new Client(email: 'john@example.com'), ['email' => 'john@example.com']);
+        $this->assertIsAtolable(new Client(email: 'john@example.com'), ['email' => 'john@example.com']);
-        $this->assertAtolable(new Client(phone: '+1/22/99*73s dsdas654 5s6'), ['phone' => '+122997365456']);
+        $this->assertIsAtolable(new Client(phone: '+1/22/99*73s dsdas654 5s6'), ['phone' => '+122997365456']);
-        $this->assertAtolable(new Client(inn: '+fasd3\qe3fs_=nac99013928czc'), ['inn' => '3399013928']);
+        $this->assertIsAtolable(new Client(inn: '+fasd3\qe3fs_=nac99013928czc'), ['inn' => '3399013928']);
-        $this->assertAtolable(new Client(
+        $this->assertIsAtolable(new Client(
             'John Doe',
             'john@example.com',
             '+1/22/99*73s dsdas654 5s6', // +122997365456

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',

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,

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,

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);
     }
 
     /**

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->assertIsAtolable(new MoneyTransferOperator('some name'), ['name' => 'some name']);
-        $this->assertAtolable(new MoneyTransferOperator(inn: '+fasd3\qe3fs_=nac99013928czc'), ['inn' => '3399013928']);
+        $this->assertIsAtolable(new MoneyTransferOperator(inn: '+fasd3\qe3fs_=nac99013928czc'), ['inn' => '3399013928']);
-        $this->assertAtolable(new MoneyTransferOperator(address: 'London'), ['address' => 'London']);
+        $this->assertIsAtolable(new MoneyTransferOperator(address: 'London'), ['address' => 'London']);
-        $this->assertAtolable(new MoneyTransferOperator(phones: ['+122997365456']), ['phones' => ['+122997365456']]);
+        $this->assertIsAtolable(new MoneyTransferOperator(phones: ['+122997365456']), ['phones' => ['+122997365456']]);
-        $this->assertAtolable(new MoneyTransferOperator(
+        $this->assertIsAtolable(new MoneyTransferOperator(
             'some name',
             '+fasd3\qe3fs_=nac99013928czc',
             'London',

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']]
         );

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,

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())
+        );
+    }
+}

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']]);
     }
 
     /**

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->assertIsAtolable(new Supplier('some name'), ['name' => 'some name']);
-        $this->assertAtolable(new Supplier(inn: '+fasd3\qe3fs_=nac99013928czc'), ['inn' => '3399013928']);
+        $this->assertIsAtolable(new Supplier(inn: '+fasd3\qe3fs_=nac99013928czc'), ['inn' => '3399013928']);
-        $this->assertAtolable(new Supplier(phones: ['+122997365456']), ['phones' => ['+122997365456']]);
+        $this->assertIsAtolable(new Supplier(phones: ['+122997365456']), ['phones' => ['+122997365456']]);
-        $this->assertAtolable(new Supplier(
+        $this->assertIsAtolable(new Supplier(
             'some name',
             '+fasd3\qe3fs_=nac99013928czc',
             ['+122997365456'],

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(),
         ]);