423 lines
19 KiB
Python
423 lines
19 KiB
Python
|
#!/usr/bin/env python3
|
|||
|
|
"""
|
|||
|
|
test_price_calculator.py — Unit tests для price_calculator.py
|
|||
|
|
|
|||
|
|
Montana Protocol
|
|||
|
|
Тестирование ценового калькулятора и якоря Beeple
|
|||
|
|
"""
|
|||
|
|
|
|||
|
|
import sys
|
|||
|
|
import os
|
|||
|
|
import unittest
|
|||
|
|
from datetime import datetime, timezone
|
|||
|
|
|
|||
|
|
# Добавляем путь к модулю
|
|||
|
|
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../экономика/банк_времени/код'))
|
|||
|
|
from price_calculator import (
|
|||
|
|
BeepleAnchor,
|
|||
|
|
mta_to_usd,
|
|||
|
|
usd_to_mta,
|
|||
|
|
seconds_to_usd,
|
|||
|
|
usd_to_seconds,
|
|||
|
|
days_to_usd,
|
|||
|
|
usd_to_days,
|
|||
|
|
get_anchor_info,
|
|||
|
|
format_price,
|
|||
|
|
PizzaDayCalculator
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
|
|||
|
|
class TestBeepleAnchorConstants(unittest.TestCase):
|
|||
|
|
"""Тесты констант якоря Beeple"""
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
# BEEPLE ANCHOR CONSTANTS
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
def test_sale_price(self):
|
|||
|
|
"""Цена продажи Beeple NFT"""
|
|||
|
|
self.assertEqual(BeepleAnchor.SALE_PRICE_USD, 69_346_250.00)
|
|||
|
|
|
|||
|
|
def test_total_days(self):
|
|||
|
|
"""Количество дней работы"""
|
|||
|
|
self.assertEqual(BeepleAnchor.TOTAL_DAYS, 5000)
|
|||
|
|
|
|||
|
|
def test_sale_date(self):
|
|||
|
|
"""Дата продажи"""
|
|||
|
|
self.assertEqual(BeepleAnchor.SALE_DATE, "2021-03-11")
|
|||
|
|
|
|||
|
|
def test_usd_per_day(self):
|
|||
|
|
"""USD за день работы"""
|
|||
|
|
expected = BeepleAnchor.SALE_PRICE_USD / BeepleAnchor.TOTAL_DAYS
|
|||
|
|
self.assertAlmostEqual(BeepleAnchor.USD_PER_DAY, expected, places=2)
|
|||
|
|
self.assertAlmostEqual(BeepleAnchor.USD_PER_DAY, 13869.25, places=2)
|
|||
|
|
|
|||
|
|
def test_usd_per_hour(self):
|
|||
|
|
"""USD за час работы"""
|
|||
|
|
expected = BeepleAnchor.USD_PER_DAY / 24
|
|||
|
|
self.assertAlmostEqual(BeepleAnchor.USD_PER_HOUR, expected, places=2)
|
|||
|
|
self.assertAlmostEqual(BeepleAnchor.USD_PER_HOUR, 577.885, places=2)
|
|||
|
|
|
|||
|
|
def test_usd_per_minute(self):
|
|||
|
|
"""USD за минуту работы"""
|
|||
|
|
expected = BeepleAnchor.USD_PER_HOUR / 60
|
|||
|
|
self.assertAlmostEqual(BeepleAnchor.USD_PER_MINUTE, expected, places=2)
|
|||
|
|
self.assertAlmostEqual(BeepleAnchor.USD_PER_MINUTE, 9.6314, places=2)
|
|||
|
|
|
|||
|
|
def test_usd_per_second(self):
|
|||
|
|
"""USD за секунду работы"""
|
|||
|
|
expected = BeepleAnchor.USD_PER_MINUTE / 60
|
|||
|
|
self.assertAlmostEqual(BeepleAnchor.USD_PER_SECOND, expected, places=4)
|
|||
|
|
self.assertAlmostEqual(BeepleAnchor.USD_PER_SECOND, 0.1605, places=4)
|
|||
|
|
|
|||
|
|
def test_mta_per_second(self):
|
|||
|
|
"""MTA за секунду"""
|
|||
|
|
self.assertEqual(BeepleAnchor.MTA_PER_SECOND, 1.0)
|
|||
|
|
|
|||
|
|
def test_usd_per_mta(self):
|
|||
|
|
"""USD за 1 MTA"""
|
|||
|
|
self.assertEqual(BeepleAnchor.USD_PER_MTA, BeepleAnchor.USD_PER_SECOND)
|
|||
|
|
|
|||
|
|
|
|||
|
|
class TestMTAtoUSD(unittest.TestCase):
|
|||
|
|
"""Тесты конвертации MTA → USD"""
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
# MTA TO USD
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
def test_mta_to_usd_one_second(self):
|
|||
|
|
"""1 MTA (1 секунда) → USD"""
|
|||
|
|
result = mta_to_usd(1.0)
|
|||
|
|
self.assertAlmostEqual(result, 0.1605, places=4)
|
|||
|
|
|
|||
|
|
def test_mta_to_usd_ten_minutes(self):
|
|||
|
|
"""600 MTA (10 минут) → USD"""
|
|||
|
|
result = mta_to_usd(600)
|
|||
|
|
expected = 600 * BeepleAnchor.USD_PER_SECOND
|
|||
|
|
self.assertAlmostEqual(result, expected, places=2)
|
|||
|
|
self.assertAlmostEqual(result, 96.3, places=1)
|
|||
|
|
|
|||
|
|
def test_mta_to_usd_one_hour(self):
|
|||
|
|
"""3600 MTA (1 час) → USD"""
|
|||
|
|
result = mta_to_usd(3600)
|
|||
|
|
expected = 3600 * BeepleAnchor.USD_PER_SECOND
|
|||
|
|
self.assertAlmostEqual(result, expected, places=2)
|
|||
|
|
self.assertAlmostEqual(result, 577.8, places=1)
|
|||
|
|
|
|||
|
|
def test_mta_to_usd_one_day(self):
|
|||
|
|
"""86400 MTA (1 день) → USD"""
|
|||
|
|
result = mta_to_usd(86400)
|
|||
|
|
expected = 86400 * BeepleAnchor.USD_PER_SECOND
|
|||
|
|
self.assertAlmostEqual(result, expected, places=2)
|
|||
|
|
self.assertAlmostEqual(result, 13869.2, places=1)
|
|||
|
|
|
|||
|
|
def test_mta_to_usd_zero(self):
|
|||
|
|
"""0 MTA → $0"""
|
|||
|
|
result = mta_to_usd(0)
|
|||
|
|
self.assertEqual(result, 0.0)
|
|||
|
|
|
|||
|
|
def test_mta_to_usd_large_number(self):
|
|||
|
|
"""1,000,000 MTA → USD"""
|
|||
|
|
result = mta_to_usd(1_000_000)
|
|||
|
|
expected = 1_000_000 * BeepleAnchor.USD_PER_SECOND
|
|||
|
|
self.assertAlmostEqual(result, expected, places=2)
|
|||
|
|
|
|||
|
|
|
|||
|
|
class TestUSDtoMTA(unittest.TestCase):
|
|||
|
|
"""Тесты конвертации USD → MTA"""
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
# USD TO MTA
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
def test_usd_to_mta_one_second_price(self):
|
|||
|
|
"""$0.1605 → 1 MTA"""
|
|||
|
|
result = usd_to_mta(0.1605)
|
|||
|
|
self.assertAlmostEqual(result, 1.0, places=2)
|
|||
|
|
|
|||
|
|
def test_usd_to_mta_one_hundred(self):
|
|||
|
|
"""$100 → MTA"""
|
|||
|
|
result = usd_to_mta(100)
|
|||
|
|
expected = 100 / BeepleAnchor.USD_PER_SECOND
|
|||
|
|
self.assertAlmostEqual(result, expected, places=2)
|
|||
|
|
self.assertAlmostEqual(result, 623.0, places=0)
|
|||
|
|
|
|||
|
|
def test_usd_to_mta_zero(self):
|
|||
|
|
"""$0 → 0 MTA"""
|
|||
|
|
result = usd_to_mta(0)
|
|||
|
|
self.assertEqual(result, 0.0)
|
|||
|
|
|
|||
|
|
def test_usd_to_mta_roundtrip(self):
|
|||
|
|
"""Roundtrip: MTA → USD → MTA"""
|
|||
|
|
original = 1000.0
|
|||
|
|
converted = mta_to_usd(original)
|
|||
|
|
back = usd_to_mta(converted)
|
|||
|
|
self.assertAlmostEqual(back, original, places=2)
|
|||
|
|
|
|||
|
|
|
|||
|
|
class TestSecondsConversion(unittest.TestCase):
|
|||
|
|
"""Тесты конвертации секунд"""
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
# SECONDS CONVERSION
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
def test_seconds_to_usd_one(self):
|
|||
|
|
"""1 секунда → USD"""
|
|||
|
|
result = seconds_to_usd(1)
|
|||
|
|
self.assertAlmostEqual(result, 0.1605, places=4)
|
|||
|
|
|
|||
|
|
def test_seconds_to_usd_sixty(self):
|
|||
|
|
"""60 секунд (1 минута) → USD"""
|
|||
|
|
result = seconds_to_usd(60)
|
|||
|
|
expected = 60 * BeepleAnchor.USD_PER_SECOND
|
|||
|
|
self.assertAlmostEqual(result, expected, places=2)
|
|||
|
|
|
|||
|
|
def test_seconds_to_usd_ten_minutes(self):
|
|||
|
|
"""600 секунд (10 минут) → USD"""
|
|||
|
|
result = seconds_to_usd(600)
|
|||
|
|
self.assertAlmostEqual(result, 96.3, places=1)
|
|||
|
|
|
|||
|
|
def test_usd_to_seconds_one_second_price(self):
|
|||
|
|
"""$0.1605 → 1 секунда"""
|
|||
|
|
result = usd_to_seconds(0.1605)
|
|||
|
|
self.assertAlmostEqual(result, 1.0, places=2)
|
|||
|
|
|
|||
|
|
def test_usd_to_seconds_one_hundred(self):
|
|||
|
|
"""$100 → секунды"""
|
|||
|
|
result = usd_to_seconds(100)
|
|||
|
|
expected = 100 / BeepleAnchor.USD_PER_SECOND
|
|||
|
|
self.assertAlmostEqual(result, expected, places=2)
|
|||
|
|
|
|||
|
|
def test_seconds_roundtrip(self):
|
|||
|
|
"""Roundtrip: секунды → USD → секунды"""
|
|||
|
|
original = 3600 # 1 час
|
|||
|
|
converted = seconds_to_usd(original)
|
|||
|
|
back = usd_to_seconds(converted)
|
|||
|
|
self.assertAlmostEqual(back, original, places=2)
|
|||
|
|
|
|||
|
|
|
|||
|
|
class TestDaysConversion(unittest.TestCase):
|
|||
|
|
"""Тесты конвертации дней"""
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
# DAYS CONVERSION
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
def test_days_to_usd_one(self):
|
|||
|
|
"""1 день → USD"""
|
|||
|
|
result = days_to_usd(1)
|
|||
|
|
self.assertAlmostEqual(result, BeepleAnchor.USD_PER_DAY, places=2)
|
|||
|
|
self.assertAlmostEqual(result, 13869.25, places=2)
|
|||
|
|
|
|||
|
|
def test_days_to_usd_5000(self):
|
|||
|
|
"""5000 дней → USD (полная работа Beeple)"""
|
|||
|
|
result = days_to_usd(5000)
|
|||
|
|
self.assertAlmostEqual(result, BeepleAnchor.SALE_PRICE_USD, places=2)
|
|||
|
|
|
|||
|
|
def test_days_to_usd_fractional(self):
|
|||
|
|
"""0.5 дня → USD"""
|
|||
|
|
result = days_to_usd(0.5)
|
|||
|
|
expected = BeepleAnchor.USD_PER_DAY * 0.5
|
|||
|
|
self.assertAlmostEqual(result, expected, places=2)
|
|||
|
|
|
|||
|
|
def test_usd_to_days_one_day_price(self):
|
|||
|
|
"""$13,869.25 → 1 день"""
|
|||
|
|
result = usd_to_days(13869.25)
|
|||
|
|
self.assertAlmostEqual(result, 1.0, places=2)
|
|||
|
|
|
|||
|
|
def test_usd_to_days_full_sale(self):
|
|||
|
|
"""$69.3M → 5000 дней"""
|
|||
|
|
result = usd_to_days(BeepleAnchor.SALE_PRICE_USD)
|
|||
|
|
self.assertAlmostEqual(result, 5000, places=2)
|
|||
|
|
|
|||
|
|
def test_days_roundtrip(self):
|
|||
|
|
"""Roundtrip: дни → USD → дни"""
|
|||
|
|
original = 365 # 1 год
|
|||
|
|
converted = days_to_usd(original)
|
|||
|
|
back = usd_to_days(converted)
|
|||
|
|
self.assertAlmostEqual(back, original, places=2)
|
|||
|
|
|
|||
|
|
|
|||
|
|
class TestAnchorInfo(unittest.TestCase):
|
|||
|
|
"""Тесты получения информации о якоре"""
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
# ANCHOR INFO
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
def test_get_anchor_info_structure(self):
|
|||
|
|
"""Структура информации о якоре"""
|
|||
|
|
info = get_anchor_info()
|
|||
|
|
|
|||
|
|
self.assertIsInstance(info, dict)
|
|||
|
|
self.assertIn("sale_price_usd", info)
|
|||
|
|
self.assertIn("total_days", info)
|
|||
|
|
self.assertIn("sale_date", info)
|
|||
|
|
self.assertIn("usd_per_second", info)
|
|||
|
|
self.assertIn("usd_per_minute", info)
|
|||
|
|
self.assertIn("usd_per_hour", info)
|
|||
|
|
self.assertIn("usd_per_day", info)
|
|||
|
|
self.assertIn("mta_per_second", info)
|
|||
|
|
self.assertIn("usd_per_mta", info)
|
|||
|
|
|
|||
|
|
def test_get_anchor_info_values(self):
|
|||
|
|
"""Значения в информации о якоре"""
|
|||
|
|
info = get_anchor_info()
|
|||
|
|
|
|||
|
|
self.assertEqual(info["sale_price_usd"], 69_346_250.00)
|
|||
|
|
self.assertEqual(info["total_days"], 5000)
|
|||
|
|
self.assertEqual(info["sale_date"], "2021-03-11")
|
|||
|
|
self.assertAlmostEqual(info["usd_per_second"], 0.1605, places=4)
|
|||
|
|
self.assertEqual(info["mta_per_second"], 1.0)
|
|||
|
|
|
|||
|
|
|
|||
|
|
class TestFormatPrice(unittest.TestCase):
|
|||
|
|
"""Тесты форматирования цены"""
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
# FORMAT PRICE
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
def test_format_price_usd(self):
|
|||
|
|
"""Форматирование в USD"""
|
|||
|
|
result = format_price(96.31, "USD")
|
|||
|
|
self.assertEqual(result, "$96.31 USD")
|
|||
|
|
|
|||
|
|
def test_format_price_mta(self):
|
|||
|
|
"""Форматирование в MTA"""
|
|||
|
|
usd_amount = 0.1605 # 1 MTA
|
|||
|
|
result = format_price(usd_amount, "MTA")
|
|||
|
|
self.assertIn("MTA", result)
|
|||
|
|
self.assertIn("1.00", result)
|
|||
|
|
|
|||
|
|
def test_format_price_large_number(self):
|
|||
|
|
"""Форматирование большого числа"""
|
|||
|
|
result = format_price(13869.25, "USD")
|
|||
|
|
self.assertEqual(result, "$13869.25 USD")
|
|||
|
|
|
|||
|
|
def test_format_price_zero(self):
|
|||
|
|
"""Форматирование нуля"""
|
|||
|
|
result = format_price(0.0, "USD")
|
|||
|
|
self.assertEqual(result, "$0.00 USD")
|
|||
|
|
|
|||
|
|
|
|||
|
|
class TestPizzaDayCalculator(unittest.TestCase):
|
|||
|
|
"""Тесты Pizza Day механизма"""
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
# PIZZA DAY MECHANISM
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
def test_is_pizza_day_true(self):
|
|||
|
|
"""22 мая — это Pizza Day"""
|
|||
|
|
pizza_day = datetime(2025, 5, 22, tzinfo=timezone.utc)
|
|||
|
|
result = PizzaDayCalculator.is_pizza_day(pizza_day)
|
|||
|
|
self.assertTrue(result)
|
|||
|
|
|
|||
|
|
def test_is_pizza_day_false(self):
|
|||
|
|
"""23 мая — НЕ Pizza Day"""
|
|||
|
|
not_pizza_day = datetime(2025, 5, 23, tzinfo=timezone.utc)
|
|||
|
|
result = PizzaDayCalculator.is_pizza_day(not_pizza_day)
|
|||
|
|
self.assertFalse(result)
|
|||
|
|
|
|||
|
|
def test_is_pizza_day_different_year(self):
|
|||
|
|
"""Pizza Day в другом году"""
|
|||
|
|
pizza_day_2030 = datetime(2030, 5, 22, tzinfo=timezone.utc)
|
|||
|
|
result = PizzaDayCalculator.is_pizza_day(pizza_day_2030)
|
|||
|
|
self.assertTrue(result)
|
|||
|
|
|
|||
|
|
def test_days_until_pizza_day_before(self):
|
|||
|
|
"""Дней до Pizza Day (до 22 мая)"""
|
|||
|
|
date = datetime(2025, 5, 1, tzinfo=timezone.utc)
|
|||
|
|
result = PizzaDayCalculator.days_until_pizza_day(date)
|
|||
|
|
self.assertEqual(result, 21) # 22 - 1 = 21 день
|
|||
|
|
|
|||
|
|
def test_days_until_pizza_day_after(self):
|
|||
|
|
"""Дней до Pizza Day (после 22 мая)"""
|
|||
|
|
date = datetime(2025, 6, 1, tzinfo=timezone.utc)
|
|||
|
|
result = PizzaDayCalculator.days_until_pizza_day(date)
|
|||
|
|
|
|||
|
|
# Должно быть ~355 дней до следующего 22 мая
|
|||
|
|
self.assertGreater(result, 300)
|
|||
|
|
self.assertLess(result, 366)
|
|||
|
|
|
|||
|
|
def test_days_until_pizza_day_on_pizza_day(self):
|
|||
|
|
"""Дней до Pizza Day в сам Pizza Day"""
|
|||
|
|
pizza_day = datetime(2025, 5, 22, tzinfo=timezone.utc)
|
|||
|
|
result = PizzaDayCalculator.days_until_pizza_day(pizza_day)
|
|||
|
|
|
|||
|
|
# В сам Pizza Day — 0 дней до него (или 365 до следующего)
|
|||
|
|
# Зависит от времени суток
|
|||
|
|
self.assertIn(result, [0, 365])
|
|||
|
|
|
|||
|
|
def test_recalculate_anchor(self):
|
|||
|
|
"""Пересчёт якоря с новыми значениями"""
|
|||
|
|
new_price = 100_000_000 # $100M
|
|||
|
|
new_days = 10_000
|
|||
|
|
|
|||
|
|
result = PizzaDayCalculator.recalculate_anchor(new_price, new_days)
|
|||
|
|
|
|||
|
|
self.assertEqual(result["sale_price_usd"], new_price)
|
|||
|
|
self.assertEqual(result["total_days"], new_days)
|
|||
|
|
self.assertAlmostEqual(result["usd_per_day"], 10_000, places=2)
|
|||
|
|
self.assertAlmostEqual(result["usd_per_second"], 0.1157, places=4)
|
|||
|
|
|
|||
|
|
def test_recalculate_anchor_doubles_price(self):
|
|||
|
|
"""Пересчёт с удвоенной ценой"""
|
|||
|
|
original_price = BeepleAnchor.SALE_PRICE_USD
|
|||
|
|
doubled_price = original_price * 2
|
|||
|
|
|
|||
|
|
result = PizzaDayCalculator.recalculate_anchor(doubled_price, BeepleAnchor.TOTAL_DAYS)
|
|||
|
|
|
|||
|
|
# USD/секунда должен удвоиться
|
|||
|
|
expected_usd_per_sec = BeepleAnchor.USD_PER_SECOND * 2
|
|||
|
|
self.assertAlmostEqual(result["usd_per_second"], expected_usd_per_sec, places=4)
|
|||
|
|
|
|||
|
|
|
|||
|
|
class TestConsistency(unittest.TestCase):
|
|||
|
|
"""Тесты консистентности расчётов"""
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
# CONSISTENCY
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
def test_seconds_equals_mta(self):
|
|||
|
|
"""1 секунда = 1 MTA"""
|
|||
|
|
seconds_value = seconds_to_usd(1)
|
|||
|
|
mta_value = mta_to_usd(1)
|
|||
|
|
self.assertAlmostEqual(seconds_value, mta_value, places=4)
|
|||
|
|
|
|||
|
|
def test_day_to_seconds_consistency(self):
|
|||
|
|
"""86400 секунд = 1 день"""
|
|||
|
|
usd_from_seconds = seconds_to_usd(86400)
|
|||
|
|
usd_from_days = days_to_usd(1)
|
|||
|
|
self.assertAlmostEqual(usd_from_seconds, usd_from_days, places=2)
|
|||
|
|
|
|||
|
|
def test_beeple_calculation_consistency(self):
|
|||
|
|
"""$69.3M / 5000 дней / 86400 сек = $0.1605/сек"""
|
|||
|
|
calculated = BeepleAnchor.SALE_PRICE_USD / BeepleAnchor.TOTAL_DAYS / 86400
|
|||
|
|
self.assertAlmostEqual(calculated, BeepleAnchor.USD_PER_SECOND, places=4)
|
|||
|
|
|
|||
|
|
def test_all_units_consistent(self):
|
|||
|
|
"""Все единицы согласованы"""
|
|||
|
|
# 1 день = 24 часа = 1440 минут = 86400 секунд
|
|||
|
|
day_price = BeepleAnchor.USD_PER_DAY
|
|||
|
|
hour_price = BeepleAnchor.USD_PER_HOUR * 24
|
|||
|
|
minute_price = BeepleAnchor.USD_PER_MINUTE * 1440
|
|||
|
|
second_price = BeepleAnchor.USD_PER_SECOND * 86400
|
|||
|
|
|
|||
|
|
self.assertAlmostEqual(day_price, hour_price, places=2)
|
|||
|
|
self.assertAlmostEqual(day_price, minute_price, places=2)
|
|||
|
|
self.assertAlmostEqual(day_price, second_price, places=2)
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════════
|
|||
|
|
# RUN TESTS
|
|||
|
|
# ═══════════════════════════════════════════════════════════════════════════
|
|||
|
|
|
|||
|
|
if __name__ == '__main__':
|
|||
|
|
# Запускаем с verbose output
|
|||
|
|
unittest.main(verbosity=2)
|