def overview():
uquery = lambda: session.session.query(User)
entries = [{"title": "Nutzer in Datenbank",
"href": None,
"number": uquery().count()},
{"title": "Mitglieder",
"href": None,
"number": uquery().join(Membership).filter(
Membership.group == config.member_group,
Membership.active())
.count()},
{"title": "Nicht bezahlt",
"href": None,
"number": uquery().join(User.account)
.join(Split)
.group_by(User.id)
.having(func.sum(Split.amount) > 0)
.count()},
{"title": "Nicht bezahlt (Mitglieder)",
"href": "#",
"number": uquery().join(Membership).filter(
Membership.group == config.member_group,
Membership.active())
.join(User.account)
.join(Split)
.group_by(User.id)
.having(func.sum(Split.amount) > 0)
.count()}]
return render_template("user/user_overview.html", entries=entries)
def make_member_of(user, group, processor, during=UnboundedInterval):
"""
Makes a user member of a group in a given interval. If the given interval
overlaps with an existing membership, this method will join the overlapping
intervals together, so that there will be at most one membership for
particular user in particular group at any given point in time.
:param User user: the user
:param Group group: the group
:param User processor: User issuing the addition
:param Interval during:
"""
memberships = session.session.query(Membership).filter(
Membership.user == user, Membership.group == group,
Membership.active(during)).all()
intervals = IntervalSet(
closed(m.begins_at, m.ends_at) for m in memberships).union(during)
for m in memberships:
session.session.delete(m)
session.session.add_all(
Membership(begins_at=i.begin, ends_at=i.end, user=user, group=group)
for i in intervals)
message = deferred_gettext(u"Added to group {group} during {during}.")
log_user_event(message=message.format(group=group.name,
during=during).to_json(),
user=user,
author=processor)
def remove_member_of(user, group, processor, during=UnboundedInterval):
"""Remove a user from a group in a given interval.
The interval defaults to the unbounded interval, so that the user
will be removed from the group at any point in time, **removing
all memberships** in this group retroactively.
However, a common use case is terminating a membership by setting
``during=closedopen(now, None)``.
:param User user: the user
:param Group group: the group
:param User processor: User issuing the removal
:param Interval during:
"""
memberships = session.session.query(Membership).filter(
Membership.user == user, Membership.group == group,
Membership.active(during)).all()
intervals = IntervalSet(
closed(m.begins_at, m.ends_at) for m in memberships).difference(during)
for m in memberships:
session.session.delete(m)
session.session.add_all(
Membership(begins_at=i.begin, ends_at=i.end, user=user, group=group)
for i in intervals)
message = deferred_gettext(u"Removed from group {group} during {during}.")
log_user_event(message=message.format(group=group.name,
during=during).to_json(),
user=user,
author=processor)
def test_active_disable(self, session, utcnow, user, property_group1):
mem = Membership(active_during=closedopen(utcnow - timedelta(hours=2), None),
user=user, group=property_group1)
with session.begin_nested():
session.add(mem)
assert utcnow in mem.active_during
# disable: [NOW - 2h,) → [NOW - 2h, NOW - 1h)
with session.begin_nested():
mem.disable(utcnow - timedelta(hours=1))
session.refresh(mem)
assert utcnow not in mem.active_during
def test_0040_set_correct_dates(self):
# add membership to group1
p1 = Membership(user=self.user, group=self.property_group1)
p1.begins_at = session.utcnow()
p1.ends_at = session.utcnow()
session.session.add(p1)
session.session.commit()
p1.begins_at = session.utcnow() - timedelta(days=3)
p1.ends_at = session.utcnow() + timedelta(days=3)
session.session.commit()
def test_end_date_before_start(self):
# add membership to group1
p1 = Membership(user=self.user, group=self.property_group1)
p1.begins_at = session.utcnow()
def set_old_date():
""" Set ends_at before begins_at
"""
p1.ends_at = session.utcnow() - timedelta(hours=2)
self.assertRaisesRegexp(AssertionError,
"begins_at must be before ends_at",
set_old_date)
def test_0020_end_date_before_start(self):
# add membership to group1
p1 = Membership(user=self.user, group=self.property_group1)
p1.begins_at = session.utcnow()
def set_old_date():
""" Set ends_at before begins_at
"""
p1.ends_at = session.utcnow() - timedelta(hours=2)
self.assertRaisesRegexp(
AssertionError,
"begins_at must be before ends_at",
set_old_date
)
def _add_membership(group):
with session.begin_nested():
m = Membership(user=user,
group=group,
active_during=closedopen(utcnow, None))
session.add(m)
return m
def make_member_of(user, group, processor, during=UnboundedInterval):
"""
Makes a user member of a group in a given interval. If the given interval
overlaps with an existing membership, this method will join the overlapping
intervals together, so that there will be at most one membership for
particular user in particular group at any given point in time.
:param User user: the user
:param Group group: the group
:param User processor: User issuing the addition
:param Interval during:
"""
if group.permission_level > processor.permission_level:
raise PermissionError("cannot create a membership for a group with a"
" higher permission level")
memberships: list[Membership] = [
m for m in user.active_memberships(when=during) if m.group == group
]
intervals = IntervalSet(m.active_during.closure
for m in memberships).union(during)
for m in memberships:
session.session.delete(m)
session.session.flush()
session.session.add_all(
Membership(active_during=i, user=user, group=group) for i in intervals)
message = deferred_gettext("Added to group {group} during {during}.")
log_user_event(message=message.format(group=group.name,
during=during).to_json(),
user=user,
author=processor)
def remove_member_of(user, group, processor, during=UnboundedInterval):
"""Remove a user from a group in a given interval.
The interval defaults to the unbounded interval, so that the user
will be removed from the group at any point in time, **removing
all memberships** in this group retroactively.
However, a common use case is terminating a membership by setting
``during=closedopen(now, None)``.
:param User user: the user
:param Group group: the group
:param User processor: User issuing the removal
:param Interval during:
"""
memberships = session.session.query(Membership).filter(
Membership.user == user, Membership.group == group,
Membership.active(during)).all()
intervals = IntervalSet(
closed(m.begins_at, m.ends_at) for m in memberships
).difference(during)
for m in memberships:
session.session.delete(m)
session.session.add_all(
Membership(begins_at=i.begin, ends_at=i.end, user=user, group=group)
for i in intervals)
message = deferred_gettext(u"Removed from group {group} during {during}.")
log_user_event(message=message.format(group=group.name,
during=during).to_json(),
user=user, author=processor)
def make_member_of(user, group, processor, during=UnboundedInterval):
"""
Makes a user member of a group in a given interval. If the given interval
overlaps with an existing membership, this method will join the overlapping
intervals together, so that there will be at most one membership for
particular user in particular group at any given point in time.
:param User user: the user
:param Group group: the group
:param User processor: User issuing the addition
:param Interval during:
"""
memberships = session.session.query(Membership).filter(
Membership.user == user, Membership.group == group,
Membership.active(during)).all()
intervals = IntervalSet(
closed(m.begins_at, m.ends_at) for m in memberships
).union(during)
for m in memberships:
session.session.delete(m)
session.session.add_all(
Membership(begins_at=i.begin, ends_at=i.end, user=user, group=group)
for i in intervals)
message = deferred_gettext(u"Added to group {group} during {during}.")
log_user_event(message=message.format(group=group.name,
during=during).to_json(),
user=user, author=processor)
def test_0040_disable_membership(self):
# add membership to group1
membership = Membership(
begins_at=session.utcnow() - timedelta(hours=2),
user=self.user,
group=self.property_group1
)
session.session.add(membership)
session.session.commit()
self.assertTrue(self.user.has_property(PropertyData.prop_test1.name))
membership.disable(session.utcnow() - timedelta(hours=1))
session.session.commit()
self.assertNotIn(
self.property_group1,
self.user.active_property_groups()
)
self.assertFalse(self.user.has_property(PropertyData.prop_test1.name))
# add membership to group1
membership = Membership(
begins_at=session.utcnow(),
user=self.user,
group=self.property_group1
)
session.session.add(membership)
session.session.commit()
self.assertTrue(self.user.has_property(PropertyData.prop_test1.name))
# add membership to group2
membership = Membership(
begins_at=session.utcnow() - timedelta(hours=2),
user=self.user,
group=self.property_group2
)
session.session.add(membership)
session.session.commit()
self.assertTrue(self.user.has_property(PropertyData.prop_test1.name))
self.assertTrue(self.user.has_property(PropertyData.prop_test2.name))
# disables membership in group2
membership.disable(session.utcnow() - timedelta(hours=1))
session.session.commit()
self.assertTrue(self.user.has_property(PropertyData.prop_test1.name))
self.assertFalse(self.user.has_property(PropertyData.prop_test2.name))
def test_0010_group_users(self):
self.assertEqual(len(self.property_group1.users), 0)
self.assertEqual(len(self.property_group1.active_users()), 0)
# add membership to group1
p1 = Membership(begins_at=session.utcnow() - timedelta(hours=2),
user=self.user, group=self.property_group1)
session.session.add(p1)
session.session.commit()
self.assertEqual(len(self.property_group1.users), 1)
self.assertEqual(len(self.property_group1.active_users()), 1)
p1.disable(session.utcnow() - timedelta(hours=1))
session.session.commit()
self.assertEqual(len(self.property_group1.users), 1)
self.assertEqual(len(self.property_group1.active_users()), 0)
def overview():
uquery = lambda: session.session.query(User)
entries = [{
"title": "Nutzer in Datenbank",
"href": None,
"number": uquery().count()
}, {
"title":
"Mitglieder",
"href":
None,
"number":
uquery().join(Membership).filter(
Membership.group == config.member_group,
Membership.active()).count()
}, {
"title":
"Nicht bezahlt",
"href":
None,
"number":
uquery().join(User.account).join(Split).group_by(
User.id).having(func.sum(Split.amount) > 0).count()
}, {
"title":
"Nicht bezahlt (Mitglieder)",
"href":
"#",
"number":
uquery().join(Membership).filter(
Membership.group == config.member_group,
Membership.active()).join(User.account).join(Split).group_by(
User.id).having(func.sum(Split.amount) > 0).count()
}]
return render_template(
"user/user_overview.html",
entries=entries,
traffic_top_table=TrafficTopTable(
data_url=url_for("user.json_users_highest_traffic"),
table_args={
'data-page-size': 10,
'data-search': 'false'
},
))
def test_group_users(self, session, utcnow, user, property_group1, property_group2):
assert len(property_group1.users) == 0
assert len(property_group1.active_users()) == 0
# add membership to group1
p1 = Membership(active_during=closedopen(utcnow - timedelta(hours=2), None),
user=user, group=property_group1)
with session.begin_nested():
session.add(p1)
session.refresh(property_group1)
assert len(property_group1.users) == 1
assert len(property_group1.active_users()) == 1
with session.begin_nested():
p1.disable(utcnow - timedelta(hours=1))
session.refresh(property_group1)
assert len(property_group1.users) == 1
assert len(property_group1.active_users()) == 0
def test_start_date_default(self):
# add membership to group1
p1 = Membership(user=self.user, group=self.property_group1)
session.session.add(p1)
session.session.commit()
p = Membership.q.first()
self.assertIsNotNone(p)
self.assertIsNotNone(p.begins_at)
self.assertIsNone(p.ends_at)
def test_active_instance_property(
self,
rel_begin, rel_end, active_expected,
session, utcnow, user, property_group1
):
interval = closedopen(utcnow + rel_begin, rel_end and utcnow + rel_end)
mem = Membership(active_during=interval, user=user, group=property_group1)
with session.begin_nested():
session.add(mem)
session.refresh(mem)
assert (utcnow in mem.active_during) == active_expected
def test_add_membership(self):
# add membership to group1
membership = Membership(begins_at=session.utcnow(),
user=self.user,
group=self.property_group1)
session.session.add(membership)
session.session.commit()
self.assertTrue(self.user.has_property(self.prop1))
self.assertFalse(self.user.has_property(self.prop2))
# add membership to group2
membership = Membership(begins_at=session.utcnow(),
user=self.user,
group=self.property_group2)
session.session.add(membership)
session.session.commit()
self.assertTrue(self.user.has_property(self.prop1))
self.assertTrue(self.user.has_property(self.prop2))
def test_clear_end_date(self):
# add membership to group1
p1 = Membership(user=self.user, group=self.property_group1)
p1.begins_at = session.utcnow()
p1.ends_at = session.utcnow()
session.session.add(p1)
session.session.commit()
# test if membership in database
p1 = Membership.q.filter_by(user=self.user,
group=self.property_group1).one()
self.assertIsNotNone(p1.ends_at)
# clear ends_at
p1.ends_at = None
session.session.commit()
p1 = Membership.q.filter_by(user=self.user,
group=self.property_group1).one()
self.assertIsNone(p1.ends_at)
def test_disable_membership(self, session, utcnow, user, property_group1, property_group2):
# add membership to group1
membership = Membership(
active_during=closedopen(utcnow - timedelta(hours=2), None),
user=user,
group=property_group1
)
with session.begin_nested():
session.add(membership)
session.refresh(user)
assert user.has_property(PROP1)
with session.begin_nested():
membership.disable(utcnow - timedelta(hours=1))
session.refresh(user)
assert property_group1 not in user.active_property_groups()
assert not user.has_property(PROP1)
with session.begin_nested():
# add membership to group1
session.add(Membership(
active_during=closedopen(utcnow, None),
user=user,
group=property_group1
))
session.refresh(user)
assert user.has_property(PROP1)
# add membership to group2
membership = Membership(
active_during=closedopen(utcnow - timedelta(hours=2), None),
user=user,
group=property_group2
)
with session.begin_nested():
session.add(membership)
session.refresh(user)
assert user.has_property(PROP1)
assert user.has_property(PROP2)
# disables membership in group2
with session.begin_nested():
membership.disable(utcnow - timedelta(hours=1))
session.refresh(user)
assert user.has_property(PROP1)
assert not user.has_property(PROP2)
def test_add_timed_membership(self, session, utcnow, user, property_group1, property_group2):
with session.begin_nested():
session.add(Membership(
active_during=closedopen(utcnow, utcnow + timedelta(days=3)),
user=user,
group=property_group1
))
session.refresh(user)
assert user.has_property(PROP1)
assert not user.has_property(PROP2)
with session.begin_nested():
# add expired membership to group2
session.add(Membership(
active_during=closedopen(utcnow - timedelta(hours=2), utcnow - timedelta(hours=1)),
user=user,
group=property_group2
))
session.refresh(user)
assert user.has_property(PROP1)
assert not user.has_property(PROP2)
def test_0030_add_timed_membership(self):
# add membership to group1
now = session.utcnow()
membership = Membership(
begins_at=now,
user=self.user,
group=self.property_group1
)
membership.ends_at = membership.begins_at + timedelta(days=3)
session.session.add(membership)
session.session.commit()
self.assertTrue(self.user.has_property(PropertyData.prop_test1.name))
self.assertFalse(self.user.has_property(PropertyData.prop_test2.name))
# add expired membership to group2
membership = Membership(
begins_at=now - timedelta(hours=2),
user=self.user,
group=self.property_group2
)
membership.ends_at = now - timedelta(hours=1)
session.session.add(membership)
session.session.commit()
self.assertTrue(self.user.has_property(PropertyData.prop_test1.name))
self.assertFalse(self.user.has_property(PropertyData.prop_test2.name))
def test_user_property_groups(self, session, utcnow, user, property_group1, property_group2):
# first have no property group
assert len(user.property_groups) == 0
assert len(user.active_property_groups()) == 0
# add one active property group
p1 = Membership(active_during=closedopen(utcnow - timedelta(hours=2), None),
user=user, group=property_group1)
with session.begin_nested():
session.add(p1)
session.refresh(user)
f = Membership.q.first()
assert utcnow in f.active_during
assert len(user.property_groups) == 1
assert len(user.active_property_groups()) == 1
# add a second active property group - count should be 2
p1 = Membership(active_during=closedopen(utcnow - timedelta(hours=2), None),
user=user, group=property_group2)
with session.begin_nested():
session.add(p1)
session.refresh(user)
assert len(user.property_groups) == 2
assert len(user.active_property_groups()) == 2
# disable the second group. active should be one, all 2
with session.begin_nested():
p1.disable(utcnow - timedelta(hours=1))
session.refresh(user)
assert len(user.property_groups) == 2
assert len(user.active_property_groups()) == 1
# test a join
res = session.query(
User, PropertyGroup.id
).join(User.property_groups).filter(
User.id == user.id
).distinct().count()
assert res == 2
# reenable it - but with a deadline - both counts should be 2
with session.begin_nested():
p1.active_during = closedopen(p1.active_during.begin,
utcnow + timedelta(days=1))
session.refresh(user)
assert len(user.property_groups) == 2
assert len(user.active_property_groups()) == 2
# test a join
res = session.query(
User, PropertyGroup
).join(User.property_groups).filter(
User.id == user.id
).distinct().count()
assert res == 2
def test_0050_clear_end_date(self):
# add membership to group1
p1 = Membership(user=self.user, group=self.property_group1)
p1.begins_at = session.utcnow()
p1.ends_at = session.utcnow()
session.session.add(p1)
session.session.commit()
# test if membership in database
p1 = Membership.q.filter_by(
user=self.user, group=self.property_group1
).one()
self.assertIsNotNone(p1.ends_at)
# clear ends_at
p1.ends_at = None
session.session.commit()
p1 = Membership.q.filter_by(
user=self.user, group=self.property_group1
).one()
self.assertIsNone(p1.ends_at)
def test_add_membership(self, session, utcnow, user, property_group1, property_group2):
# add membership to group1
with session.begin_nested():
session.add(Membership(
active_during=closedopen(utcnow, None),
user=user,
group=property_group1
))
session.refresh(user)
assert user.has_property(PROP1)
assert not user.has_property(PROP2)
# add membership to group2
with session.begin_nested():
session.add(Membership(
active_during=closedopen(utcnow, None),
user=user,
group=property_group2
))
session.refresh(user)
assert user.has_property(PROP1)
assert user.has_property(PROP2)
def fetch_groups_to_sync(session) -> List[GroupProxyType]:
"""Fetch the groups who should be synced
:param session: The SQLAlchemy session to use
:returns: An iterable of `(Group, members)` ResultProxies.
"""
return (
Group.q
# uids of the members of the group
.add_column(func.coalesce(select([func.array_agg(User.login)])
.select_from(join(Membership, User))
.where(Membership.group_id == Group.id).where(Membership.active())
.group_by(Group.id)
.as_scalar(),
func.cast('{}', dialects.postgresql.ARRAY(User.login.type))).label('members'))
.all()
)
def test_set_correct_dates(self):
# add membership to group1
p1 = Membership(user=self.user, group=self.property_group1)
p1.begins_at = session.utcnow()
p1.ends_at = session.utcnow()
session.session.add(p1)
session.session.commit()
p1.begins_at = session.utcnow() - timedelta(days=3)
p1.ends_at = session.utcnow() + timedelta(days=3)
session.session.commit()
def remove_member_of(user, group, processor, during=UnboundedInterval):
"""Remove a user from a group in a given interval.
The interval defaults to the unbounded interval, so that the user
will be removed from the group at any point in time, **removing
all memberships** in this group retroactively.
However, a common use case is terminating a membership by setting
``during=closedopen(now, None)``.
:param User user: the user
:param Group group: the group
:param User processor: User issuing the removal
:param Interval during:
"""
if group.permission_level > processor.permission_level:
raise PermissionError("cannot delete a membership for a group with a"
" higher permission level")
memberships: list[Membership] = [
m for m in user.active_memberships(when=during) if m.group == group
]
intervals = IntervalSet(m.active_during.closure
for m in memberships).difference(during)
for m in memberships:
session.session.delete(m)
# flush necessary because we otherwise don't have any control
# over the order of deletion vs. addition
session.session.flush()
session.session.add_all(
Membership(active_during=i, user=user, group=group) for i in intervals)
message = deferred_gettext("Removed from group {group} during {during}.")
log_user_event(message=message.format(group=group.name,
during=during).to_json(),
user=user,
author=processor)
def membership(self, class_session, user, utcnow, property_group1):
return Membership(
user=user,
group=property_group1,
active_during=closedopen(utcnow, None),
)
def add_membership(self):
session.session.add(
Membership(user=self.user, group=self.property_group1))
session.session.commit()
def test_active_instance_property(self):
p1 = Membership(begins_at=session.utcnow() - timedelta(hours=2),
user=self.user,
group=self.property_group1)
self.assertTrue(p1.active())
session.session.add(p1)
session.session.commit()
p1 = Membership.q.filter_by(user=self.user,
group=self.property_group1).one()
self.assertTrue(p1.active())
p1.disable(session.utcnow() - timedelta(hours=1))
session.session.commit()
p1 = Membership.q.filter_by(user=self.user,
group=self.property_group1).one()
self.assertFalse(p1.active())
p1.ends_at = None
session.session.commit()
p1 = Membership.q.filter_by(user=self.user,
group=self.property_group1).one()
self.assertTrue(p1.active())
session.session.delete(p1)
session.session.commit()
p1 = Membership(begins_at=session.utcnow() - timedelta(hours=2),
user=self.user,
group=self.property_group1)
session.session.add(p1)
session.session.commit()
p1 = Membership.q.filter_by(user=self.user,
group=self.property_group1).one()
self.assertTrue(p1.active())
p1.begins_at = session.utcnow() + timedelta(days=2)
session.session.commit()
p1 = Membership.q.filter_by(user=self.user,
group=self.property_group1).one()
self.assertFalse(p1.active())
p1.disable(session.utcnow() - timedelta(hours=1))
session.session.commit()
p1 = Membership.q.filter_by(user=self.user,
group=self.property_group1).one()
self.assertFalse(p1.active())
p1.ends_at = p1.begins_at + timedelta(days=1)
session.session.commit()
p1 = Membership.q.filter_by(user=self.user,
group=self.property_group1).one()
self.assertFalse(p1.active())
p1.begins_at = session.utcnow() - timedelta(days=1)
session.session.commit()
p1 = Membership.q.filter_by(user=self.user,
group=self.property_group1).one()
self.assertTrue(p1.active())
def test_user_property_groups(self):
# first have no property group
self.assertEqual(len(self.user.property_groups), 0)
self.assertEqual(len(self.user.active_property_groups()), 0)
# add one active property group
p1 = Membership(begins_at=session.utcnow() - timedelta(hours=2),
user=self.user,
group=self.property_group1)
session.session.add(p1)
session.session.commit()
f = Membership.q.first()
self.assertTrue(f.active())
self.assertEqual(len(self.user.property_groups), 1)
self.assertEqual(len(self.user.active_property_groups()), 1)
# add a second active property group - count should be 2
p1 = Membership(begins_at=session.utcnow() - timedelta(hours=2),
user=self.user,
group=self.property_group2)
session.session.add(p1)
session.session.commit()
self.assertEqual(len(self.user.property_groups), 2)
self.assertEqual(len(self.user.active_property_groups()), 2)
# disable the second group. active should be one, all 2
p1.disable(session.utcnow() - timedelta(hours=1))
session.session.commit()
self.assertEqual(len(self.user.property_groups), 2)
self.assertEqual(len(self.user.active_property_groups()), 1)
# test a join
res = session.session.query(user.User, PropertyGroup.id).join(
user.User.property_groups).filter(
user.User.id == self.user.id).distinct().count()
self.assertEqual(res, 2)
# reenable it - but with a deadline - both counts should be 2
p1.ends_at = session.utcnow() + timedelta(days=1)
session.session.commit()
self.assertEqual(len(self.user.property_groups), 2)
self.assertEqual(len(self.user.active_property_groups()), 2)
# Add a second membership to the first group
# should not affect the count
p1 = Membership(begins_at=session.utcnow() - timedelta(hours=2),
user=self.user,
group=self.property_group1)
session.session.add(p1)
session.session.commit()
self.assertEqual(len(self.user.property_groups), 2)
self.assertEqual(len(self.user.active_property_groups()), 2)
# disabling the new one should also not affect.
p1.disable(session.utcnow() - timedelta(hours=1))
session.session.commit()
self.assertEqual(len(self.user.property_groups), 2)
self.assertEqual(len(self.user.active_property_groups()), 2)
# test a join
res = session.session.query(user.User, PropertyGroup).join(
user.User.property_groups).filter(
user.User.id == self.user.id).distinct().count()
self.assertEqual(res, 2)
def add_membership(self, group):
m = Membership(user=self.user, group=group)
session.session.add(m)
session.session.commit()
return m
def test_0030_user_property_groups(self):
# first have no property group
self.assertEqual(len(self.user.property_groups), 0)
self.assertEqual(len(self.user.active_property_groups()), 0)
# add one active property group
p1 = Membership(begins_at=session.utcnow() - timedelta(hours=2),
user=self.user, group=self.property_group1)
session.session.add(p1)
session.session.commit()
f = Membership.q.first()
self.assertTrue(f.active())
self.assertEqual(len(self.user.property_groups), 1)
self.assertEqual(len(self.user.active_property_groups()), 1)
# adding a traffic group should not affect the property_group
p1 = Membership(begins_at=session.utcnow() - timedelta(hours=2),
user=self.user, group=self.traffic_group2)
session.session.add(p1)
session.session.commit()
self.assertEqual(len(self.user.property_groups), 1)
self.assertEqual(len(self.user.active_property_groups()), 1)
# add a second active property group - count should be 2
p1 = Membership(begins_at=session.utcnow() - timedelta(hours=2),
user=self.user, group=self.property_group2)
session.session.add(p1)
session.session.commit()
self.assertEqual(len(self.user.property_groups), 2)
self.assertEqual(len(self.user.active_property_groups()), 2)
# disable the second group. active should be one, all 2
p1.disable(session.utcnow() - timedelta(hours=1))
session.session.commit()
self.assertEqual(len(self.user.property_groups), 2)
self.assertEqual(len(self.user.active_property_groups()), 1)
# test a join
res = session.session.query(
user.User, PropertyGroup.id
).join(user.User.property_groups).filter(
user.User.id == self.user.id
).distinct().count()
self.assertEqual(res, 2)
# reenable it - but with a deadline - both counts should be 2
p1.ends_at = session.utcnow() + timedelta(days=1)
session.session.commit()
self.assertEqual(len(self.user.property_groups), 2)
self.assertEqual(len(self.user.active_property_groups()), 2)
# Add a second membership to the first group
# should not affect the count
p1 = Membership(begins_at=session.utcnow() - timedelta(hours=2),
user=self.user, group=self.property_group1)
session.session.add(p1)
session.session.commit()
self.assertEqual(len(self.user.property_groups), 2)
self.assertEqual(len(self.user.active_property_groups()), 2)
# disabling the new one should also not affect.
p1.disable(session.utcnow() - timedelta(hours=1))
session.session.commit()
self.assertEqual(len(self.user.property_groups), 2)
self.assertEqual(len(self.user.active_property_groups()), 2)
# test a join
res = session.session.query(
user.User, PropertyGroup
).join(user.User.property_groups).filter(
user.User.id == self.user.id
).distinct().count()
self.assertEqual(res, 2)
def test_0010_active_instance_property(self):
p1 = Membership(begins_at=session.utcnow() - timedelta(hours=2),
user=self.user, group=self.property_group1)
self.assertTrue(p1.active())
session.session.add(p1)
session.session.commit()
p1 = Membership.q.filter_by(
user=self.user, group=self.property_group1
).one()
self.assertTrue(p1.active())
p1.disable(session.utcnow() - timedelta(hours=1))
session.session.commit()
p1 = Membership.q.filter_by(
user=self.user, group=self.property_group1
).one()
self.assertFalse(p1.active())
p1.ends_at = None
session.session.commit()
p1 = Membership.q.filter_by(
user=self.user, group=self.property_group1
).one()
self.assertTrue(p1.active())
session.session.delete(p1)
session.session.commit()
p1 = Membership(begins_at=session.utcnow() - timedelta(hours=2),
user=self.user, group=self.property_group1)
session.session.add(p1)
session.session.commit()
p1 = Membership.q.filter_by(
user=self.user, group=self.property_group1
).one()
self.assertTrue(p1.active())
p1.begins_at = session.utcnow() + timedelta(days=2)
session.session.commit()
p1 = Membership.q.filter_by(
user=self.user, group=self.property_group1
).one()
self.assertFalse(p1.active())
p1.disable(session.utcnow() - timedelta(hours=1))
session.session.commit()
p1 = Membership.q.filter_by(
user=self.user, group=self.property_group1
).one()
self.assertFalse(p1.active())
p1.ends_at = p1.begins_at + timedelta(days=1)
session.session.commit()
p1 = Membership.q.filter_by(
user=self.user, group=self.property_group1
).one()
self.assertFalse(p1.active())
p1.begins_at = session.utcnow() - timedelta(days=1)
session.session.commit()
p1 = Membership.q.filter_by(
user=self.user, group=self.property_group1
).one()
self.assertTrue(p1.active())
