def test_intersect(self):
self.assertIntervalSetOperationEquals(IntervalSet.intersect, [
([[open(None, None)],
[openclosed(None, 0),
closed(1, 2),
closedopen(3, None)]
], [openclosed(None, 0),
closed(1, 2),
closedopen(3, None)]),
])
def test_contains_operator(self):
self.assertCallTrue(operator.contains, [
(closed(0, 0), 0),
(closed(0, 2), 1),
(openclosed(None, 0), 0),
(closedopen(0, None), 0),
(open(None, None), 0),
])
self.assertCallFalse(operator.contains, [
(empty(0), 0),
(closedopen(0, 1), 1),
(openclosed(0, 1), 0),
(open(0, 1), 1),
])
def test_difference(self):
self.assertIntervalSetOperationEquals(IntervalSet.difference, [
([[open(None, None)],
[closed(0, 1),
closedopen(2, 3),
openclosed(4, 5),
open(6, 7)]], [
open(None, 0),
open(1, 2),
closed(3, 4),
openclosed(5, 6),
closedopen(7, None)
]),
])
def test_empty(self):
self.assertCallTrue(operator.attrgetter("empty"), [
[empty(0)],
[closedopen(0, 0)],
[openclosed(0, 0)],
[open(0, 0)],
])
self.assertCallFalse(operator.attrgetter("empty"), [
[single(0)],
[closed(0, 0)],
[closed(0, 1)],
[closedopen(0, 1)],
[openclosed(0, 1)],
[open(0, 1)],
])
def test_intersect(self):
self.assertCallEquals(Interval.intersect, [
((closed(0, 0), closed(0, 0)), closed(0, 0)),
((closed(0, 0), open(0, 0)), None),
((closed(1, 1), closed(0, 2)), closed(1, 1)),
((closed(0, 2), closed(1, 3)), closed(1, 2)),
((closed(0, 3), closed(1, 2)), closed(1, 2)),
((closed(1, 2), closed(0, 3)), closed(1, 2)),
((open(1, 2), closed(0, 3)), open(1, 2)),
((closedopen(1, 2), closed(0, 3)), closedopen(1, 2)),
((openclosed(1, 2), closed(0, 3)), openclosed(1, 2)),
((closed(0, 1), closed(2, 3)), None),
((closed(None, 2), closed(1, None)), closed(1, 2)),
((closed(1, 2), closed(None, None)), closed(1, 2)),
((closed(None, None), closed(None, None)), closed(None, None)),
])
def test_serialize_interval(self):
self.assertValidSerialization(UnboundedInterval)
now = datetime.datetime.utcnow()
then = now + datetime.timedelta(1)
self.assertValidSerialization(closed(now, then))
self.assertValidSerialization(closedopen(now, then))
self.assertValidSerialization(openclosed(now, then))
self.assertValidSerialization(open(now, then))
def test_serialize_interval(self):
self.assertValidSerialization(UnboundedInterval)
now = datetime.datetime.utcnow()
then = now + datetime.timedelta(1)
self.assertValidSerialization(closed(now, then))
self.assertValidSerialization(closedopen(now, then))
self.assertValidSerialization(openclosed(now, then))
self.assertValidSerialization(open(now, then))
def test_complement(self):
self.assertIntervalSetOperationEquals(IntervalSet.complement, [
([[]], open(None, None)),
([[closed(0, 1), open(2, 3)]
], [open(None, 0),
openclosed(1, 2),
closedopen(3, None)]),
([[closed(None, 0), closed(1, None)]], ([open(0, 1)])),
])
def test_overlaps(self):
self.assertCallTrue(Interval.overlaps, [
(closed(0, 0), closed(0, 0)),
(closed(0, 1), closed(1, 2)),
(closed(0, 2), closed(1, 3)),
(closed(None, 1), closed(0, None)),
(closed(0, None), closed(None, 1)),
(closed(0, 1), closed(None, None)),
(closed(None, None), closed(0, 1)),
])
self.assertCallFalse(Interval.overlaps, [
(closedopen(0, 1), openclosed(1, 2)),
(closedopen(0, 1), closed(1, 2)),
(closed(0, 1), openclosed(1, 2)),
(closed(0, 0), closed(1, 1)),
(closed(0, 1), closed(2, 3)),
(closed(None, 0), closed(1, None)),
(closed(1, None), closed(None, 0)),
])
def test_starts(self):
self.assertCallTrue(Interval.starts, [
(closed(0, 0), closed(0, 0)),
(closed(0, 1), closed(0, 2)),
(closed(None, 0), closed(None, 2)),
])
self.assertCallFalse(Interval.starts, [
(closed(0, 1), openclosed(0, 1)),
(closed(0, 0), closed(1, 1)),
(closed(0, 1), closed(2, 3)),
(closed(None, 0), closed(1, None)),
(closed(0, 1), closed(None, 2)),
(closed(0, None), closed(None, 1)),
])
def test_0030_transferred_value(self):
amount = Decimal(90)
today = session.utcnow().date()
simple_transaction("transaction", self.fee_account, self.user_account,
amount, self.author, today - timedelta(1))
simple_transaction("transaction", self.fee_account, self.user_account,
amount, self.author, today)
simple_transaction("transaction", self.fee_account, self.user_account,
amount, self.author, today + timedelta(1))
assert (transferred_amount(self.fee_account, self.user_account,
single(today)) == amount)
assert (transferred_amount(self.fee_account, self.user_account,
closedopen(today, None)) == 2 * amount)
assert (transferred_amount(self.fee_account, self.user_account,
openclosed(None, today)) == 2 * amount)
assert (transferred_amount(self.fee_account,
self.user_account) == 3 * amount)
Transaction.q.delete()
session.session.commit()
def test_0030_transferred_value(self):
amount = Decimal(90)
today = session.utcnow().date()
simple_transaction(
u"transaction", self.fee_account, self.user_account,
amount, self.author, today - timedelta(1)
)
simple_transaction(
u"transaction", self.fee_account, self.user_account,
amount, self.author, today
)
simple_transaction(
u"transaction", self.fee_account, self.user_account,
amount, self.author, today + timedelta(1)
)
self.assertEqual(
transferred_amount(
self.fee_account, self.user_account, single(today)
),
amount
)
self.assertEqual(
transferred_amount(
self.fee_account, self.user_account, closedopen(today, None)
),
2*amount
)
self.assertEqual(
transferred_amount(
self.fee_account, self.user_account, openclosed(None, today)
),
2*amount
)
self.assertEqual(
transferred_amount(
self.fee_account, self.user_account
),
3*amount
)
Transaction.q.delete()
session.session.commit()
def test_type_mangling(self):
target = IntervalSet([closed(0, 1)])
# Creation
self.assertEqual(target, IntervalSet(closed(0, 1)))
self.assertEqual(target, IntervalSet([closed(0, 1)]))
self.assertRaises(TypeError, IntervalSet, 0)
# Union
base = IntervalSet(())
self.assertEqual(target, base | IntervalSet(closed(0, 1)))
self.assertEqual(target, base | closed(0, 1))
self.assertEqual(target, base | [closed(0, 1)])
# Intersection
base = target | closed(1, 2)
self.assertEqual(target, base & IntervalSet(openclosed(0, 1)))
self.assertEqual(target, base & openclosed(0, 1))
self.assertEqual(target, base & [openclosed(0, 1)])
# Difference
self.assertEqual(target, base - IntervalSet(openclosed(1, 2)))
self.assertEqual(target, base - openclosed(1, 2))
self.assertEqual(target, base - [openclosed(1, 2)])
def test_type_mangling(self):
# TODO one test per assertion and `target` / `base` as fixtures
target = IntervalSet([closed(0, 1)])
# Creation
assert target == IntervalSet(closed(0, 1))
assert target == IntervalSet([closed(0, 1)])
with pytest.raises(TypeError):
IntervalSet(0)
# Union
base = IntervalSet(())
assert target == base | IntervalSet(closed(0, 1))
assert target == base | closed(0, 1)
assert target == base | [closed(0, 1)]
# Intersection
base = target | closed(1, 2)
assert target == base & IntervalSet(openclosed(0, 1))
assert target == base & openclosed(0, 1)
assert target == base & [openclosed(0, 1)]
# Difference
assert target == base - IntervalSet(openclosed(1, 2))
assert target == base - openclosed(1, 2)
assert target == base - [openclosed(1, 2)]
import pytest
from pycroft.helpers.interval import closed, openclosed, closedopen, open, \
empty, Interval, single
@pytest.mark.parametrize('one, other', [
(closed(0, 0), 0),
(closed(0, 2), 1),
(openclosed(None, 0), 0),
(closedopen(0, None), 0),
(open(None, None), 0),
])
def test_contained(one, other):
assert other in one
assert not (other not in one)
@pytest.mark.parametrize('one, other', [
(empty(0), 0),
(closedopen(0, 1), 1),
(openclosed(0, 1), 0),
(open(0, 1), 1),
])
def test_not_contained(one, other):
assert other not in one
assert not (other in one)
def test_begin_greater_than_end():
with pytest.raises(ValueError):
NOW = datetime.utcnow().replace(tzinfo=pytz.utc)
def test_select_as_text(session):
stmt = select(cast(literal(open(None, None), TsTzRange), TEXT))
assert session.scalar(stmt) == '(,)'
@pytest.mark.parametrize('interval', [
open(NOW, NOW + timedelta(days=1)),
closed(NOW, NOW + timedelta(days=1)),
open(NOW, NOW + timedelta(days=1)),
open(None, None),
open(None, NOW),
openclosed(None, NOW),
closedopen(None, NOW),
])
def test_declarative_insert_and_select(session, interval):
mem = TableWithInterval(value=interval)
with session.begin_nested():
session.add(mem)
assert mem.value == interval
@pytest.mark.parametrize('interval', [
open(NOW, NOW + timedelta(days=1)),
])
def test_literal_select(session, interval):
stmt = select(cast(literal(interval, TsTzRange), TsTzRange))
assert session.scalar(stmt) == interval
@pytest.mark.parametrize('value', [
"test",
True,
42,
0.5,
Decimal('3.8e2'),
Money(Decimal(20.0), "EUR"),
datetime.datetime.utcnow(),
datetime.date.today(),
datetime.timedelta(1),
datetime.datetime.utcnow().time(),
UnboundedInterval,
closed(now, then),
closedopen(now, then),
openclosed(now, then),
open(now, then),
])
def test_valid_serialization(value):
s = serialize_param(value)
try:
json.dumps(s)
except (ValueError, TypeError):
pytest.fail(f"Param {value} cannot be serialized to JSON.")
assert deserialize_param(s) == value
def test_serialize_unknown_type():
with pytest.raises(TypeError):
serialize_param(object())
closed(-10, None)
], [closed(None, None)]),
([empty(6),
closedopen(1, 2),
empty(0),
closedopen(2, 3),
open(4, 5)], [closedopen(1, 3), open(4, 5)]),
])
def test_constructor(one: list[Interval], other: list[Interval]):
assert IntervalSet(one) == IntervalSet(other)
@pytest.mark.parametrize('intervals, expected', [
([], open(None, None)),
([closed(0, 1), open(2, 3)
], [open(None, 0), openclosed(1, 2),
closedopen(3, None)]),
([closed(None, 0), closed(1, None)], [open(0, 1)]),
])
def test_complement(intervals: list[Interval], expected: IntervalSet):
assert IntervalSet(intervals).complement() == IntervalSet(expected)
@pytest.mark.parametrize('one, other, expected', [
([], [closed(0, 1), open(1, 2)], [closed(0, 1), open(1, 2)]),
([closed(0, 1), open(1, 2)], [], [closed(0, 1), open(1, 2)]),
([closed(None, 1), closed(3, 4), open(7, 8)
], [open(0, 5), closed(6, 7),
closedopen(8, None)], [open(None, 5), closed(6, None)]),
])
def test_union(one: list[Interval], other: list[Interval],
