From 5ccb0e9db4e12195bfc775b2c795a2f4b43630b7 Mon Sep 17 00:00:00 2001 From: AnthonyAxenov Date: Wed, 1 Dec 2021 20:11:08 +0800 Subject: [PATCH] =?UTF-8?q?=D0=9A=D1=83=D1=87=D0=B0=D0=B4=20=D0=B4=D0=BE?= =?UTF-8?q?=D1=80=D0=B0=D0=B1=D0=BE=D1=82=D0=BE=D0=BA,=20=D0=B3=D0=BB?= =?UTF-8?q?=D0=B0=D0=B2=D0=BD=D1=8B=D0=BC=20=D0=BE=D0=B1=D1=80=D0=B0=D0=B7?= =?UTF-8?q?=D0=BE=D0=BC=20=D0=B2=D0=BE=D0=BA=D1=80=D1=83=D0=B3=20`Item`?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - `Item` почти готов и весь покрыт тестами. Пока остались нереализованными `nomenclature_code` и `excise` - `Client::setPhone()` теперь выбрасывает InvalidPhoneException - доработка и создание новых исключений (не буду все перечислять, смотри диффы) - мелочи по phpdoc и всяким текстовкам --- src/Constants/Constraints.php | 24 +- src/Constants/Ffd105Tags.php | 2 +- src/Entities/Client.php | 12 +- src/Entities/Document.php | 4 +- src/Entities/Item.php | 435 +++++++----- src/Exceptions/AtolException.php | 3 +- src/Exceptions/EmptyItemNameException.php | 25 + .../InvalidDeclarationNumberException.php | 32 + src/Exceptions/InvalidEnumValueException.php | 13 +- src/Exceptions/InvalidOKSMCodeException.php | 34 + src/Exceptions/NegativeItemPriceException.php | 33 + .../NegativeItemQuantityException.php | 33 + .../TooHighItemQuantityException.php | 35 + src/Exceptions/TooHighPriceException.php | 12 +- src/Exceptions/TooHighSumException.php | 35 + ...hp => TooLongMeasurementUnitException.php} | 2 +- src/Exceptions/TooManyException.php | 13 +- .../AtolOnline/Tests/Entities/ClientTest.php | 16 +- .../AtolOnline/Tests/Entities/CompanyTest.php | 5 +- tests/AtolOnline/Tests/Entities/ItemTest.php | 659 ++++++++++++++++++ .../Entities/MoneyTransferOperatorTest.php | 2 +- tests/ItemTest_todo.php | 163 ----- 22 files changed, 1232 insertions(+), 360 deletions(-) create mode 100644 src/Exceptions/EmptyItemNameException.php create mode 100644 src/Exceptions/InvalidDeclarationNumberException.php create mode 100644 src/Exceptions/InvalidOKSMCodeException.php create mode 100644 src/Exceptions/NegativeItemPriceException.php create mode 100644 src/Exceptions/NegativeItemQuantityException.php create mode 100644 src/Exceptions/TooHighItemQuantityException.php create mode 100644 src/Exceptions/TooHighSumException.php rename src/Exceptions/{TooLongUnitException.php => TooLongMeasurementUnitException.php} (93%) create mode 100644 tests/AtolOnline/Tests/Entities/ItemTest.php delete mode 100644 tests/ItemTest_todo.php diff --git a/src/Constants/Constraints.php b/src/Constants/Constraints.php index 2c17544..e3c1350 100644 --- a/src/Constants/Constraints.php +++ b/src/Constants/Constraints.php @@ -102,6 +102,20 @@ final class Constraints */ const MAX_LENGTH_USER_DATA = 64; + /** + * Минимальная длина кода таможенной декларации (1231) + * + * @see https://online.atol.ru/possystem/v4/schema/sell Схема receipt.items.declaration_number + */ + const MIN_LENGTH_DECLARATION_NUMBER = 1; + + /** + * Максимальная длина кода таможенной декларации (1231) + * + * @see https://online.atol.ru/files/API_atol_online_v4.pdf Документация, стр 30 + */ + const MAX_LENGTH_DECLARATION_NUMBER = 32; + /** * Максимальное количество платежей в любом документе * @see https://online.atol.ru/files/API_atol_online_v4.pdf Документация, стр 30 и 35 @@ -122,7 +136,7 @@ final class Constraints const MAX_LENGTH_CASHIER_NAME = 64; /** - * Регулярное выражание для валидации строки ИНН + * Регулярное выражение для валидации строки ИНН * * @see https://online.atol.ru/possystem/v4/schema/sell Схема "#/receipt/client/inn" */ @@ -138,9 +152,15 @@ final class Constraints '/^([^\s\\\]{0,17}|\+[^\s\\\]{1,18})$/'; /** - * Регулярное выражание для валидации строки Callback URL + * Регулярное выражение для валидации строки Callback URL */ const PATTERN_CALLBACK_URL = /* @lang PhpRegExp */ '/^http(s?)\:\/\/[0-9a-zA-Zа-яА-Я]' . '([-.\w]*[0-9a-zA-Zа-яА-Я])*(:(0-9)*)*(\/?)([a-zAZ0-9а-яА-Я\-\.\?\,\'\/\\\+&=%\$#_]*)?$/'; + + /** + * Регулярное выражение для валидации кода страны происхождения товара + */ + const PATTERN_OKSM_CODE = /* @lang PhpRegExp */ + '/^[\d]{3}$/'; } diff --git a/src/Constants/Ffd105Tags.php b/src/Constants/Ffd105Tags.php index 7b73a6d..734cca4 100644 --- a/src/Constants/Ffd105Tags.php +++ b/src/Constants/Ffd105Tags.php @@ -145,5 +145,5 @@ final class Ffd105Tags /** * Номер таможенной декларации (в соотв. с приказом ФНС России от 24.03.2016 N ММВ-7-15/155) */ - const DECLARATION_NUMBER = 1231; + const ITEM_DECLARATION_NUMBER = 1231; } diff --git a/src/Entities/Client.php b/src/Entities/Client.php index 3d8376e..e0672c1 100644 --- a/src/Entities/Client.php +++ b/src/Entities/Client.php @@ -15,14 +15,15 @@ use AtolOnline\{ Constants\Constraints, Exceptions\InvalidEmailException, Exceptions\InvalidInnLengthException, + Exceptions\InvalidPhoneException, Exceptions\TooLongClientContactException, Exceptions\TooLongClientNameException, Exceptions\TooLongEmailException}; /** - * Класс Client, описывающий сущность покупателя + * Класс, описывающий покупателя * - * @package AtolOnline\Entities + * @see https://online.atol.ru/files/API_atol_online_v4.pdf Документация, стр 17 */ class Client extends Entity { @@ -84,7 +85,6 @@ class Client extends Entity /** * Устанавливает наименование покупателя * - * @todo улучшить валидацию по Constraints::PATTERN_PHONE * @param string|null $name * @return $this * @throws TooLongClientNameException @@ -148,14 +148,14 @@ class Client extends Entity * * @param string|null $phone Номер телефона * @return $this - * @throws TooLongClientContactException + * @throws InvalidPhoneException */ public function setPhone(?string $phone): self { if (is_string($phone)) { $phone = preg_replace('/[^\d]/', '', trim($phone)); - if (mb_strlen($phone) > Constraints::MAX_LENGTH_CLIENT_CONTACT) { - throw new TooLongClientContactException($phone); + if (preg_match(Constraints::PATTERN_PHONE, $phone) != 1) { + throw new InvalidPhoneException($phone); } } $this->phone = empty($phone) ? null : "+$phone"; diff --git a/src/Entities/Document.php b/src/Entities/Document.php index 4bc4e7c..8c88432 100644 --- a/src/Entities/Document.php +++ b/src/Entities/Document.php @@ -21,8 +21,8 @@ use AtolOnline\Exceptions\TooLongCashierException; use AtolOnline\Exceptions\TooLongClientContactException; use AtolOnline\Exceptions\TooLongEmailException; use AtolOnline\Exceptions\TooLongItemNameException; +use AtolOnline\Exceptions\TooLongMeasurementUnitException; use AtolOnline\Exceptions\TooLongPaymentAddressException; -use AtolOnline\Exceptions\TooLongUnitException; use AtolOnline\Exceptions\TooLongUserdataException; use AtolOnline\Exceptions\TooManyException; use AtolOnline\Exceptions\TooManyItemsException; @@ -351,7 +351,7 @@ class Document extends Entity * @throws TooManyException * @throws TooManyItemsException * @throws TooManyPaymentsException - * @throws TooLongUnitException + * @throws TooLongMeasurementUnitException * @throws TooLongUserdataException * @throws Exception */ diff --git a/src/Entities/Item.php b/src/Entities/Item.php index 9421193..8e7b226 100644 --- a/src/Entities/Item.php +++ b/src/Entities/Item.php @@ -13,9 +13,20 @@ namespace AtolOnline\Entities; use AtolOnline\{ Constants\Constraints, + Enums\PaymentMethods, + Enums\PaymentObjects, + Enums\VatTypes, + Exceptions\EmptyItemNameException, + Exceptions\InvalidDeclarationNumberException, + Exceptions\InvalidEnumValueException, + Exceptions\InvalidOKSMCodeException, + Exceptions\NegativeItemPriceException, + Exceptions\NegativeItemQuantityException, + Exceptions\TooHighItemQuantityException, Exceptions\TooHighPriceException, + Exceptions\TooHighSumException, Exceptions\TooLongItemNameException, - Exceptions\TooLongUnitException, + Exceptions\TooLongMeasurementUnitException, Exceptions\TooLongUserdataException, Exceptions\TooManyException}; @@ -32,94 +43,85 @@ class Item extends Entity protected string $name; /** - * @var int Цена в копейках (с учётом скидок и наценок) (1079) + * @var float Цена в рублях (с учётом скидок и наценок) (1079) */ - protected int $price = 0; + protected float $price; /** - * @var float Количество, вес (1023) + * @var float Количество/вес (1023) */ - protected float $quantity = 0.0; + protected float $quantity; /** - * @var float Сумма в копейках (1043) + * @var string|null Единица измерения (1197) */ - protected float $sum = 0; + protected ?string $measurement_unit = null; /** - * @var string Единица измерения количества (1197) + * @var string|null Признак способа расчёта (1214) */ - protected string $measurement_unit; + protected ?string $payment_method = null; + + /** + * @var string|null Признак предмета расчёта (1212) + */ + protected ?string $payment_object = null; + + /** + * @var string|null Номер таможенной декларации (1321) + */ + protected ?string $declaration_number = null; /** * @var Vat|null Ставка НДС */ - protected ?Vat $vat; + protected ?Vat $vat = null; /** - * @var string Признак способа расчёта (1214) + * @var AgentInfo|null Атрибуты агента */ - protected string $payment_method; + protected ?AgentInfo $agent_info = null; /** - * @var string Признак объекта расчёта (1212) + * @var Supplier|null Атрибуты поставшика */ - protected string $payment_object; + protected ?Supplier $supplier = null; /** - * @var string Дополнительный реквизит (1191) + * @var string|null Дополнительный реквизит (1191) */ - protected string $user_data; + protected ?string $user_data = null; /** - * Item constructor. + * @var string|null Цифровой код страны происхождения товара (1230) + */ + protected ?string $country_code = null; + + /** + * Конструктор * * @param string|null $name Наименование * @param float|null $price Цена за одну единицу * @param float|null $quantity Количество - * @param string|null $measurement_unit Единица измерения - * @param string|null $vat_type Ставка НДС - * @param string|null $payment_object Признак - * @param string|null $payment_method Способ расчёта - * @throws TooLongItemNameException Слишком длинное наименование - * @throws TooHighPriceException Слишком высокая цена за одну единицу - * @throws TooManyException Слишком большое количество - * @throws TooLongUnitException Слишком длинное название единицы измерения + * @throws TooLongItemNameException + * @throws TooHighPriceException + * @throws TooManyException + * @throws NegativeItemPriceException + * @throws EmptyItemNameException + * @throws NegativeItemQuantityException */ public function __construct( - ?string $name = null, - ?float $price = null, - ?float $quantity = null, - ?string $measurement_unit = null, - ?string $vat_type = null, - ?string $payment_object = null, - ?string $payment_method = null + string $name = null, + float $price = null, + float $quantity = null, ) { - if ($name) { - $this->setName($name); - } - if ($price) { - $this->setPrice($price); - } - if ($quantity) { - $this->setQuantity($quantity); - } - if ($measurement_unit) { - $this->setMeasurementUnit($measurement_unit); - } - if ($vat_type) { - $this->setVatType($vat_type); - } - if ($payment_object) { - $this->setPaymentObject($payment_object); - } - if ($payment_method) { - $this->setPaymentMethod($payment_method); - } + !is_null($name) && $this->setName($name); + !is_null($price) && $this->setPrice($price); + !is_null($quantity) && $this->setQuantity($quantity); } /** - * Возвращает наименование. Тег ФФД - 1030. + * Возвращает наименование * * @return string */ @@ -129,51 +131,59 @@ class Item extends Entity } /** - * Устаналивает наименование. Тег ФФД - 1030. + * Устаналивает наименование * * @param string $name Наименование * @return $this * @throws TooLongItemNameException Слишком длинное имя/наименование + * @throws EmptyItemNameException */ public function setName(string $name): self { $name = trim($name); if (mb_strlen($name) > Constraints::MAX_LENGTH_ITEM_NAME) { - throw new TooLongItemNameException($name, Constraints::MAX_LENGTH_ITEM_NAME); + throw new TooLongItemNameException($name); + } + if (empty($name)) { + throw new EmptyItemNameException(); } $this->name = $name; return $this; } /** - * Возвращает цену в рублях. Тег ФФД - 1079. + * Возвращает цену в рублях * * @return float */ public function getPrice(): float { - return rubles($this->price); + return $this->price; } /** - * Устанавливает цену в рублях. Тег ФФД - 1079. + * Устанавливает цену в рублях * - * @param float $rubles Цена за одну единицу в рублях + * @param float $rubles * @return $this - * @throws TooHighPriceException Слишком высокая цена за одну единицу + * @throws NegativeItemPriceException + * @throws TooHighPriceException */ - public function setPrice(float $rubles): Item + public function setPrice(float $rubles): self { - if ($rubles > 42949672.95) { - throw new TooHighPriceException($rubles, 42949672.95); + if ($rubles > Constraints::MAX_COUNT_ITEM_PRICE) { + throw new TooHighPriceException($this->getName(), $rubles); } - $this->price = kopeks($rubles); - $this->calcSum(); + if ($rubles < 0) { + throw new NegativeItemPriceException($this->getName(), $rubles); + } + $this->price = $rubles; + //$this->calcSum(); return $this; } /** - * Возвращает количество. Тег ФФД - 1023. + * Возвращает количество * * @return float */ @@ -183,99 +193,115 @@ class Item extends Entity } /** - * Устанавливает количество. Тег ФФД - 1023. + * Устанавливает количество * * @param float $quantity Количество - * @param string|null $measurement_unit Единица измерения количества * @return $this - * @throws TooManyException Слишком большое количество - * @throws TooHighPriceException Слишком высокая общая стоимость - * @throws TooLongUnitException Слишком длинное название единицы измерения + * @throws TooHighItemQuantityException + * @throws NegativeItemQuantityException */ - public function setQuantity(float $quantity, string $measurement_unit = null): Item + public function setQuantity(float $quantity): self { $quantity = round($quantity, 3); - if ($quantity > 99999.999) { - throw new TooManyException($quantity, 99999.999); + if ($quantity > Constraints::MAX_COUNT_ITEM_QUANTITY) { + throw new TooHighItemQuantityException($this->getName(), $quantity); + } + if ($quantity < 0) { + throw new NegativeItemQuantityException($this->getName(), $quantity); } $this->quantity = $quantity; - $this->calcSum(); - if ($measurement_unit) { - $this->setMeasurementUnit($measurement_unit); - } return $this; } /** - * Возвращает заданную единицу измерения количества. Тег ФФД - 1197. + * Возвращает стоимость * - * @return string + * @return float + * @throws TooHighSumException */ - public function getMeasurementUnit(): string + public function getSum(): float + { + $sum = $this->price * $this->quantity; + if ($sum > Constraints::MAX_COUNT_ITEM_PRICE) { + throw new TooHighSumException($this->getName(), $sum); + } + return $sum; + } + + /** + * Возвращает заданную единицу измерения количества + * + * @return string|null + */ + public function getMeasurementUnit(): ?string { return $this->measurement_unit; } /** - * Устанавливает единицу измерения количества. Тег ФФД - 1197. + * Устанавливает единицу измерения количества * - * @param string $measurement_unit Единица измерения количества + * @param string|null $measurement_unit * @return $this - * @throws TooLongUnitException Слишком длинное название единицы измерения + * @throws TooLongMeasurementUnitException */ - public function setMeasurementUnit(string $measurement_unit): Item + public function setMeasurementUnit(?string $measurement_unit): self { - $measurement_unit = trim($measurement_unit); + $measurement_unit = trim((string)$measurement_unit); if (mb_strlen($measurement_unit) > Constraints::MAX_LENGTH_MEASUREMENT_UNIT) { - throw new TooLongUnitException($measurement_unit, Constraints::MAX_LENGTH_MEASUREMENT_UNIT); + throw new TooLongMeasurementUnitException($measurement_unit); } - $this->measurement_unit = $measurement_unit; + $this->measurement_unit = $measurement_unit ?: null; return $this; } /** - * Возвращает признак способа оплаты. Тег ФФД - 1214. + * Возвращает признак способа оплаты * - * @return string + * @return string|null */ - public function getPaymentMethod(): string + public function getPaymentMethod(): ?string { return $this->payment_method; } /** - * Устанавливает признак способа оплаты. Тег ФФД - 1214. + * Устанавливает признак способа оплаты * - * @param string $payment_method Признак способа оплаты + * @param string|null $payment_method Признак способа оплаты * @return $this - * @todo Проверка допустимых значений + * @throws InvalidEnumValueException */ - public function setPaymentMethod(string $payment_method): Item + public function setPaymentMethod(?string $payment_method): self { - $this->payment_method = trim($payment_method); + $payment_method = trim((string)$payment_method); + PaymentMethods::isValid($payment_method); + $this->payment_method = $payment_method ?: null; return $this; } /** - * Возвращает признак предмета расчёта. Тег ФФД - 1212. + * Возвращает признак предмета расчёта * - * @return string + * @return string|null */ - public function getPaymentObject(): string + public function getPaymentObject(): ?string { return $this->payment_object; } /** - * Устанавливает признак предмета расчёта. Тег ФФД - 1212. + * Устанавливает признак предмета расчёта * - * @param string $payment_object Признак предмета расчёта + * @param string|null $payment_object Признак предмета расчёта * @return $this - * @todo Проверка допустимых значений + * @throws InvalidEnumValueException */ - public function setPaymentObject(string $payment_object): Item + public function setPaymentObject(?string $payment_object): self { - $this->payment_object = trim($payment_object); + $payment_object = trim((string)$payment_object); + PaymentObjects::isValid($payment_object); + $this->payment_object = $payment_object ?: null; return $this; } @@ -292,25 +318,68 @@ class Item extends Entity /** * Устанавливает ставку НДС * - * @param string|null $vat_type Тип ставки НДС. Передать null, чтобы удалить ставку. + * @param Vat|string|null $vat Объект ставки, одно из значений VatTypes или null для удаления ставки * @return $this - * @throws TooHighPriceException + * @throws TooHighSumException */ - public function setVatType(?string $vat_type): Item + public function setVat(Vat|string|null $vat): self { - if ($vat_type) { - $this->vat - ? $this->vat->setType($vat_type) - : $this->vat = new Vat($vat_type); - } else { - $this->vat = null; + if (is_string($vat)) { + $vat = trim($vat); + VatTypes::isValid($vat) && $vat = new Vat($vat, $this->getSum()); + } elseif ($vat instanceof Vat) { + $vat->setSum($this->getSum()); } - $this->calcSum(); + $this->vat = $vat ?: null; return $this; } /** - * Возвращает дополнительный реквизит. Тег ФФД - 1191. + * Возвращает установленный объект атрибутов агента + * + * @return AgentInfo|null + */ + public function getAgentInfo(): ?AgentInfo + { + return $this->agent_info; + } + + /** + * Устанавливает атрибуты агента + * + * @param AgentInfo|null $agent_info + * @return Item + */ + public function setAgentInfo(?AgentInfo $agent_info): self + { + $this->agent_info = $agent_info; + return $this; + } + + /** + * Возвращает установленного поставщика + * + * @return Supplier|null + */ + public function getSupplier(): ?Supplier + { + return $this->supplier; + } + + /** + * Устанавливает поставщика + * + * @param Supplier|null $supplier + * @return Item + */ + public function setSupplier(?Supplier $supplier): self + { + $this->supplier = $supplier; + return $this; + } + + /** + * Возвращает дополнительный реквизит * * @return string|null */ @@ -320,30 +389,83 @@ class Item extends Entity } /** - * Устанавливает дополнительный реквизит. Тег ФФД - 1191. + * Устанавливает дополнительный реквизит * - * @param string $user_data Дополнительный реквизит. Тег ФФД - 1191. + * @param string|null $user_data Дополнительный реквизит * @return $this * @throws TooLongUserdataException Слишком длинный дополнительный реквизит */ - public function setUserData(string $user_data): self + public function setUserData(?string $user_data): self { - $user_data = trim($user_data); + $user_data = trim((string)$user_data); if (mb_strlen($user_data) > Constraints::MAX_LENGTH_USER_DATA) { - throw new TooLongUserdataException($user_data, Constraints::MAX_LENGTH_USER_DATA); + throw new TooLongUserdataException($user_data); } - $this->user_data = $user_data; + $this->user_data = $user_data ?: null; return $this; } /** - * Возвращает стоимость. Тег ФФД - 1043. + * Возвращает установленный код страны происхождения товара * - * @return float + * @return string|null + * @see https://ru.wikipedia.org/wiki/Общероссийский_классификатор_стран_мира + * @see https://classifikators.ru/oksm */ - public function getSum(): float + public function getCountryCode(): ?string { - return rubles($this->sum); + return $this->country_code; + } + + /** + * Устанавливает код страны происхождения товара + * + * @param string|null $country_code + * @return Item + * @throws InvalidOKSMCodeException + * @see https://classifikators.ru/oksm + * @see https://ru.wikipedia.org/wiki/Общероссийский_классификатор_стран_мира + */ + public function setCountryCode(?string $country_code): self + { + $country_code = trim((string)$country_code); + if (preg_match(Constraints::PATTERN_OKSM_CODE, $country_code) != 1) { + throw new InvalidOKSMCodeException($country_code); + } + $this->country_code = $country_code ?: null; + return $this; + } + + /** + * Возвращает установленный код таможенной декларации + * + * @return string|null + */ + public function getDeclarationNumber(): ?string + { + return $this->declaration_number; + } + + /** + * Устанавливает код таможенной декларации + * + * @param string|null $declaration_number + * @return Item + * @throws InvalidDeclarationNumberException + */ + public function setDeclarationNumber(?string $declaration_number): self + { + if (is_string($declaration_number)) { + $declaration_number = trim($declaration_number); + if ( + mb_strlen($declaration_number) < Constraints::MIN_LENGTH_DECLARATION_NUMBER || + mb_strlen($declaration_number) > Constraints::MAX_LENGTH_DECLARATION_NUMBER + ) { + throw new InvalidDeclarationNumberException($declaration_number); + } + } + $this->declaration_number = $declaration_number; + return $this; } /** @@ -352,45 +474,42 @@ class Item extends Entity * @return float * @throws TooHighPriceException Слишком большая сумма */ - public function calcSum(): float - { - $sum = $this->quantity * $this->price; - if (rubles($sum) > 42949672.95) { - throw new TooHighPriceException($sum, 42949672.95); - } - $this->sum = $sum; - if ($this->vat) { - $this->vat->setSum(rubles($sum)); - } - return $this->getSum(); - } + //public function calcSum(): float + //{ + // $sum = $this->quantity * $this->price; + // if (rubles($sum) > 42949672.95) { + // throw new TooHighPriceException($sum, 42949672.95); + // } + // $this->sum = $sum; + // if ($this->vat) { + // $this->vat->setSum(rubles($sum)); + // } + // return $this->getSum(); + //} /** * @inheritDoc + * @throws TooHighSumException */ - public function jsonSerialize() + public function jsonSerialize(): array { $json = [ - 'name' => $this->getName(), // обязательно - 'price' => $this->getPrice(), // обязательно - 'quantity' => $this->getQuantity(), // обязательно - 'sum' => $this->getSum(), // обязательно - 'measurement_unit' => $this->getMeasurementUnit(), - 'payment_method' => $this->getPaymentMethod(), - 'payment_object' => $this->getPaymentObject() - //TODO nomenclature_code - //TODO agent_info - //TODO supplier_info - //TODO excise - //TODO country_code - //TODO declaration_number + 'name' => $this->getName(), + 'price' => $this->getPrice(), + 'quantity' => $this->getQuantity(), + 'sum' => $this->getSum(), ]; - if ($this->getVat()) { - $json['vat'] = $this->getVat()->jsonSerialize(); - } - if ($this->getUserData()) { - $json['user_data'] = $this->getUserData(); - } + $this->getMeasurementUnit() && $json['measurement_unit'] = $this->getMeasurementUnit(); + $this->getPaymentMethod() && $json['payment_method'] = $this->getPaymentMethod(); + $this->getPaymentObject() && $json['payment_object'] = $this->getPaymentObject(); + $this->getDeclarationNumber() && $json['declaration_number'] = $this->getDeclarationNumber(); + $this->getVat()?->jsonSerialize() && $json['vat'] = $this->getVat()->jsonSerialize(); + $this->getAgentInfo()?->jsonSerialize() && $json['agent_info'] = $this->getAgentInfo()->jsonSerialize(); + $this->getSupplier()?->jsonSerialize() && $json['supplier_info'] = $this->getSupplier()->jsonSerialize(); + $this->getUserData() && $json['user_data'] = $this->getUserData(); + //TODO excise + $this->getCountryCode() && $json['country_code'] = $this->getCountryCode(); + //TODO nomenclature_code return $json; } } diff --git a/src/Exceptions/AtolException.php b/src/Exceptions/AtolException.php index d3e9237..6b86648 100644 --- a/src/Exceptions/AtolException.php +++ b/src/Exceptions/AtolException.php @@ -31,8 +31,9 @@ class AtolException extends Exception */ public function __construct(string $message = '', array $ffd_tags = []) { + $tags = implode(', ', $ffd_tags ?: $this->ffd_tags); parent::__construct( - ($message ?: $this->message) . ' [Теги ФФД: ' . implode(', ', $ffd_tags ?: $this->ffd_tags) . ']' + ($message ?: $this->message) . ($tags ? ' [Теги ФФД: ' . $tags : '') . ']' ); } } diff --git a/src/Exceptions/EmptyItemNameException.php b/src/Exceptions/EmptyItemNameException.php new file mode 100644 index 0000000..30bbfd5 --- /dev/null +++ b/src/Exceptions/EmptyItemNameException.php @@ -0,0 +1,25 @@ +message) . ': ' . $value; - if ($max > 0 || $this->max > 0) { - $message .= ' (макс. = ' . ($max ?? $this->max) . ', фактически = ' . $value . ')'; - } - parent::__construct($message); + parent::__construct( + ($message ?: $this->message) . (((float)$max > 0 || (float)$this->max > 0) ? + ' (макс = ' . ($max ?? $this->max) . ', фактически = ' . $value . ')' : '') + ); } } diff --git a/tests/AtolOnline/Tests/Entities/ClientTest.php b/tests/AtolOnline/Tests/Entities/ClientTest.php index c2b4c34..b498433 100644 --- a/tests/AtolOnline/Tests/Entities/ClientTest.php +++ b/tests/AtolOnline/Tests/Entities/ClientTest.php @@ -13,7 +13,7 @@ use AtolOnline\{ Entities\Client, Exceptions\InvalidEmailException, Exceptions\InvalidInnLengthException, - Exceptions\TooLongClientContactException, + Exceptions\InvalidPhoneException, Exceptions\TooLongClientNameException, Exceptions\TooLongEmailException, Helpers, @@ -118,7 +118,7 @@ class ClientTest extends BasicTestCase * @covers \AtolOnline\Entities\Client * @covers \AtolOnline\Entities\Client::setPhone * @covers \AtolOnline\Entities\Client::getPhone - * @throws TooLongClientContactException + * @throws InvalidPhoneException */ public function testNullablePhones(mixed $phone): void { @@ -133,7 +133,7 @@ class ClientTest extends BasicTestCase * @covers \AtolOnline\Entities\Client * @covers \AtolOnline\Entities\Client::setPhone * @covers \AtolOnline\Entities\Client::getPhone - * @throws TooLongClientContactException + * @throws InvalidPhoneException */ public function testValidPhone(string $input, string $output): void { @@ -146,13 +146,13 @@ class ClientTest extends BasicTestCase * @todo актуализировать при доработатанной валидации * @covers \AtolOnline\Entities\Client * @covers \AtolOnline\Entities\Client::setPhone - * @covers \AtolOnline\Exceptions\TooLongClientContactException - * @throws TooLongClientContactException + * @covers \AtolOnline\Exceptions\InvalidPhoneException + * @throws InvalidPhoneException */ - public function testTooLongClientPhone(): void + public function testInvalidPhoneException(): void { - $this->expectException(TooLongClientContactException::class); - (new Client())->setPhone('99999999999999999999999999999999999999999999999999999999999999999999999999'); + $this->expectException(InvalidPhoneException::class); + (new Client())->setPhone(Helpers::randomStr(500)); } /** diff --git a/tests/AtolOnline/Tests/Entities/CompanyTest.php b/tests/AtolOnline/Tests/Entities/CompanyTest.php index b392678..2ed59ef 100644 --- a/tests/AtolOnline/Tests/Entities/CompanyTest.php +++ b/tests/AtolOnline/Tests/Entities/CompanyTest.php @@ -19,11 +19,10 @@ use AtolOnline\{ Exceptions\TooLongEmailException, Exceptions\TooLongPaymentAddressException, Helpers, - Tests\BasicTestCase -}; + Tests\BasicTestCase}; /** - * Набор тестов для проверки работы класс продавца + * Набор тестов для проверки работы класса продавца */ class CompanyTest extends BasicTestCase { diff --git a/tests/AtolOnline/Tests/Entities/ItemTest.php b/tests/AtolOnline/Tests/Entities/ItemTest.php new file mode 100644 index 0000000..4de59d0 --- /dev/null +++ b/tests/AtolOnline/Tests/Entities/ItemTest.php @@ -0,0 +1,659 @@ +assertAtolable( + new Item('test item', 2, 3), + [ + 'name' => 'test item', + 'price' => 2, + 'quantity' => 3, + 'sum' => 6, + ] + ); + } + + /** + * Тестирует выброс исключения при установке слишком длинного имени предмета расчёта + * + * @covers \AtolOnline\Entities\Item + * @covers \AtolOnline\Entities\Item::setName + * @covers \AtolOnline\Exceptions\TooLongItemNameException + * @throws TooLongItemNameException + * @throws TooHighPriceException + * @throws TooManyException + * @throws NegativeItemPriceException + * @throws EmptyItemNameException + * @throws NegativeItemQuantityException + */ + public function testTooLongItemNameException(): void + { + $this->expectException(TooLongItemNameException::class); + new Item(Helpers::randomStr(Constraints::MAX_LENGTH_ITEM_NAME + 1), 2, 3); + } + + /** + * Тестирует выброс исключения при установке пустого имени предмета расчёта + * + * @covers \AtolOnline\Entities\Item + * @covers \AtolOnline\Entities\Item::setName + * @covers \AtolOnline\Exceptions\EmptyItemNameException + * @throws TooLongItemNameException + * @throws TooHighPriceException + * @throws TooManyException + * @throws NegativeItemPriceException + * @throws EmptyItemNameException + * @throws NegativeItemQuantityException + */ + public function testEmptyItemNameException(): void + { + $this->expectException(EmptyItemNameException::class); + new Item(" \n\r\t\0 ", 2, 3); + } + + /** + * Тестирует выброс исключения при установке слишком высокой цены предмета расчёта + * + * @covers \AtolOnline\Entities\Item + * @covers \AtolOnline\Entities\Item::setPrice + * @covers \AtolOnline\Exceptions\TooHighPriceException + * @throws TooLongItemNameException + * @throws TooHighPriceException + * @throws TooManyException + * @throws NegativeItemPriceException + * @throws EmptyItemNameException + * @throws NegativeItemQuantityException + */ + public function testTooHighPriceException(): void + { + $this->expectException(TooHighPriceException::class); + new Item('test', Constraints::MAX_COUNT_ITEM_PRICE + 0.1, 3); + } + + /** + * Тестирует выброс исключения при получении слишком высокой стоимости предмета расчёта + * + * @covers \AtolOnline\Entities\Item + * @covers \AtolOnline\Entities\Item::setPrice + * @covers \AtolOnline\Exceptions\TooHighSumException + * @throws TooHighSumException + */ + public function testTooHighSumException(): void + { + $this->expectException(TooHighSumException::class); + (new Item('test', Constraints::MAX_COUNT_ITEM_PRICE, Constraints::MAX_COUNT_ITEM_QUANTITY))->getSum(); + } + + /** + * Тестирует выброс исключения при установке слишком высокой цены предмета расчёта + * + * @covers \AtolOnline\Entities\Item + * @covers \AtolOnline\Entities\Item::setPrice + * @covers \AtolOnline\Exceptions\NegativeItemPriceException + * @throws TooLongItemNameException + * @throws TooHighPriceException + * @throws TooManyException + * @throws NegativeItemPriceException + * @throws EmptyItemNameException + * @throws NegativeItemQuantityException + */ + public function testNegativeItemPriceException(): void + { + $this->expectException(NegativeItemPriceException::class); + new Item('test', -0.01, 3); + } + + /** + * Тестирует выброс исключения при установке слишком большого количества предмета расчёта + * + * @covers \AtolOnline\Entities\Item + * @covers \AtolOnline\Entities\Item::setQuantity + * @covers \AtolOnline\Exceptions\TooHighItemQuantityException + * @throws TooLongItemNameException + * @throws TooHighPriceException + * @throws TooManyException + * @throws NegativeItemPriceException + * @throws EmptyItemNameException + * @throws NegativeItemQuantityException + */ + public function testTooHighItemQuantityException(): void + { + $this->expectException(TooHighItemQuantityException::class); + new Item('test', 2, Constraints::MAX_COUNT_ITEM_QUANTITY + 1); + } + + /** + * Тестирует выброс исключения при установке отрицательного количества предмета расчёта + * + * @covers \AtolOnline\Entities\Item + * @covers \AtolOnline\Entities\Item::setQuantity + * @covers \AtolOnline\Exceptions\NegativeItemQuantityException + * @throws TooLongItemNameException + * @throws TooHighPriceException + * @throws TooManyException + * @throws NegativeItemPriceException + * @throws EmptyItemNameException + */ + public function testNegativeItemQuantityException(): void + { + $this->expectException(NegativeItemQuantityException::class); + new Item('test', 2, -0.01); + } + + /** + * Тестирует установку пустой единицы измерения + * + * @param mixed $param + * @dataProvider providerNullableStrings + * @covers \AtolOnline\Entities\Item::setMeasurementUnit + * @covers \AtolOnline\Entities\Item::getMeasurementUnit + * @throws EmptyItemNameException + * @throws NegativeItemPriceException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws TooLongMeasurementUnitException + * @throws TooManyException + * @throws NegativeItemQuantityException + */ + public function testNullableMeasurementUnit(mixed $param): void + { + $this->assertNull((new Item('test item', 2, 3))->setMeasurementUnit($param)->getMeasurementUnit()); + } + + /** + * Тестирует выброс исключения при установке слишком длинной единицы измерения + * + * @covers \AtolOnline\Entities\Item::setMeasurementUnit + * @covers \AtolOnline\Exceptions\TooLongMeasurementUnitException + * @throws EmptyItemNameException + * @throws NegativeItemPriceException + * @throws NegativeItemQuantityException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws TooLongMeasurementUnitException + * @throws TooManyException + */ + public function testTooLongMeasurementUnitException(): void + { + $this->expectException(TooLongMeasurementUnitException::class); + (new Item('test item', 2, 3)) + ->setMeasurementUnit(Helpers::randomStr(Constraints::MAX_LENGTH_MEASUREMENT_UNIT + 1)); + } + + /** + * Тестирует сеттеры-геттеры валидных перечислимых значений атрибутов + * + * @covers \AtolOnline\Entities\Item::setPaymentMethod + * @covers \AtolOnline\Entities\Item::getPaymentMethod + * @covers \AtolOnline\Entities\Item::setPaymentObject + * @covers \AtolOnline\Entities\Item::getPaymentObject + * @covers \AtolOnline\Entities\Item::jsonSerialize + * @throws EmptyItemNameException + * @throws InvalidEnumValueException + * @throws TooManyException + * @throws NegativeItemPriceException + * @throws TooHighPriceException + * @throws NegativeItemQuantityException + * @throws TooLongItemNameException + */ + public function testValidEnums(): void + { + $item = new Item('test item', 2, 3); + $this->assertEquals( + PaymentMethods::ADVANCE, + $item->setPaymentMethod(PaymentMethods::ADVANCE)->getPaymentMethod() + ); + $this->assertEquals( + PaymentObjects::COMMODITY, + $item->setPaymentObject(PaymentObjects::COMMODITY)->getPaymentObject() + ); + $this->assertAtolable($item, [ + 'name' => 'test item', + 'price' => 2, + 'quantity' => 3, + 'sum' => 6, + 'payment_method' => 'advance', + 'payment_object' => 'commodity', + ]); + } + + /** + * Тестирует установку невалидного способа оплаты + * + * @covers \AtolOnline\Entities\Item::setPaymentMethod + * @covers \AtolOnline\Exceptions\InvalidEnumValueException + * @throws EmptyItemNameException + * @throws InvalidEnumValueException + * @throws TooManyException + * @throws NegativeItemPriceException + * @throws TooHighPriceException + * @throws NegativeItemQuantityException + * @throws TooLongItemNameException + */ + public function testInvalidPaymentMethod(): void + { + $this->expectException(InvalidEnumValueException::class); + $this->expectExceptionMessage('Некорректное значение AtolOnline\Enums\PaymentMethods::wrong_value'); + (new Item('test item', 2, 3))->setPaymentMethod('wrong_value'); + } + + /** + * Тестирует установку невалидного предмета расчёта + * + * @covers \AtolOnline\Entities\Item::setPaymentObject + * @covers \AtolOnline\Exceptions\InvalidEnumValueException + * @throws EmptyItemNameException + * @throws InvalidEnumValueException + * @throws TooManyException + * @throws NegativeItemPriceException + * @throws TooHighPriceException + * @throws NegativeItemQuantityException + * @throws TooLongItemNameException + */ + public function testInvalidPaymentObject(): void + { + $this->expectException(InvalidEnumValueException::class); + $this->expectExceptionMessage('Некорректное значение AtolOnline\Enums\PaymentObjects::wrong_value'); + (new Item('test item', 2, 3))->setPaymentObject('wrong_value'); + } + + /** + * Тестирует установку ставки НДС по строковой константе типа ставки + * + * @covers \AtolOnline\Entities\Item::setVat + * @covers \AtolOnline\Entities\Item::getVat + * @covers \AtolOnline\Entities\Item::jsonSerialize + * @throws EmptyItemNameException + * @throws NegativeItemPriceException + * @throws NegativeItemQuantityException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws TooManyException + */ + public function testValidVatByString(): void + { + $item = (new Item('test item', 2, 3))->setVat(VatTypes::VAT20); + $this->assertIsSameClass(Vat::class, $item->getVat()); + $this->assertEquals(VatTypes::VAT20, $item->getVat()->getType()); + $this->assertEquals($item->getSum(), $item->getVat()->getSum()); + $this->assertAtolable($item, [ + 'name' => 'test item', + 'price' => 2, + 'quantity' => 3, + 'sum' => 6, + 'vat' => [ + 'type' => 'vat20', + 'sum' => 1.2, + ], + ]); + } + + /** + * Тестирует установку ставки НДС объектом + * + * @covers \AtolOnline\Entities\Item::setVat + * @covers \AtolOnline\Entities\Item::getVat + * @covers \AtolOnline\Entities\Item::jsonSerialize + * @throws EmptyItemNameException + * @throws NegativeItemPriceException + * @throws NegativeItemQuantityException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws TooManyException + */ + public function testValidVatByObject(): void + { + $vat = new Vat(VatTypes::VAT20, 4000); + $item = (new Item('test item', 2, 3))->setVat($vat); + $this->assertIsSameClass(Vat::class, $item->getVat()); + $this->assertEquals(VatTypes::VAT20, $item->getVat()->getType()); + $this->assertEquals($item->getSum(), $item->getVat()->getSum()); + $this->assertAtolable($item, [ + 'name' => 'test item', + 'price' => 2, + 'quantity' => 3, + 'sum' => 6, + 'vat' => [ + 'type' => 'vat20', + 'sum' => 1.2, + ], + ]); + } + + /** + * Тестирует обнуление ставки НДС + * + * @param mixed $vat + * @dataProvider providerNullableStrings + * @covers \AtolOnline\Entities\Item::setVat + * @covers \AtolOnline\Entities\Item::getVat + * @covers \AtolOnline\Entities\Item::jsonSerialize + * @throws EmptyItemNameException + * @throws NegativeItemPriceException + * @throws NegativeItemQuantityException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws TooManyException + */ + public function testNullableVatByString(mixed $vat): void + { + $item = (new Item('test item', 2, 3))->setVat($vat); + $this->assertNull($item->getVat()); + } + + /** + * Тестирует установку атрибутов агента + * + * @covers \AtolOnline\Entities\Item::setAgentInfo + * @covers \AtolOnline\Entities\Item::getAgentInfo + * @covers \AtolOnline\Entities\Item::jsonSerialize + * @throws EmptyItemNameException + * @throws InvalidEnumValueException + * @throws InvalidInnLengthException + * @throws InvalidPhoneException + * @throws NegativeItemPriceException + * @throws NegativeItemQuantityException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws TooLongPayingAgentOperationException + * @throws TooManyException + */ + public function testAgentInfo(): void + { + $agent_info = new AgentInfo( + AgentTypes::ANOTHER, + new PayingAgent('test', ['+79518888888']), + new ReceivePaymentsOperator(['+79519999999']), + new MoneyTransferOperator('MTO Name', '9876543210', 'London', ['+79517777777']), + ); + $item = (new Item('test item', 2, 3))->setAgentInfo($agent_info); + $this->assertEquals($agent_info, $item->getAgentInfo()); + } + + /** + * Тестирует установку поставщика + * + * @covers \AtolOnline\Entities\Item::setSupplier + * @covers \AtolOnline\Entities\Item::getSupplier + * @covers \AtolOnline\Entities\Item::jsonSerialize + * @throws EmptyItemNameException + * @throws InvalidInnLengthException + * @throws InvalidPhoneException + * @throws NegativeItemPriceException + * @throws NegativeItemQuantityException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws TooManyException + */ + public function testSupplier(): void + { + $supplier = new Supplier( + 'some name', + '+fasd3\qe3fs_=nac99013928czc', + ['+122997365456'], + ); + $item = (new Item('test item', 2, 3))->setSupplier($supplier); + $this->assertEquals($supplier, $item->getSupplier()); + $this->assertAtolable($item, [ + 'name' => 'test item', + 'price' => 2, + 'quantity' => 3, + 'sum' => 6, + 'supplier_info' => [ + 'name' => 'some name', + 'inn' => '3399013928', + 'phones' => ['+122997365456'], + ], + ]); + } + + /** + * Тестирует установку валидных пользовательских данных + * + * @covers \AtolOnline\Entities\Item::setUserData + * @covers \AtolOnline\Entities\Item::getUserData + * @covers \AtolOnline\Entities\Item::jsonSerialize + * @throws EmptyItemNameException + * @throws NegativeItemPriceException + * @throws NegativeItemQuantityException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws TooLongUserdataException + * @throws TooManyException + */ + public function testValidUserdata(): void + { + $this->assertAtolable( + (new Item('test item', 2, 3)) + ->setUserData($user_data = Helpers::randomStr(Constraints::MAX_LENGTH_USER_DATA)), + [ + 'name' => 'test item', + 'price' => 2, + 'quantity' => 3, + 'sum' => 6, + 'user_data' => $user_data, + ] + ); + } + + /** + * Тестирует установку пустых пользовательских данных + * + * @param mixed $param + * @dataProvider providerNullableStrings + * @covers \AtolOnline\Entities\Item::setUserData + * @covers \AtolOnline\Entities\Item::getUserData + * @throws EmptyItemNameException + * @throws NegativeItemPriceException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws TooManyException + * @throws NegativeItemQuantityException + * @throws TooLongUserdataException + */ + public function testNullableUserData(mixed $param): void + { + $item = new Item('test item', 2, 3); + $this->assertNull($item->setUserData($param)->getUserData()); + } + + /** + * Тестирует выброс исключения при установке слишком длинных польз. данных + * + * @covers \AtolOnline\Entities\Item::setUserData + * @covers \AtolOnline\Exceptions\TooLongUserdataException + * @throws EmptyItemNameException + * @throws NegativeItemPriceException + * @throws NegativeItemQuantityException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws TooLongUserdataException + * @throws TooManyException + */ + public function testTooLongUserdataException(): void + { + $this->expectException(TooLongUserdataException::class); + (new Item('test item', 2, 3))->setUserData(Helpers::randomStr(Constraints::MAX_LENGTH_USER_DATA + 1)); + } + + /** + * Тестирует установку кода страны происхождения товара + * + * @covers \AtolOnline\Entities\Item::setCountryCode + * @covers \AtolOnline\Entities\Item::getCountryCode + * @covers \AtolOnline\Entities\Item::jsonSerialize + * @throws EmptyItemNameException + * @throws InvalidOKSMCodeException + * @throws NegativeItemPriceException + * @throws NegativeItemQuantityException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws TooManyException + */ + public function testCountryCode(): void + { + $this->assertAtolable( + (new Item('test item', 2, 3))->setCountryCode('800'), + [ + 'name' => 'test item', + 'price' => 2, + 'quantity' => 3, + 'sum' => 6, + 'country_code' => '800', + ] + ); + } + + /** + * Тестирует выброс исключения при установке невалидного кода страны происхождения товара + * + * @covers \AtolOnline\Entities\Item::setCountryCode + * @covers \AtolOnline\Exceptions\InvalidOKSMCodeException + * @throws EmptyItemNameException + * @throws InvalidOKSMCodeException + * @throws NegativeItemPriceException + * @throws NegativeItemQuantityException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws TooManyException + */ + public function testInvalidOKSMCodeException(): void + { + $this->expectException(InvalidOKSMCodeException::class); + (new Item('test item', 2, 3))->setCountryCode(Helpers::randomStr()); + } + + /** + * Тестирует установку валидного кода таможенной декларации + * + * @covers \AtolOnline\Entities\Item::getDeclarationNumber + * @covers \AtolOnline\Entities\Item::setDeclarationNumber + * @covers \AtolOnline\Entities\Item::jsonSerialize + * @throws EmptyItemNameException + * @throws NegativeItemPriceException + * @throws NegativeItemQuantityException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws TooManyException + * @throws InvalidDeclarationNumberException + */ + public function testValidDeclarationNumber(): void + { + $this->assertAtolable( + (new Item('test item', 2, 3)) + ->setDeclarationNumber($code = Helpers::randomStr()), + [ + 'name' => 'test item', + 'price' => 2, + 'quantity' => 3, + 'sum' => 6, + 'declaration_number' => $code, + ] + ); + } + + /** + * Тестирует выброс исключения при установке слишком короткого кода таможенной декларации + * + * @covers \AtolOnline\Entities\Item::setDeclarationNumber + * @covers \AtolOnline\Exceptions\InvalidDeclarationNumberException + * @throws EmptyItemNameException + * @throws NegativeItemPriceException + * @throws NegativeItemQuantityException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws InvalidDeclarationNumberException + * @throws TooManyException + */ + public function testInvalidDeclarationNumberExceptionMin(): void + { + $this->expectException(InvalidDeclarationNumberException::class); + (new Item('test item', 2, 3)) + ->setDeclarationNumber(Helpers::randomStr(Constraints::MIN_LENGTH_DECLARATION_NUMBER - 1)); + } + + /** + * Тестирует выброс исключения при установке слишком длинного кода таможенной декларации + * + * @covers \AtolOnline\Entities\Item::setDeclarationNumber + * @covers \AtolOnline\Exceptions\InvalidDeclarationNumberException + * @throws EmptyItemNameException + * @throws NegativeItemPriceException + * @throws NegativeItemQuantityException + * @throws TooHighPriceException + * @throws TooLongItemNameException + * @throws InvalidDeclarationNumberException + * @throws TooManyException + */ + public function testInvalidDeclarationNumberExceptionMax(): void + { + $this->expectException(InvalidDeclarationNumberException::class); + (new Item('test item', 2, 3)) + ->setDeclarationNumber(Helpers::randomStr(Constraints::MAX_LENGTH_DECLARATION_NUMBER + 1)); + } +} diff --git a/tests/AtolOnline/Tests/Entities/MoneyTransferOperatorTest.php b/tests/AtolOnline/Tests/Entities/MoneyTransferOperatorTest.php index 0be356d..bf6560a 100644 --- a/tests/AtolOnline/Tests/Entities/MoneyTransferOperatorTest.php +++ b/tests/AtolOnline/Tests/Entities/MoneyTransferOperatorTest.php @@ -16,7 +16,7 @@ use AtolOnline\{ Tests\BasicTestCase}; /** - * Набор тестов для проверки работы класса поставщика + * Набор тестов для проверки работы класса оператора перевода */ class MoneyTransferOperatorTest extends BasicTestCase { diff --git a/tests/ItemTest_todo.php b/tests/ItemTest_todo.php deleted file mode 100644 index 97d3f3f..0000000 --- a/tests/ItemTest_todo.php +++ /dev/null @@ -1,163 +0,0 @@ -assertAtolable($item); - $this->assertEquals('Банан', $item->getName()); - $this->assertEquals(65.99, $item->getPrice()); - $this->assertEquals(2.74, $item->getQuantity()); - $this->assertEquals('кг', $item->getMeasurementUnit()); - $this->assertEquals(VatTypes::NONE, $item->getVat()->getType()); - $this->assertEquals(PaymentObjects::COMMODITY, $item->getPaymentObject()); - $this->assertEquals(PaymentMethods::FULL_PAYMENT, $item->getPaymentMethod()); - } - - /** - * Тестирует установку параметров через сеттеры - * - * @throws AtolOnline\Exceptions\TooLongNameException - * @throws AtolOnline\Exceptions\TooHighPriceException - * @throws AtolOnline\Exceptions\BasicTooManyException - * @throws AtolOnline\Exceptions\TooLongUnitException - * @throws AtolOnline\Exceptions\TooLongUserdataException - */ - public function testSetters() - { - $item = new Item(); - $item->setName('Банан'); - $item->setPrice(65.99); - $item->setQuantity(2.74); - $item->setMeasurementUnit('кг'); - $item->setVatType(VatTypes::NONE); - $item->setPaymentObject(PaymentObjects::COMMODITY); - $item->setPaymentMethod(PaymentMethods::FULL_PAYMENT); - $item->setUserData('Some user data'); - $this->assertAtolable($item); - $this->assertEquals('Банан', $item->getName()); - $this->assertEquals(65.99, $item->getPrice()); - $this->assertEquals(2.74, $item->getQuantity()); - $this->assertEquals('кг', $item->getMeasurementUnit()); - $this->assertEquals(VatTypes::NONE, $item->getVat()->getType()); - $this->assertEquals(PaymentObjects::COMMODITY, $item->getPaymentObject()); - $this->assertEquals(PaymentMethods::FULL_PAYMENT, $item->getPaymentMethod()); - $this->assertEquals('Some user data', $item->getUserData()); - } - - /** - * Тестирует установку ставки НДС разными путями - * - * @throws TooHighPriceException - */ - public function testSetVat() - { - $item = new Item(); - $item->setVatType(VatTypes::NONE); - $this->assertEquals(VatTypes::NONE, $item->getVat()->getType()); - $item->setVatType(VatTypes::VAT20); - $this->assertEquals(VatTypes::VAT20, $item->getVat()->getType()); - } - - /** - * Тестирует исключение о слишком длинном наименовании - * - * @throws TooLongItemNameException - */ - public function testAtolNameTooLongException() - { - $item = new Item(); - $this->expectException(TooLongItemNameException::class); - $item->setName(Helpers::randomStr(130)); - } - - /** - * Тестирует исключение о слишком высоком количестве - * - * @throws TooHighPriceException - * @throws TooManyException - * @throws TooLongUnitException - */ - public function testAtolQuantityTooHighException() - { - $item = new Item(); - $this->expectException(TooManyException::class); - $item->setQuantity(100000.1); - } - - /** - * Тестирует исключение о слишком высокой цене - * - * @throws TooHighPriceException - */ - public function testAtolPriceTooHighException() - { - $item = new Item(); - $this->expectException(TooHighPriceException::class); - $item->setPrice(42949673.1); - } - - /** - * Тестирует исключение о слишком длинных польз. данных - * - * @throws TooLongUserdataException - */ - public function testAtolUserdataTooLongException() - { - $item = new Item(); - $this->expectException(TooLongUserdataException::class); - $item->setUserData('User data User data User data User data User data User data User data'); - } - - /** - * Тестирует исключение о слишком длинной единице измерения - * - * @throws TooLongUnitException - */ - public function testAtolUnitTooLongException() - { - $item = new Item(); - $this->expectException(TooLongUnitException::class); - $item->setMeasurementUnit('кг кг кг кг кг кг кг кг кг '); - } -}