diff --git a/src/sakia/core/community.py b/src/sakia/core/community.py
index bc97eddeb913a1d9a7976a7e4c9772b4ef674204..e9104305ccad82bd1cac164f5bc00b991c0056fd 100644
--- a/src/sakia/core/community.py
+++ b/src/sakia/core/community.py
@@ -116,13 +116,16 @@ class Community(QObject):
u = ord('\u24B6') + ord(letter) - ord('A')
return chr(u)
- async def dividend(self):
+ async def dividend(self, block_number=None):
"""
- Get the last generated community universal dividend.
+ Get the last generated community universal dividend before block_number.
+ If block_number is None, returns the last block_number.
+
+ :param int block_number: The block at which we get the latest dividend
:return: The last UD or 1 if no UD was generated.
"""
- block = await self.get_ud_block()
+ block = await self.get_ud_block(block_number=block_number)
if block:
return block['dividend']
else:
@@ -152,18 +155,24 @@ class Community(QObject):
else:
return 1
- async def get_ud_block(self, x=0):
+ async def get_ud_block(self, x=0, block_number=None):
"""
Get a block with universal dividend
+ If x and block_number are passed to the result,
+ it returns the 'x' older block with UD in it BEFORE block_number
:param int x: Get the 'x' older block with UD in it
+ :param int block_number: Get the latest dividend before this block number
:return: The last block with universal dividend.
+ :rtype: dict
"""
try:
udblocks = await self.bma_access.future_request(bma.blockchain.UD)
blocks = udblocks['result']['blocks']
+ if block_number:
+ blocks = [b for b in blocks if b <= block_number]
if len(blocks) > 0:
- index = len(blocks)-(1+x)
+ index = len(blocks) - (1+x)
if index < 0:
index = 0
block_number = blocks[index]
diff --git a/src/sakia/core/money/__init__.py b/src/sakia/core/money/__init__.py
index 05a4b506a6ff4f03c503992f6cae11774a6a4ab1..21b04a8f501cfb26ba65419a6e3590b5d54bb331 100644
--- a/src/sakia/core/money/__init__.py
+++ b/src/sakia/core/money/__init__.py
@@ -2,5 +2,6 @@ from .quantitative import Quantitative
from .relative import Relative
from .quant_zerosum import QuantitativeZSum
from .relative_zerosum import RelativeZSum
+from .relative_to_past import RelativeToPast
-Referentials = (Quantitative, Relative, QuantitativeZSum, RelativeZSum)
+Referentials = (Quantitative, Relative, QuantitativeZSum, RelativeZSum, RelativeToPast)
diff --git a/src/sakia/core/money/base_referential.py b/src/sakia/core/money/base_referential.py
new file mode 100644
index 0000000000000000000000000000000000000000..4040074b7695f74c10cd3d464da2cb4fbe3bed37
--- /dev/null
+++ b/src/sakia/core/money/base_referential.py
@@ -0,0 +1,41 @@
+from PyQt5.QtCore import QCoreApplication, QT_TRANSLATE_NOOP, QObject, QLocale
+import asyncio
+
+
+class BaseReferential:
+ """
+ Interface to all referentials
+ """
+ def __init__(self, amount, community, app, block_number=None):
+ self.amount = amount
+ self.community = community
+ self.app = app
+ self._block_number = block_number
+
+ @classmethod
+ def translated_name(self):
+ pass
+
+ @property
+ def units(self):
+ pass
+
+ @property
+ def diff_units(self):
+ pass
+
+ async def value(self):
+ pass
+
+ async def differential(self):
+ pass
+
+ @staticmethod
+ def to_si(value, digits):
+ pass
+
+ async def localized(self, units=False, international_system=False):
+ pass
+
+ async def diff_localized(self, units=False, international_system=False):
+ pass
diff --git a/src/sakia/core/money/quant_zerosum.py b/src/sakia/core/money/quant_zerosum.py
index 2c63322514e1d69c2952869965da43c8d61ab421..98f1f1c26569db4de65c5c729e314d31d4b5ef9e 100644
--- a/src/sakia/core/money/quant_zerosum.py
+++ b/src/sakia/core/money/quant_zerosum.py
@@ -1,29 +1,27 @@
from PyQt5.QtCore import QCoreApplication, QT_TRANSLATE_NOOP, QLocale
from . import Quantitative
-import asyncio
+from .base_referential import BaseReferential
-class QuantitativeZSum:
+class QuantitativeZSum(BaseReferential):
_NAME_STR_ = QT_TRANSLATE_NOOP('QuantitativeZSum', 'Quant Z-sum')
- _REF_STR_ = QT_TRANSLATE_NOOP('QuantitativeZSum', "{0} Q0 {1}")
+ _REF_STR_ = QT_TRANSLATE_NOOP('QuantitativeZSum', "{0} {1}Q0 {2}")
_UNITS_STR_ = QT_TRANSLATE_NOOP('QuantitativeZSum', "Q0 {0}")
- def __init__(self, amount, community, app):
- self.amount = amount
- self.community = community
- self.app = app
+ def __init__(self, amount, community, app, block_number=None):
+ super().__init__(amount, community, app, block_number)
@classmethod
def translated_name(cls):
return QCoreApplication.translate('QuantitativeZSum', QuantitativeZSum._NAME_STR_)
- @classmethod
- def units(cls, currency):
- return QCoreApplication.translate("QuantitativeZSum", QuantitativeZSum._UNITS_STR_).format(currency)
+ @property
+ def units(self):
+ return QCoreApplication.translate("QuantitativeZSum", QuantitativeZSum._UNITS_STR_).format(self.community.short_currency)
- @classmethod
- def diff_units(cls, currency):
- return Quantitative.units(currency)
+ @property
+ def diff_units(self):
+ return self.units
async def value(self):
"""
@@ -43,7 +41,7 @@ class QuantitativeZSum:
ud_block = await self.community.get_ud_block()
if ud_block and ud_block['membersCount'] > 0:
monetary_mass = await self.community.monetary_mass()
- average = monetary_mass / ud_block['membersCount']
+ average = int(monetary_mass / ud_block['membersCount'])
else:
average = 0
return self.amount - average
@@ -60,10 +58,11 @@ class QuantitativeZSum:
else:
localized_value = QLocale().toString(float(value), 'f', 0)
- if units:
+ if units or international_system:
return QCoreApplication.translate("QuantitativeZSum",
QuantitativeZSum._REF_STR_) \
.format(localized_value,
+ prefix,
self.community.short_currency if units else "")
else:
return localized_value
diff --git a/src/sakia/core/money/quantitative.py b/src/sakia/core/money/quantitative.py
index 811ff8f0c9cd2473410576f7d513f5ce176373ca..d1d07c151059c58ed1336fcf0da2b981c5b6666e 100644
--- a/src/sakia/core/money/quantitative.py
+++ b/src/sakia/core/money/quantitative.py
@@ -1,28 +1,26 @@
-from PyQt5.QtCore import QCoreApplication, QT_TRANSLATE_NOOP, QObject, QLocale
-import asyncio
+from PyQt5.QtCore import QCoreApplication, QT_TRANSLATE_NOOP, QLocale
+from .base_referential import BaseReferential
-class Quantitative():
+class Quantitative(BaseReferential):
_NAME_STR_ = QT_TRANSLATE_NOOP('Quantitative', 'Units')
_REF_STR_ = QT_TRANSLATE_NOOP('Quantitative', "{0} {1}{2}")
_UNITS_STR_ = QT_TRANSLATE_NOOP('Quantitative', "{0}")
- def __init__(self, amount, community, app):
- self.amount = amount
- self.community = community
- self.app = app
+ def __init__(self, amount, community, app, block_number=None):
+ super().__init__(amount, community, app, block_number)
@classmethod
def translated_name(cls):
return QCoreApplication.translate('Quantitative', Quantitative._NAME_STR_)
- @classmethod
- def units(cls, currency):
- return QCoreApplication.translate("Quantitative", Quantitative._UNITS_STR_).format(currency)
+ @property
+ def units(self):
+ return QCoreApplication.translate("Quantitative", Quantitative._UNITS_STR_).format(self.community.short_currency)
- @classmethod
- def diff_units(cls, currency):
- return Quantitative.units(currency)
+ @property
+ def diff_units(self):
+ return self.units
async def value(self):
"""
diff --git a/src/sakia/core/money/relative.py b/src/sakia/core/money/relative.py
index 29b7d3f0d001d87a8d75b1341df748b0adff35d7..1ca052fd65cf2dd5afad51669658d6bb1374e970 100644
--- a/src/sakia/core/money/relative.py
+++ b/src/sakia/core/money/relative.py
@@ -1,28 +1,26 @@
from PyQt5.QtCore import QObject, QCoreApplication, QT_TRANSLATE_NOOP, QLocale
-import asyncio
+from .base_referential import BaseReferential
-class Relative:
+class Relative(BaseReferential):
_NAME_STR_ = QT_TRANSLATE_NOOP('Relative', 'UD')
_REF_STR_ = QT_TRANSLATE_NOOP('Relative', "{0} {1}UD {2}")
_UNITS_STR_ = QT_TRANSLATE_NOOP('Relative', "UD {0}")
- def __init__(self, amount, community, app):
- self.amount = amount
- self.community = community
- self.app = app
+ def __init__(self, amount, community, app, block_number=None):
+ super().__init__(amount, community, app, block_number)
@classmethod
def translated_name(cls):
return QCoreApplication.translate('Relative', Relative._NAME_STR_)
- @classmethod
- def units(self, currency):
- return QCoreApplication.translate("Relative", Relative._UNITS_STR_).format(currency)
+ @property
+ def units(self):
+ return QCoreApplication.translate("Relative", Relative._UNITS_STR_).format(self.community.short_currency)
- @classmethod
- def diff_units(self, currency):
- return self.units(currency)
+ @property
+ def diff_units(self):
+ return self.units
async def value(self):
"""
diff --git a/src/sakia/core/money/relative_to_past.py b/src/sakia/core/money/relative_to_past.py
new file mode 100644
index 0000000000000000000000000000000000000000..8fdae53c34b54ec1aa3b136ac2219936b945494c
--- /dev/null
+++ b/src/sakia/core/money/relative_to_past.py
@@ -0,0 +1,91 @@
+from PyQt5.QtCore import QObject, QCoreApplication, QT_TRANSLATE_NOOP, QLocale, QDateTime
+from .base_referential import BaseReferential
+from . import Relative
+
+
+class RelativeToPast(BaseReferential):
+ _NAME_STR_ = QT_TRANSLATE_NOOP('RelativeToPast', 'Past UD')
+ _REF_STR_ = QT_TRANSLATE_NOOP('RelativeToPast', "{0} {1}UD({2}) {3}")
+ _UNITS_STR_ = QT_TRANSLATE_NOOP('RelativeToPast', "UD({0}) {1}")
+
+ def __init__(self, amount, community, app, block_number=None):
+ super().__init__(amount, community, app, block_number)
+
+ @classmethod
+ def translated_name(cls):
+ return QCoreApplication.translate('RelativeToPast', RelativeToPast._NAME_STR_)
+
+ @property
+ def units(self):
+ return QCoreApplication.translate("RelativeToPast", RelativeToPast._UNITS_STR_).format('t',
+ self.community.short_currency)
+
+ @property
+ def diff_units(self):
+ return self.units
+
+ async def value(self):
+ """
+ Return relative to past value of amount
+ :return: float
+ """
+ dividend = await self.community.dividend()
+ if dividend > 0:
+ return self.amount / float(dividend)
+ else:
+ return self.amount
+
+ async def differential(self):
+ """
+ Return relative to past differential value of amount
+ :return: float
+ """
+ dividend = await self.community.dividend(self._block_number)
+ if dividend > 0:
+ return self.amount / float(dividend)
+ else:
+ return self.amount
+
+ async def localized(self, units=False, international_system=False):
+ value = await self.value()
+ block = await self.community.get_block()
+ prefix = ""
+ if international_system:
+ localized_value, prefix = Relative.to_si(value, self.app.preferences['digits_after_comma'])
+ else:
+ localized_value = QLocale().toString(float(value), 'f', self.app.preferences['digits_after_comma'])
+
+ if units or international_system:
+ return QCoreApplication.translate("RelativeToPast", RelativeToPast._REF_STR_) \
+ .format(localized_value,
+ prefix,
+ QLocale.toString(
+ QLocale(),
+ QDateTime.fromTime_t(block['medianTime']).date(),
+ QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
+ ),
+ self.community.short_currency if units else "")
+ else:
+ return localized_value
+
+ async def diff_localized(self, units=False, international_system=False):
+ value = await self.differential()
+ block = await self.community.get_block(self._block_number)
+ prefix = ""
+ if international_system and value != 0:
+ localized_value, prefix = Relative.to_si(value, self.app.preferences['digits_after_comma'])
+ else:
+ localized_value = QLocale().toString(float(value), 'f', self.app.preferences['digits_after_comma'])
+
+ if units or international_system:
+ return QCoreApplication.translate("RelativeToPast", RelativeToPast._REF_STR_)\
+ .format(localized_value,
+ prefix,
+ QLocale.toString(
+ QLocale(),
+ QDateTime.fromTime_t(block['medianTime']).date(),
+ QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
+ ),
+ self.community.short_currency if units else "")
+ else:
+ return localized_value
diff --git a/src/sakia/core/money/relative_zerosum.py b/src/sakia/core/money/relative_zerosum.py
index 5a6b823985ec04ade40327397fffe1337c2df790..797f7cb4d80fa78622c2b76b9a909b8702267b79 100644
--- a/src/sakia/core/money/relative_zerosum.py
+++ b/src/sakia/core/money/relative_zerosum.py
@@ -1,29 +1,27 @@
from PyQt5.QtCore import QCoreApplication, QT_TRANSLATE_NOOP, QLocale
from .relative import Relative
-import asyncio
+from .base_referential import BaseReferential
-class RelativeZSum:
+class RelativeZSum(BaseReferential):
_NAME_STR_ = QT_TRANSLATE_NOOP('RelativeZSum', 'Relat Z-sum')
- _REF_STR_ = QT_TRANSLATE_NOOP('RelativeZSum', "{0} R0 {1}")
+ _REF_STR_ = QT_TRANSLATE_NOOP('RelativeZSum', "{0} {1}R0 {2}")
_UNITS_STR_ = QT_TRANSLATE_NOOP('RelativeZSum', "R0 {0}")
- def __init__(self, amount, community, app):
- self.amount = amount
- self.community = community
- self.app = app
+ def __init__(self, amount, community, app, block_number=None):
+ super().__init__(amount, community, app, block_number)
@classmethod
def translated_name(cls):
return QCoreApplication.translate('RelativeZSum', RelativeZSum._NAME_STR_)
- @classmethod
- def units(cls, currency):
- return QCoreApplication.translate("RelativeZSum", RelativeZSum._UNITS_STR_).format(currency)
+ @property
+ def units(self):
+ return QCoreApplication.translate("RelativeZSum", RelativeZSum._UNITS_STR_).format(self.community.short_currency)
- @classmethod
- def diff_units(cls, currency):
- return Relative.units(currency)
+ @property
+ def diff_units(self):
+ return self.units
async def value(self):
"""
@@ -41,7 +39,7 @@ class RelativeZSum:
:return: float
"""
ud_block = await self.community.get_ud_block()
- ud_block_minus_1 = await self.community.get_ud_block(1)
+ ud_block_minus_1 = await self.community.get_ud_block(x=1)
if ud_block_minus_1 and ud_block['membersCount'] > 0:
median = ud_block_minus_1['monetaryMass'] / ud_block['membersCount']
relative_value = self.amount / float(ud_block['dividend'])
@@ -63,9 +61,10 @@ class RelativeZSum:
else:
localized_value = QLocale().toString(float(value), 'f', self.app.preferences['digits_after_comma'])
- if units:
+ if units or international_system:
return QCoreApplication.translate("RelativeZSum", RelativeZSum._REF_STR_)\
.format(localized_value,
+ prefix,
self.community.short_currency if units else "")
else:
return localized_value
@@ -79,8 +78,8 @@ class RelativeZSum:
else:
localized_value = QLocale().toString(float(value), 'f', self.app.preferences['digits_after_comma'])
- if units:
+ if units or international_system:
return QCoreApplication.translate("RelativeZSum", RelativeZSum._REF_STR_)\
- .format(localized_value, self.community.short_currency if units else "")
+ .format(localized_value, prefix, self.community.short_currency if units else "")
else:
return localized_value
diff --git a/src/sakia/gui/informations_tab.py b/src/sakia/gui/informations_tab.py
index bfad9b2f535dcc205a324538fe00a965aac780fd..790556d52ccf8e4de8b76b6354fa73bc49796139 100644
--- a/src/sakia/gui/informations_tab.py
+++ b/src/sakia/gui/informations_tab.py
@@ -70,7 +70,7 @@ class InformationsTabWidget(QWidget, Ui_InformationsTabWidget):
logging.debug('community get_ud_block error : ' + str(e))
return False
try:
- block_ud_minus_1 = await self.community.get_ud_block(1)
+ block_ud_minus_1 = await self.community.get_ud_block(x=1)
except NoPeerAvailable as e:
logging.debug('community get_ud_block error : ' + str(e))
return False
@@ -125,15 +125,15 @@ class InformationsTabWidget(QWidget, Ui_InformationsTabWidget):
""").format(
localized_ud,
self.tr('Universal Dividend UD(t) in'),
- self.account.current_ref.diff_units(self.community.currency),
+ self.account.current_ref(0, self.community, self.app, None).diff_units,
localized_mass_minus_1,
self.tr('Monetary Mass M(t-1) in'),
- self.account.current_ref.diff_units(self.community.currency),
+ self.account.current_ref(0, self.community, self.app, None).units,
block_ud['membersCount'],
self.tr('Members N(t)'),
localized_mass_minus_1_per_member,
self.tr('Monetary Mass per member M(t-1)/N(t) in'),
- self.account.current_ref.diff_units(self.community.currency),
+ self.account.current_ref(0, self.community, self.app, None).diff_units,
float(0) if block_ud['membersCount'] == 0 or block_ud_minus_1['monetaryMass'] == 0 else
block_ud['dividend'] / (block_ud_minus_1['monetaryMass'] / block_ud['membersCount']),
@@ -179,10 +179,10 @@ class InformationsTabWidget(QWidget, Ui_InformationsTabWidget):
self.tr('{:} = MAX {{ {:} {:} ; {:2.0%} × {:} {:} / {:} }}').format(
localized_ud_plus_1,
localized_ud,
- self.account.current_ref.diff_units(self.community.currency),
+ self.account.current_ref(0, self.community, self.app, None).diff_units,
params['c'],
localized_mass,
- self.account.current_ref.diff_units(self.community.currency),
+ self.account.current_ref(0, self.community, self.app, None).diff_units,
block_ud['membersCount']
),
self.tr('Universal Dividend (computed)')
diff --git a/src/sakia/models/txhistory.py b/src/sakia/models/txhistory.py
index d138dada1f9d006d46f344bdc1ef6c6672f70a5e..8bbc8a66af86acce4fb34fb6dd45e6fd4e14075c 100644
--- a/src/sakia/models/txhistory.py
+++ b/src/sakia/models/txhistory.py
@@ -231,7 +231,8 @@ class HistoryTableModel(QAbstractTableModel):
async def data_received(self, transfer):
amount = transfer.metadata['amount']
- deposit = await self.account.current_ref(transfer.metadata['amount'], self.community, self.app)\
+ deposit = await self.account.current_ref(transfer.metadata['amount'], self.community,
+ self.app, transfer.blockid.number)\
.diff_localized(international_system=self.app.preferences['international_system_of_units'])
comment = ""
if transfer.metadata['comment'] != "":
@@ -254,7 +255,8 @@ class HistoryTableModel(QAbstractTableModel):
async def data_sent(self, transfer):
amount = transfer.metadata['amount']
- paiment = await self.account.current_ref(transfer.metadata['amount'], self.community, self.app)\
+ paiment = await self.account.current_ref(transfer.metadata['amount'], self.community,
+ self.app, transfer.blockid.number)\
.diff_localized(international_system=self.app.preferences['international_system_of_units'])
comment = ""
if transfer.metadata['comment'] != "":
@@ -277,7 +279,7 @@ class HistoryTableModel(QAbstractTableModel):
async def data_dividend(self, dividend):
amount = dividend['amount']
- deposit = await self.account.current_ref(dividend['amount'], self.community, self.app)\
+ deposit = await self.account.current_ref(dividend['amount'], self.community, self.app, dividend['block_number'])\
.diff_localized(international_system=self.app.preferences['international_system_of_units'])
comment = ""
receiver = self.account.name
@@ -334,7 +336,7 @@ class HistoryTableModel(QAbstractTableModel):
if self.columns_types[section] == 'payment' or self.columns_types[section] == 'deposit':
return '{:}\n({:})'.format(
self.column_headers[section](),
- self.account.current_ref.diff_units(self.community.short_currency)
+ self.account.current_ref(0, self.community, self.app, None).diff_units
)
return self.column_headers[section]()
diff --git a/src/sakia/models/wallets.py b/src/sakia/models/wallets.py
index a656f182d05107b72ba6dc777cbf32967a83c61d..4428dcbb9cc070488c58c4ac009857f0ff74541b 100644
--- a/src/sakia/models/wallets.py
+++ b/src/sakia/models/wallets.py
@@ -112,7 +112,7 @@ class WalletsTableModel(QAbstractTableModel):
if self.columns_types[section] == 'amount':
return '{:}\n({:})'.format(
self.columns_headers[section],
- self.account.current_ref.units(self.community.short_currency)
+ self.account.current_ref(0, self.community, self.app, None).units
)
return self.columns_headers[section]
diff --git a/src/sakia/tests/unit/core/money/__init__.py b/src/sakia/tests/unit/core/money/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/sakia/tests/unit/core/money/test_quantitative.py b/src/sakia/tests/unit/core/money/test_quantitative.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd32a301ff91a7280f982bb66e68ade163d32be4
--- /dev/null
+++ b/src/sakia/tests/unit/core/money/test_quantitative.py
@@ -0,0 +1,144 @@
+import unittest
+from asynctest.mock import Mock, CoroutineMock, patch, PropertyMock
+from PyQt5.QtCore import QLocale
+from sakia.tests import QuamashTest
+from sakia.core.money import Quantitative
+
+
+class TestQuantitative(unittest.TestCase, QuamashTest):
+ def setUp(self):
+ self.setUpQuamash()
+ QLocale.setDefault(QLocale("en_GB"))
+
+ def tearDown(self):
+ self.tearDownQuamash()
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_units(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ referential = Quantitative(0, community, app, None)
+ self.assertEqual(referential.units, "TC")
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_units(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ referential = Quantitative(0, community, app, None)
+ self.assertEqual(referential.units, "TC")
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_value(self, app, community):
+ referential = Quantitative(101010110, community, app, None)
+ async def exec_test():
+ value = await referential.value()
+ self.assertEqual(value, 101010110)
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_differential(self, app, community):
+ referential = Quantitative(110, community, app, None)
+ async def exec_test():
+ value = await referential.value()
+ self.assertEqual(value, 110)
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ referential = Quantitative(101010110, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=True)
+ self.assertEqual(value, "101,010,110 TC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_with_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Quantitative(101010110, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=True, international_system=True)
+ self.assertEqual(value, "101.010110 MTC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_units_no_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Quantitative(101010110, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=False, international_system=False)
+ self.assertEqual(value, "101,010,110")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_units_with_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Quantitative(101010110, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=False, international_system=True)
+ self.assertEqual(value, "101.010110 M")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ referential = Quantitative(101010110, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=True)
+ self.assertEqual(value, "101,010,110 TC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_with_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Quantitative(101010110, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=True, international_system=True)
+ self.assertEqual(value, "101.010110 MTC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_units_no_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Quantitative(101010110, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=False, international_system=False)
+ self.assertEqual(value, "101,010,110")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_units_with_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Quantitative(101010110, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=False, international_system=True)
+ self.assertEqual(value, "101.010110 M")
+ self.lp.run_until_complete(exec_test())
diff --git a/src/sakia/tests/unit/core/money/test_quantitative_zsum.py b/src/sakia/tests/unit/core/money/test_quantitative_zsum.py
new file mode 100644
index 0000000000000000000000000000000000000000..68ecaad7c751ba4b8f6fa014c93875e0bc85ebe7
--- /dev/null
+++ b/src/sakia/tests/unit/core/money/test_quantitative_zsum.py
@@ -0,0 +1,164 @@
+import unittest
+from asynctest.mock import Mock, CoroutineMock, patch, PropertyMock
+from PyQt5.QtCore import QLocale
+from sakia.tests import QuamashTest
+from sakia.core.money import QuantitativeZSum
+
+
+class TestQuantitativeZSum(unittest.TestCase, QuamashTest):
+ def setUp(self):
+ self.setUpQuamash()
+ QLocale.setDefault(QLocale("en_GB"))
+
+ def tearDown(self):
+ self.tearDownQuamash()
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_units(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ referential = QuantitativeZSum(0, community, app, None)
+ self.assertEqual(referential.units, "Q0 TC")
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_units(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ referential = QuantitativeZSum(0, community, app, None)
+ self.assertEqual(referential.units, "Q0 TC")
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_value(self, app, community):
+ referential = QuantitativeZSum(110, community, app, None)
+ community.get_ud_block = CoroutineMock(return_value={'membersCount': 5})
+ community.monetary_mass = CoroutineMock(return_value=500)
+ async def exec_test():
+ value = await referential.value()
+ self.assertEqual(value, 10)
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_differential(self, app, community):
+ community.get_ud_block = CoroutineMock(return_value={'membersCount': 5})
+ community.monetary_mass = CoroutineMock(return_value=500)
+ referential = QuantitativeZSum(110, community, app, None)
+ async def exec_test():
+ value = await referential.value()
+ self.assertEqual(value, 10)
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.get_ud_block = CoroutineMock(return_value={'membersCount': 5})
+ community.monetary_mass = CoroutineMock(return_value=500)
+ referential = QuantitativeZSum(110, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=True)
+ self.assertEqual(value, "10 Q0 TC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_with_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.get_ud_block = CoroutineMock(return_value={'membersCount': 1000})
+ community.monetary_mass = CoroutineMock(return_value=500 * 1000)
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = QuantitativeZSum(110 * 1000, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=True, international_system=True)
+ self.assertEqual(value, "109.500000 kQ0 TC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_units_no_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.get_ud_block = CoroutineMock(return_value={'membersCount': 5})
+ community.monetary_mass = CoroutineMock(return_value=500)
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = QuantitativeZSum(110, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=False, international_system=False)
+ self.assertEqual(value, "10")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_units_with_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.get_ud_block = CoroutineMock(return_value={'membersCount': 1000})
+ community.monetary_mass = CoroutineMock(return_value=500 * 1000)
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = QuantitativeZSum(110 * 1000, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=False, international_system=True)
+ self.assertEqual(value, "109.500000 kQ0 ")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.get_ud_block = CoroutineMock(return_value={'membersCount': 1000})
+ community.monetary_mass = CoroutineMock(return_value=500 * 1000 * 1000)
+ referential = QuantitativeZSum(110 * 1000, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=True)
+ self.assertEqual(value, "110,000 TC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_with_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.get_ud_block = CoroutineMock(return_value={'membersCount': 10})
+ community.monetary_mass = CoroutineMock(return_value=500 * 1000 * 1000)
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = QuantitativeZSum(101010110, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=True, international_system=True)
+ self.assertEqual(value, "101.010110 MTC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_units_no_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.get_ud_block = CoroutineMock(return_value={'membersCount': 10})
+ community.monetary_mass = CoroutineMock(return_value=500 * 1000 * 1000)
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = QuantitativeZSum(101010110, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=False, international_system=False)
+ self.assertEqual(value, "101,010,110")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_units_with_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.get_ud_block = CoroutineMock(return_value={'membersCount': 10})
+ community.monetary_mass = CoroutineMock(return_value=500 * 1000 * 1000)
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = QuantitativeZSum(101010110, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=False, international_system=True)
+ self.assertEqual(value, "101.010110 M")
+ self.lp.run_until_complete(exec_test())
diff --git a/src/sakia/tests/unit/core/money/test_relative.py b/src/sakia/tests/unit/core/money/test_relative.py
new file mode 100644
index 0000000000000000000000000000000000000000..1791fb3ed1bdfef8ef9de254a4f6f23ef67206b9
--- /dev/null
+++ b/src/sakia/tests/unit/core/money/test_relative.py
@@ -0,0 +1,160 @@
+import unittest
+from asynctest.mock import Mock, CoroutineMock, patch, PropertyMock
+from PyQt5.QtCore import QLocale
+from sakia.tests import QuamashTest
+from sakia.core.money import Relative
+
+
+class TestRelative(unittest.TestCase, QuamashTest):
+ def setUp(self):
+ self.setUpQuamash()
+ QLocale.setDefault(QLocale("en_GB"))
+
+ def tearDown(self):
+ self.tearDownQuamash()
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_units(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ referential = Relative(0, community, app, None)
+ self.assertEqual(referential.units, "UD TC")
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_units(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ referential = Relative(0, community, app, None)
+ self.assertEqual(referential.units, "UD TC")
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_value(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ referential = Relative(10101011, community, app, None)
+ async def exec_test():
+ value = await referential.value()
+ self.assertAlmostEqual(value, 1010.10110)
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_differential(self, app, community):
+ community.dividend = CoroutineMock(return_value=1000)
+ referential = Relative(110, community, app, None)
+ async def exec_test():
+ value = await referential.value()
+ self.assertAlmostEqual(value, 0.11)
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=1000)
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Relative(101, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=True)
+ self.assertEqual(value, "0.101000 UD TC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_with_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Relative(1011, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=True, international_system=True)
+ self.assertEqual(value, "1.011000 dUD TC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_units_no_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Relative(1011, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=False, international_system=False)
+ self.assertEqual(value, "0.101100")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_units_with_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Relative(1011, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=False, international_system=True)
+ self.assertEqual(value, "1.011000 dUD ")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Relative(1011, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=True)
+ self.assertEqual(value, "0.101100 UD TC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_with_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Relative(1011, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=True, international_system=True)
+ self.assertEqual(value, "1.011000 dUD TC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_units_no_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Relative(1011, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=False, international_system=False)
+ self.assertEqual(value, "0.101100")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_units_with_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = Relative(1011, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=False, international_system=True)
+ self.assertEqual(value, "1.011000 dUD ")
+ self.lp.run_until_complete(exec_test())
\ No newline at end of file
diff --git a/src/sakia/tests/unit/core/money/test_relative_to_past.py b/src/sakia/tests/unit/core/money/test_relative_to_past.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ad2cb740df151338e3c5d245fa8230013e21090
--- /dev/null
+++ b/src/sakia/tests/unit/core/money/test_relative_to_past.py
@@ -0,0 +1,192 @@
+import unittest
+from asynctest.mock import Mock, CoroutineMock, patch, PropertyMock
+from PyQt5.QtCore import QLocale, QDateTime
+from sakia.tests import QuamashTest
+from sakia.core.money import RelativeToPast
+
+
+class TestRelativeToPast(unittest.TestCase, QuamashTest):
+ def setUp(self):
+ self.setUpQuamash()
+ QLocale.setDefault(QLocale("en_GB"))
+
+ def tearDown(self):
+ self.tearDownQuamash()
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_units(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ referential = RelativeToPast(0, community, app, 100)
+ self.assertEqual(referential.units, "UD(t) TC")
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_units(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ referential = RelativeToPast(0, community, app, 100)
+ self.assertEqual(referential.units, "UD(t) TC")
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_value(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ referential = RelativeToPast(10101011, community, app, 100)
+ async def exec_test():
+ value = await referential.value()
+ self.assertAlmostEqual(value, 1010.10110)
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_differential(self, app, community):
+ community.dividend = CoroutineMock(return_value=1000)
+ referential = RelativeToPast(110, community, app, 100)
+ async def exec_test():
+ value = await referential.value()
+ self.assertAlmostEqual(value, 0.11)
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=1000)
+ community.get_block = CoroutineMock(return_value={'medianTime': 1452663088792})
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeToPast(101, community, app, 100)
+ async def exec_test():
+ value = await referential.localized(units=True)
+ self.assertEqual(value, "0.101000 UD({0}) TC".format(QLocale.toString(
+ QLocale(),
+ QDateTime.fromTime_t(1452663088792).date(),
+ QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
+ )))
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_with_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ community.get_block = CoroutineMock(return_value={'medianTime': 1452663088792})
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeToPast(1011, community, app, 100)
+ async def exec_test():
+ value = await referential.localized(units=True, international_system=True)
+ self.assertEqual(value, "1.011000 dUD({0}) TC".format(QLocale.toString(
+ QLocale(),
+ QDateTime.fromTime_t(1452663088792).date(),
+ QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
+ )))
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_units_no_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ community.get_block = CoroutineMock(return_value={'medianTime': 1452663088792})
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeToPast(1011, community, app, 100)
+ async def exec_test():
+ value = await referential.localized(units=False, international_system=False)
+ self.assertEqual(value, "0.101100")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_units_with_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ community.get_block = CoroutineMock(return_value={'medianTime': 1452663088792})
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeToPast(1011, community, app, 100)
+ async def exec_test():
+ value = await referential.localized(units=False, international_system=True)
+ self.assertEqual(value, "1.011000 dUD({0}) ".format(QLocale.toString(
+ QLocale(),
+ QDateTime.fromTime_t(1452663088792).date(),
+ QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
+ )))
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ community.get_block = CoroutineMock(return_value={'medianTime': 1452663088792})
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeToPast(1011, community, app, 100)
+ async def exec_test():
+ value = await referential.diff_localized(units=True)
+ self.assertEqual(value, "0.101100 UD({0}) TC".format(QLocale.toString(
+ QLocale(),
+ QDateTime.fromTime_t(1452663088792).date(),
+ QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
+ )))
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_with_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ community.get_block = CoroutineMock(return_value={'medianTime': 1452663088792})
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeToPast(1011, community, app, 100)
+ async def exec_test():
+ value = await referential.diff_localized(units=True, international_system=True)
+ self.assertEqual(value, "1.011000 dUD({0}) TC".format(QLocale.toString(
+ QLocale(),
+ QDateTime.fromTime_t(1452663088792).date(),
+ QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
+ )))
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_units_no_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ community.get_block = CoroutineMock(return_value={'medianTime': 1452663088792})
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeToPast(1011, community, app, 100)
+ async def exec_test():
+ value = await referential.diff_localized(units=False, international_system=False)
+ self.assertEqual(value, "0.101100")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_units_with_si(self, app, community):
+ community.dividend = CoroutineMock(return_value=10000)
+ community.get_block = CoroutineMock(return_value={'medianTime': 1452663088792})
+ type(community).short_currency = PropertyMock(return_value="TC")
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeToPast(1011, community, app, 100)
+ async def exec_test():
+ value = await referential.diff_localized(units=False, international_system=True)
+ self.assertEqual(value, "1.011000 dUD({0}) ".format(QLocale.toString(
+ QLocale(),
+ QDateTime.fromTime_t(1452663088792).date(),
+ QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
+ )))
+ self.lp.run_until_complete(exec_test())
diff --git a/src/sakia/tests/unit/core/money/test_relative_zsum.py b/src/sakia/tests/unit/core/money/test_relative_zsum.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6430c3b9c22bd44df4b3a8f7e3b334f3d330d77
--- /dev/null
+++ b/src/sakia/tests/unit/core/money/test_relative_zsum.py
@@ -0,0 +1,184 @@
+import unittest
+from asynctest.mock import Mock, CoroutineMock, patch, PropertyMock
+from PyQt5.QtCore import QLocale
+from sakia.tests import QuamashTest
+from sakia.core.money import RelativeZSum
+
+
+class TestRelativeZSum(unittest.TestCase, QuamashTest):
+ def setUp(self):
+ self.setUpQuamash()
+ QLocale.setDefault(QLocale("en_GB"))
+
+ def tearDown(self):
+ self.tearDownQuamash()
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_units(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ referential = RelativeZSum(0, community, app, None)
+ self.assertEqual(referential.units, "R0 TC")
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_units(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ referential = RelativeZSum(0, community, app, None)
+ self.assertEqual(referential.units, "R0 TC")
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_value(self, app, community):
+ referential = RelativeZSum(110, community, app, None)
+ community.dividend = CoroutineMock(return_value=100)
+ community.get_ud_block = CoroutineMock(side_effect=lambda *args, **kwargs: \
+ {'membersCount': 5, "monetaryMass": 500, "dividend": 100} if 'x' in kwargs \
+ else {'membersCount': 5, "monetaryMass": 1050, "dividend": 100} )
+ async def exec_test():
+ value = await referential.value()
+ self.assertAlmostEqual(value, 0.10)
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_differential(self, app, community):
+ community.dividend = CoroutineMock(return_value=100)
+ community.get_ud_block = CoroutineMock(side_effect=lambda *args, **kwargs: \
+ {'membersCount': 5, "monetaryMass": 500, "dividend": 100} if 'x' in kwargs \
+ else {'membersCount': 5, "monetaryMass": 1050, "dividend": 100} )
+ referential = RelativeZSum(110, community, app, None)
+ async def exec_test():
+ value = await referential.value()
+ self.assertAlmostEqual(value, 0.10)
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.dividend = CoroutineMock(return_value=100)
+ community.get_ud_block = CoroutineMock(side_effect=lambda *args, **kwargs: \
+ {'membersCount': 5, "monetaryMass": 500, "dividend": 100} if 'x' in kwargs \
+ else {'membersCount': 5, "monetaryMass": 1050, "dividend": 100} )
+ referential = RelativeZSum(110, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=True)
+ self.assertEqual(value, "0.1 R0 TC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_with_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.dividend = CoroutineMock(return_value=100)
+ community.get_ud_block = CoroutineMock(side_effect=lambda *args, **kwargs: \
+ {'membersCount': 5, "monetaryMass": 500, "dividend": 100} if 'x' in kwargs \
+ else {'membersCount': 5, "monetaryMass": 1050, "dividend": 100} )
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeZSum(110, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=True, international_system=True)
+ self.assertEqual(value, "1.000000 dR0 TC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_units_no_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.dividend = CoroutineMock(return_value=100)
+ community.get_ud_block = CoroutineMock(side_effect=lambda *args, **kwargs: \
+ {'membersCount': 5, "monetaryMass": 500, "dividend": 100} if 'x' in kwargs \
+ else {'membersCount': 5, "monetaryMass": 1050, "dividend": 100} )
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeZSum(110, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=False, international_system=False)
+ self.assertEqual(value, "0.100000")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_localized_no_units_with_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.dividend = CoroutineMock(return_value=100)
+ community.get_ud_block = CoroutineMock(side_effect=lambda *args, **kwargs: \
+ {'membersCount': 5, "monetaryMass": 500, "dividend": 100} if 'x' in kwargs \
+ else {'membersCount': 5, "monetaryMass": 1050, "dividend": 100} )
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeZSum(110, community, app, None)
+ async def exec_test():
+ value = await referential.localized(units=False, international_system=True)
+ self.assertEqual(value, "1.000000 dR0 ")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.dividend = CoroutineMock(return_value=100)
+ community.get_ud_block = CoroutineMock(side_effect=lambda *args, **kwargs: \
+ {'membersCount': 5, "monetaryMass": 500, "dividend": 100} if 'x' in kwargs \
+ else {'membersCount': 5, "monetaryMass": 1050, "dividend": 100} )
+ referential = RelativeZSum(90, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=True)
+ self.assertEqual(value, "0.9 R0 TC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_with_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.dividend = CoroutineMock(return_value=100)
+ community.get_ud_block = CoroutineMock(side_effect=lambda *args, **kwargs: \
+ {'membersCount': 5, "monetaryMass": 500, "dividend": 100} if 'x' in kwargs \
+ else {'membersCount': 5, "monetaryMass": 1050, "dividend": 100} )
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeZSum(90, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=True, international_system=True)
+ self.assertEqual(value, "9.000000 dR0 TC")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_units_no_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.dividend = CoroutineMock(return_value=100)
+ community.get_ud_block = CoroutineMock(side_effect=lambda *args, **kwargs: \
+ {'membersCount': 5, "monetaryMass": 500, "dividend": 100} if 'x' in kwargs \
+ else {'membersCount': 5, "monetaryMass": 1050, "dividend": 100} )
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeZSum(90, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=False, international_system=False)
+ self.assertEqual(value, "0.900000")
+ self.lp.run_until_complete(exec_test())
+
+ @patch('sakia.core.Community')
+ @patch('sakia.core.Application')
+ def test_diff_localized_no_units_with_si(self, app, community):
+ type(community).short_currency = PropertyMock(return_value="TC")
+ community.dividend = CoroutineMock(return_value=100)
+ community.get_ud_block = CoroutineMock(side_effect=lambda *args, **kwargs: \
+ {'membersCount': 5, "monetaryMass": 500, "dividend": 100} if 'x' in kwargs \
+ else {'membersCount': 5, "monetaryMass": 1050, "dividend": 100} )
+ app.preferences = {
+ 'digits_after_comma': 6
+ }
+ referential = RelativeZSum(90, community, app, None)
+ async def exec_test():
+ value = await referential.diff_localized(units=False, international_system=True)
+ self.assertEqual(value, "9.000000 dR0 ")
+ self.lp.run_until_complete(exec_test())