def test_multiplication_works_seconds(self):
t_add = Timedelta(seconds=10) * Timedelta(seconds=3)
t_done = Timedelta(seconds=30)
org = timedelta(seconds=30)
self.assertEqual(t_add, t_done)
self.assertEqual(t_add._timedelta, org)
def test_addition_works_days_and_seconds(self):
t_add = Timedelta(days=10, seconds=10) + Timedelta(days=1, seconds=1)
t_done = Timedelta(days=11, seconds=11)
org = timedelta(days=11, seconds=11)
self.assertEqual(t_add, t_done)
self.assertEqual(t_add._timedelta, org)
def test_subtraction_works_days_and_seconds(self):
t_add = Timedelta(days=10, seconds=10) - Timedelta(days=1, seconds=1)
t_done = Timedelta(days=9, seconds=9)
org = timedelta(days=9, seconds=9)
self.assertEqual(t_add, t_done)
self.assertEqual(t_add._timedelta, org)
def test_multiplication_works_days_and_seconds(self):
SECONDS_IN_A_DAY = 86400
t_add = Timedelta(days=10, seconds=10) * Timedelta(days=3, seconds=3)
t_done = Timedelta(seconds=(30 + (30 * SECONDS_IN_A_DAY)))
org = timedelta(seconds=(30 + (30 * SECONDS_IN_A_DAY)))
self.assertEqual(t_add, t_done)
self.assertEqual(t_add._timedelta, org)
def test_get_weeks_works(self):
weeks = 2
days = 1
hours = 4
minutes = 12
seconds = 10
t = Timedelta(weeks, days, hours, minutes, seconds)
self.assertEqual(t.weeks, 2)
def test_get_days_works(self):
weeks = 0
days = 8
hours = 4
minutes = 12
seconds = 10
t = Timedelta(weeks, days, hours, minutes, seconds)
self.assertEqual(t.days, 8)
def test_get_minutes_works(self):
weeks = 0
days = 0
hours = 0
minutes = 12
seconds = 10
t = Timedelta(weeks, days, hours, minutes, seconds)
self.assertEqual(t.minutes, 12)
def as_object(d):
if '__time__' in d:
return Datetime(*d['__time__'])
elif '__delta__' in d:
return Timedelta(days=d['__delta__'][0], seconds=d['__delta__'][1])
elif '__bytes__' in d:
return bytes.fromhex(d['__bytes__'])
elif '__fixed__' in d:
return ContractingDecimal(d['__fixed__'])
return dict(d)
def test_larger_components_returns_as_expected(self):
weeks = 2
days = 1
hours = 4
minutes = 12
seconds = 10
t = Timedelta(weeks, days, hours, minutes, seconds)
self.assertEqual(t.days, 15)
self.assertEqual(t.hours, 364)
def convert(k, v):
if k == '__fixed__':
return ContractingDecimal(v)
elif k == '__delta__':
return Timedelta(days=v[0], seconds=v[1])
elif k == '__bytes__':
return bytes.fromhex(v)
elif k == '__time__':
return Datetime(*v)
elif k == '__big_int__':
return int(v)
return v
def test_multiple_conversions(self):
d = {
'kwargs': {
'__fixed__': '0.1234'
},
'kwargs2': {
"__time__": [2021, 4, 29, 21, 30, 54, 0]
},
'kwargs3': {
"__delta__": [8, 0]
},
'kwargs4': {
"__bytes__": "123456"
}
}
expected = {
'kwargs': ContractingDecimal('0.1234'),
'kwargs2': Datetime(2021, 4, 29, 21, 30, 54, 0),
'kwargs3': Timedelta(days=8, seconds=0),
'kwargs4': b'\x124V',
}
self.assertEqual(expected, convert_dict(d))
def test_safe_repr_decimal_object_different_not_equal(self):
a = Timedelta(weeks=1, days=1)
b = Timedelta(weeks=2, days=1)
self.assertNotEqual(safe_repr(a), safe_repr(b))
def test_convert_contracting_timedelta(self):
d = {'kwargs': {"__delta__": [8, 0]}}
expected = {'kwargs': Timedelta(days=8, seconds=0)}
self.assertEqual(expected, convert_dict(d))
def test_datetime_subtraction_to_proper_timedelta(self):
d = Datetime(2019, 1, 1)
e = Datetime(2018, 1, 1)
self.assertEqual((d - e), Timedelta(days=365))
def test_safe_repr_decimal_object(self):
a = Timedelta(weeks=1, days=1)
b = Timedelta(weeks=1, days=1)
self.assertEqual(safe_repr(a), safe_repr(b))
from unittest import TestCase
from contracting.db.driver import Driver, InMemDriver, FSDriver, LMDBDriver
from contracting.db.encoder import MONGO_MAX_INT
from contracting.stdlib.bridge.time import Datetime, Timedelta
from contracting.stdlib.bridge.decimal import ContractingDecimal
from decimal import Decimal
import random
SAMPLE_STRING = 'beef'
SAMPLE_INT = 123
SAMPLE_BIGINT = MONGO_MAX_INT
SAMPLE_DATETIME = Datetime(year=2022, month=1, day=1)
SAMPLE_CONTRACTING_DECIMAL = ContractingDecimal(123.123)
SAMPLE_TIMEDELTA = Timedelta(weeks=1, days=1, hours=1)
SAMPLE_BYTES = bytes(b'0xbeef')
SAMPLE_DICT = {
'a': SAMPLE_INT,
'b': False,
'c': SAMPLE_BIGINT,
'd': SAMPLE_DATETIME,
'e': SAMPLE_CONTRACTING_DECIMAL,
'f': SAMPLE_TIMEDELTA,
'g': SAMPLE_BYTES,
'h': SAMPLE_STRING,
'x': None
}
TEST_DATA = [
SAMPLE_STRING, SAMPLE_INT, SAMPLE_BIGINT, SAMPLE_DATETIME,
SAMPLE_CONTRACTING_DECIMAL, SAMPLE_TIMEDELTA, SAMPLE_BYTES, SAMPLE_DICT
]
def test_subtracting_timedelta_to_datetime_returns_correct(self):
t = Timedelta(days=1)
d = Datetime(2020, 10, 1)
d2 = t - d
self.assertEqual(d2, Datetime(2020, 9, 30))
def test_le_true_eq(self):
t = Timedelta(days=10)
_t = Timedelta(days=10)
self.assertTrue(t <= _t)
def test_ne_true(self):
t = Timedelta(days=10)
_t = Timedelta(days=1)
self.assertTrue(t != _t)
def test_eq_true(self):
t = Timedelta(days=1)
_t = Timedelta(days=1)
self.assertTrue(t == _t)
def test_le_false(self):
t = Timedelta(days=10)
_t = Timedelta(days=1)
self.assertFalse(t <= _t)
def test_lt_true(self):
t = Timedelta(days=10)
_t = Timedelta(days=1)
self.assertFalse(t < _t)
def test_ge_false(self):
t = Timedelta(days=1)
_t = Timedelta(days=10)
self.assertFalse(t >= _t)
def test_gt_true(self):
t = Timedelta(days=10)
_t = Timedelta(days=1)
self.assertTrue(t > _t)
def test_timedelta_encode(self):
t = Timedelta(weeks=1, days=1)
_t = encode(t)
self.assertEqual('{"__delta__":[8,0]}', _t)
def test_ne_false(self):
t = Timedelta(days=10)
_t = Timedelta(days=10)
self.assertFalse(t != _t)
def test_timedelta_decode(self):
_t = '{"__delta__": [8, 0]}'
t = decode(_t)
self.assertEqual(t, Timedelta(weeks=1, days=1))
def test_timedelta_set_to_one_week_after_submission(self):
day = Timedelta(days=1)
week = Timedelta(weeks=1)
self.assertEqual(self.simple_vote.election_interval.get(), week)
self.assertEqual(self.simple_vote.voting_period.get(), day)
def test_implementation_mimics_actual_timedelta(self):
t = Timedelta(days=10, minutes=10, seconds=10)
_t = timedelta(days=10, minutes=10, seconds=10)
self.assertEqual(t._timedelta, _t)
def test_adding_timedelta_to_datetime_returns_correct(self):
t = Timedelta(days=1)
d = Datetime(2020, 10, 1)
d2 = t + d
self.assertEqual(d2, Datetime(2020, 10, 2))