anthony/atol-online
1
0
Fork 0
mirror of https://github.com/anthonyaxenov/atol-online.git synced 2024-11-21 21:34:34 +00:00
Code Issues Projects Releases Wiki Activity

Кучад доработок, главным образом вокруг Item

Browse Source 
- `Item` почти готов и весь покрыт тестами. Пока остались нереализованными `nomenclature_code` и `excise`
- `Client::setPhone()` теперь выбрасывает InvalidPhoneException
- доработка и создание новых исключений (не буду все перечислять, смотри диффы)
- мелочи по phpdoc и всяким текстовкам
This commit is contained in:
Anthony Axenov 2021-12-01 20:11:08 +08:00
parent bce21f9658
commit 5ccb0e9db4
22 changed files with 1232 additions and 360 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/Constants/Constraints.php
View File

@ -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}$/';
}

2
src/Constants/Ffd105Tags.php
View File

@ -145,5 +145,5 @@ final class Ffd105Tags
/**
* Номер таможенной декларации (в соотв. с приказом ФНС России от 24.03.2016 N ММВ-7-15/155)
*/
const DECLARATION_NUMBER = 1231;
const ITEM_DECLARATION_NUMBER = 1231;
}

12
src/Entities/Client.php
View File

@ -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";

4
src/Entities/Document.php
View File

@ -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
*/

435
src/Entities/Item.php
View File

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

3
src/Exceptions/AtolException.php
View File

@ -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 : '') . ']'
);
}
}

25
src/Exceptions/EmptyItemNameException.php Normal file
View File

@ -0,0 +1,25 @@
<?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;
use AtolOnline\Constants\Ffd105Tags;
/**
* Исключение, возникающее при пустом наименовании предмета расчёта
*
* @see https://online.atol.ru/files/API_atol_online_v4.pdf Документация, стр 21
*/
class EmptyItemNameException extends AtolException
{
protected $message = 'Наименование предмета расчёта не может быть пустым';
protected array $ffd_tags = [Ffd105Tags::ITEM_NAME];
}

32
src/Exceptions/InvalidDeclarationNumberException.php Normal file
View File

@ -0,0 +1,32 @@
<?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;
use AtolOnline\Constants\Ffd105Tags;
/**
* Исключение, возникающее при ошибке валидации кода таможенной декларации
*/
class InvalidDeclarationNumberException extends AtolException
{
protected array $ffd_tags = [Ffd105Tags::ITEM_DECLARATION_NUMBER];
/**
* Конструктор
*
* @param string $code
*/
public function __construct(string $code = '')
{
parent::__construct("Невалидный код таможенной декларации: '$code'");
}
}

13
src/Exceptions/InvalidEnumValueException.php
View File

@ -14,7 +14,7 @@ namespace AtolOnline\Exceptions;
use AtolOnline\Enums\Enum;
/**
* Исключение, возникающее при ошибке валидации типа агента
* Исключение, возникающее при ошибке валидации перечислимых значений
*/
class InvalidEnumValueException extends AtolException
{
@ -29,10 +29,11 @@ class InvalidEnumValueException extends AtolException
public function __construct(string $enum, mixed $value, string $message = '', array $ffd_tags = [])
{
/** @var $enum Enum */
parent::__construct(
($message ?: "Некорректное значение $enum::$value.") .
" Допустимые значения: " . implode(', ', $enum::toArray()),
$ffd_tags ?: $enum::getFfdTags()
);
$own_message = (
empty($value)
? "Значение из $enum не может быть пустым."
: "Некорректное значение $enum::$value."
) . " Допустимые значения: " . implode(', ', $enum::toArray());
parent::__construct($message ?: $own_message, $ffd_tags ?: $enum::getFfdTags());
}
}

34
src/Exceptions/InvalidOKSMCodeException.php Normal file
View File

@ -0,0 +1,34 @@
<?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;
use AtolOnline\Constants\Ffd105Tags;
/**
* Исключение, возникающее при ошибке валидации кода страны происхождения товара
*
* @see https://online.atol.ru/files/API_atol_online_v4.pdf Документация, стр 29
*/
class InvalidOKSMCodeException extends AtolException
{
protected array $ffd_tags = [Ffd105Tags::ITEM_COUNTRY_CODE];
/**
* Конструктор
*
* @param string $code
*/
public function __construct(string $code)
{
parent::__construct('Невалидный код страны происхождения товара: ' . $code);
}
}

33
src/Exceptions/NegativeItemPriceException.php Normal file
View File

@ -0,0 +1,33 @@
<?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;
use AtolOnline\Constants\Ffd105Tags;
/**
* Исключение, возникающее при попытке указать предмету расчёта отрицательную цену
*/
class NegativeItemPriceException extends AtolException
{
protected array $ffd_tags = [Ffd105Tags::ITEM_PRICE];
/**
* Конструктор
*
* @param string $name
* @param float $price
*/
public function __construct(string $name, float $price)
{
parent::__construct("Предмет расчёта '$name' не может иметь отрицательную цену $price");
}
}

33
src/Exceptions/NegativeItemQuantityException.php Normal file
View File

@ -0,0 +1,33 @@
<?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;
use AtolOnline\Constants\Ffd105Tags;
/**
* Исключение, возникающее при попытке указать предмету расчёта отрицательное количество
*/
class NegativeItemQuantityException extends AtolException
{
protected array $ffd_tags = [Ffd105Tags::ITEM_QUANTITY];
/**
* Конструктор
*
* @param string $name
* @param float $quantity
*/
public function __construct(string $name, float $quantity)
{
parent::__construct("Предмет расчёта '$name' не может иметь отрицательное количество $quantity");
}
}

35
src/Exceptions/TooHighItemQuantityException.php Normal file
View File

@ -0,0 +1,35 @@
<?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;
use AtolOnline\Constants\Constraints;
use AtolOnline\Constants\Ffd105Tags;
/**
* Исключение, возникающее при попытке добавить слишком большое количество предмета расчёта
*/
class TooHighItemQuantityException extends TooManyException
{
protected float $max = Constraints::MAX_COUNT_ITEM_QUANTITY;
protected array $ffd_tags = [Ffd105Tags::ITEM_QUANTITY];
/**
* Конструктор
*
* @param string $name
* @param float $quantity
*/
public function __construct(string $name, float $quantity)
{
parent::__construct($quantity, "Слишком большое количество предмета расчёта '$name'");
}
}

12
src/Exceptions/TooHighPriceException.php
View File

@ -19,7 +19,17 @@ use AtolOnline\Constants\Ffd105Tags;
*/
class TooHighPriceException extends TooManyException
{
protected $message = 'Слишком высокая цена';
protected array $ffd_tags = [Ffd105Tags::ITEM_PRICE];
protected float $max = Constraints::MAX_COUNT_ITEM_PRICE;
/**
* Конструктор
*
* @param string $name
* @param float $price
*/
public function __construct(string $name, float $price)
{
parent::__construct($price, "Слишком высокая цена для предмета расчёта '$name'");
}
}

35
src/Exceptions/TooHighSumException.php Normal file
View File

@ -0,0 +1,35 @@
<?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;
use AtolOnline\Constants\Constraints;
use AtolOnline\Constants\Ffd105Tags;
/**
* Исключение, возникающее при попытке получеиня слишком высокой стоимости
*/
class TooHighSumException extends TooManyException
{
protected array $ffd_tags = [Ffd105Tags::ITEM_SUM];
protected float $max = Constraints::MAX_COUNT_ITEM_PRICE;
/**
* Конструктор
*
* @param string $name
* @param float $sum
*/
public function __construct(string $name, float $sum)
{
parent::__construct($sum, "Слишком высокая стоимость предмета расчёта '$name'");
}
}

2
src/Exceptions/TooLongUnitException.php → src/Exceptions/TooLongMeasurementUnitException.php
View File

@ -17,7 +17,7 @@ use AtolOnline\Constants\Ffd105Tags;
/**
* Исключение, возникающее при попытке указать слишком длинную единицу измерения предмета расчёта
*/
class TooLongUnitException extends TooLongException
class TooLongMeasurementUnitException extends TooLongException
{
protected $message = 'Слишком длинная единица измерения предмета расчёта';
protected float $max = Constraints::MAX_LENGTH_MEASUREMENT_UNIT;

13
src/Exceptions/TooManyException.php
View File

@ -31,14 +31,13 @@ class TooManyException extends AtolException
*
* @param float $value
* @param string $message
* @param float $max
* @param float|null $max
*/
public function __construct(float $value, string $message = '', float $max = 0)
public function __construct(float $value, string $message = '', ?float $max = null)
{
$message = ($message ?: $this->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 . ')' : '')
);
}
}

16
tests/AtolOnline/Tests/Entities/ClientTest.php
View File

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

5
tests/AtolOnline/Tests/Entities/CompanyTest.php
View File

@ -19,11 +19,10 @@ use AtolOnline\{
Exceptions\TooLongEmailException,
Exceptions\TooLongPaymentAddressException,
Helpers,
Tests\BasicTestCase
};
Tests\BasicTestCase};
/**
* Набор тестов для проверки работы класс продавца
* Набор тестов для проверки работы класса продавца
*/
class CompanyTest extends BasicTestCase
{

659
tests/AtolOnline/Tests/Entities/ItemTest.php Normal file
View File

@ -0,0 +1,659 @@
<?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\{
Constants\Constraints,
Entities\AgentInfo,
Entities\Item,
Entities\MoneyTransferOperator,
Entities\PayingAgent,
Entities\ReceivePaymentsOperator,
Entities\Supplier,
Entities\Vat,
Enums\AgentTypes,
Enums\PaymentMethods,
Enums\PaymentObjects,
Enums\VatTypes,
Exceptions\EmptyItemNameException,
Exceptions\InvalidDeclarationNumberException,
Exceptions\InvalidEnumValueException,
Exceptions\InvalidInnLengthException,
Exceptions\InvalidOKSMCodeException,
Exceptions\InvalidPhoneException,
Exceptions\NegativeItemPriceException,
Exceptions\NegativeItemQuantityException,
Exceptions\TooHighItemQuantityException,
Exceptions\TooHighPriceException,
Exceptions\TooHighSumException,
Exceptions\TooLongItemNameException,
Exceptions\TooLongMeasurementUnitException,
Exceptions\TooLongPayingAgentOperationException,
Exceptions\TooLongUserdataException,
Exceptions\TooManyException,
Helpers,
Tests\BasicTestCase};
/**
* Набор тестов для проверки работы класс продавца
*/
class ItemTest extends BasicTestCase
{
/**
* Тестирует конструктор с сеттерами и приведение к json с геттерами
*
* @covers \AtolOnline\Entities\Item
* @covers \AtolOnline\Entities\Item::setName
* @covers \AtolOnline\Entities\Item::getName
* @covers \AtolOnline\Entities\Item::setPrice
* @covers \AtolOnline\Entities\Item::getPrice
* @covers \AtolOnline\Entities\Item::setQuantity
* @covers \AtolOnline\Entities\Item::getQuantity
* @covers \AtolOnline\Entities\Item::getSum
* @covers \AtolOnline\Entities\Item::jsonSerialize
* @throws TooLongItemNameException
* @throws TooHighPriceException
* @throws TooManyException
* @throws NegativeItemPriceException
* @throws EmptyItemNameException
* @throws NegativeItemQuantityException
*/
public function testConstructor(): void
{
$this->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));
}
}

2
tests/AtolOnline/Tests/Entities/MoneyTransferOperatorTest.php
View File

@ -16,7 +16,7 @@ use AtolOnline\{
Tests\BasicTestCase};
/**
* Набор тестов для проверки работы класса поставщика
* Набор тестов для проверки работы класса оператора перевода
*/
class MoneyTransferOperatorTest extends BasicTestCase
{

163
tests/ItemTest_todo.php
View File

@ -1,163 +0,0 @@
<?php
/*
* Copyright (c) 2020-2021 Антон Аксенов (Anthony Axenov)
*
* This code is licensed under MIT.
* Этот код распространяется по лицензии MIT.
* https://github.com/anthonyaxenov/atol-online/blob/master/LICENSE
*/
namespace AtolOnlineTests;
use AtolOnline\{
Entities\Item,
Enums\PaymentMethods,
Enums\PaymentObjects,
Enums\VatTypes,
Exceptions\TooHighPriceException,
Exceptions\TooLongItemNameException,
Exceptions\TooLongUnitException,
Exceptions\TooLongUserdataException,
Exceptions\TooManyException,};
/**
* Class ItemTest
*/
class ItemTestTodo extends BasicTestCase
{
/**
* Тестирует установку параметров через конструктор
*
* @throws AtolOnline\Exceptions\TooLongNameException
* @throws AtolOnline\Exceptions\TooHighPriceException
* @throws AtolOnline\Exceptions\BasicTooManyException
* @throws AtolOnline\Exceptions\TooLongUnitException
*/
public function testConstructor()
{
$item = new Item(
'Банан',
65.99,
2.74,
'кг',
VatTypes::NONE,
PaymentObjects::COMMODITY,
PaymentMethods::FULL_PAYMENT
);
$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());
}
/**
* Тестирует установку параметров через сеттеры
*
* @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('кг кг кг кг кг кг кг кг кг ');
}
}