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_length(self):
self.assertCallEquals(operator.attrgetter("length"), [
([open(0, 0)], 0),
([closed(0, 0)], 0),
([open(0, 1)], 1),
([closed(0, 1)], 1),
([closed(0, None)], None),
([closed(None, 0)], None),
([closed(None, None)], 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_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_sort_join(self):
self.assertEqual(
IntervalSet([
closed(2, 3),
closed(2, None),
closed(None, 1),
closed(1, 3),
closed(2, 3),
closed(-10, None)
]), IntervalSet([closed(None, None)]))
self.assertEqual(
IntervalSet([
empty(6),
closedopen(1, 2),
empty(0),
closedopen(2, 3),
open(4, 5)
]),
IntervalSet([closedopen(1, 3), open(4, 5)]),
)
def test_union(self):
self.assertIntervalSetOperationEquals(IntervalSet.union, [
([[], [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 assert_successful_move_out_execution(self, task: Task):
assert task.status == TaskStatus.EXECUTED
assert self.user.room is None
relevant_interval = open(datetime.now(timezone.utc) + timedelta(minutes=1), None)
assert self.user.active_memberships(when=relevant_interval) == []
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):
def test_select_as_text(session):
stmt = select(cast(literal(open(None, None), TsTzRange), TEXT))
assert session.scalar(stmt) == '(,)'
class TableWithInterval(IntegerIdModel):
value = Column(TsTzRange,
server_default=literal(open(None, None), TsTzRange))
class TableWithInterval(IntegerIdModel):
value = Column(TsTzRange,
server_default=literal(open(None, None), TsTzRange))
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', [
@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())
@pytest.mark.parametrize('one, other', [
([
closed(2, 3),
closed(2, None),
closed(None, 1),
closed(1, 3),
closed(2, 3),
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)
