def setUp(self):
super(TestInteractionOfDelegationOnDifferentLevels, self).setUp()
voter_group = Group.by_code(Group.CODE_VOTER)
self.me = tt_make_user(instance_group=voter_group)
self.first = tt_make_user(instance_group=voter_group)
self.second = tt_make_user(instance_group=voter_group)
self.proposal = tt_make_proposal(voting=True)
def test_queries(self):
proposal = tt_make_proposal(voting=True)
user1 = tt_make_user()
user2 = tt_make_user()
user3 = tt_make_user()
d1to2 = Delegation(user1, user2, proposal)
model.meta.Session.add(d1to2)
model.meta.Session.flush()
dn = DelegationNode(user1, proposal)
self.assertEqual(len(dn.outbound()), 1)
dn = DelegationNode(user1, proposal)
self.assertEqual(len(dn.outbound()), 1)
dn = DelegationNode(user2, proposal)
self.assertEqual(len(dn.inbound()), 1)
dn = DelegationNode(user2, proposal)
self.assertEqual(len(dn.inbound()), 1)
d3to2 = Delegation(user3, user2, proposal)
model.meta.Session.add(d3to2)
model.meta.Session.flush()
dn = DelegationNode(user2, proposal)
self.assertEqual(len(dn.inbound()), 2)
dn = DelegationNode(user2, proposal)
self.assertEqual(len(dn.inbound(recurse=False)), 2)
def setUp(self):
super(TestInteractionOfDelegationOnDifferentLevels, self).setUp()
voter_group = Group.by_code(Group.CODE_VOTER)
self.me = tt_make_user(instance_group=voter_group)
self.first = tt_make_user(instance_group=voter_group)
self.second = tt_make_user(instance_group=voter_group)
self.proposal = tt_make_proposal(voting=True)
def test_propagate(self):
proposal = tt_make_proposal(voting=True)
user1 = tt_make_user()
user2 = tt_make_user()
user3 = tt_make_user()
user4 = tt_make_user()
userA = tt_make_user()
d2to1 = Delegation(user2, user1, proposal)
model.meta.Session.add(d2to1)
dAto1 = Delegation(userA, user1, proposal)
model.meta.Session.add(dAto1)
d3to2 = Delegation(user3, user2, proposal)
model.meta.Session.add(d3to2)
d4to3 = Delegation(user4, user3, proposal)
model.meta.Session.add(d4to3)
model.meta.Session.flush()
dn = DelegationNode(user1, proposal)
assert len(dn.inbound()) == 2
def inp(user, deleg, edge):
return "foo"
assert len(dn.propagate(inp)) == 5
def test_propagate(self):
proposal = tt_make_proposal(voting=True)
user1 = tt_make_user()
user2 = tt_make_user()
user3 = tt_make_user()
user4 = tt_make_user()
userA = tt_make_user()
d2to1 = Delegation(user2, user1, proposal)
model.meta.Session.add(d2to1)
dAto1 = Delegation(userA, user1, proposal)
model.meta.Session.add(dAto1)
d3to2 = Delegation(user3, user2, proposal)
model.meta.Session.add(d3to2)
d4to3 = Delegation(user4, user3, proposal)
model.meta.Session.add(d4to3)
model.meta.Session.flush()
dn = DelegationNode(user1, proposal)
assert len(dn.inbound()) == 2
def inp(user, deleg, edge):
return "foo"
assert len(dn.propagate(inp)) == 5
def test_queries(self):
proposal = tt_make_proposal(voting=True)
user1 = tt_make_user()
user2 = tt_make_user()
user3 = tt_make_user()
d1to2 = Delegation(user1, user2, proposal)
model.meta.Session.add(d1to2)
model.meta.Session.flush()
dn = DelegationNode(user1, proposal)
self.assertEqual(len(dn.outbound()), 1)
dn = DelegationNode(user1, proposal)
self.assertEqual(len(dn.outbound()), 1)
dn = DelegationNode(user2, proposal)
self.assertEqual(len(dn.inbound()), 1)
dn = DelegationNode(user2, proposal)
self.assertEqual(len(dn.inbound()), 1)
d3to2 = Delegation(user3, user2, proposal)
model.meta.Session.add(d3to2)
model.meta.Session.flush()
dn = DelegationNode(user2, proposal)
self.assertEqual(len(dn.inbound()), 2)
dn = DelegationNode(user2, proposal)
self.assertEqual(len(dn.inbound(recurse=False)), 2)
def setUp(self):
self.me = tt_make_user()
self.first = tt_make_user()
self.second = tt_make_user()
self.proposal = tt_make_proposal(voting=True)
self.poll = Poll.create(self.proposal, self.proposal.creator,
Poll.ADOPT)
self.instance = tt_get_instance()
def setUp(self):
self.me = tt_make_user()
self.first = tt_make_user()
self.second = tt_make_user()
self.proposal = tt_make_proposal(voting=True)
self.poll = Poll.create(self.proposal, self.proposal.creator,
Poll.ADOPT)
self.instance = tt_get_instance()
def test_assignment(self):
b = UserBadge.create(u'all users - ' + tt_make_str(), u'', False, u'')
t = Treatment.create(tt_make_str(), source_badges=[b], variant_count=2)
sb, assignments, unassigned = get_assignments_by_source_badge(t)[0]
assert sb == b
ass1, ass2 = assignments
assert len(ass1) == 0
assert len(ass2) == 0
assert len(unassigned) == 0
first_users = [tt_make_user() for _ in range(5)]
for u in first_users:
b.assign(u, u)
# sanity check
assert set(u.id for u in b.users) == set(u.id for u in first_users)
sb, assignments, unassigned = get_assignments_by_source_badge(t)[0]
assert sb == b
ass1, ass2 = assignments
assert len(ass1) == 0
assert len(ass2) == 0
assert len(unassigned) == len(first_users)
assert assign_users(t)
sb, assignments, unassigned = get_assignments_by_source_badge(t)[0]
assert sb == b
ass1, ass2 = assignments
assert len(ass1) + len(ass2) == len(first_users)
assert (len(ass1) == len(ass2) - 1) or (len(ass1) == len(ass2) + 1)
assert len(unassigned) == 0
assert not assign_users(t)
new_users = [tt_make_user() for _ in range(5)]
for u in new_users:
b.assign(u, u)
sb, assignments, unassigned = get_assignments_by_source_badge(t)[0]
assert sb == b
ass1, ass2 = assignments
assert len(ass1) + len(ass2) == len(first_users)
assert (len(ass1) == len(ass2) - 1) or (len(ass1) == len(ass2) + 1)
assert len(unassigned) == len(new_users)
assert assign_users(t)
sb, assignments, unassigned = get_assignments_by_source_badge(t)[0]
assert sb == b
ass1, ass2 = assignments
assert len(ass1) + len(ass2) == len(first_users) + len(new_users)
# The following assert is disabled as it fails non-deterministically
# (see #601). It can be reenabled once this issue is fixed.
#assert len(ass1) == len(ass2)
assert len(unassigned) == 0
assert not assign_users(t)
def _make_one(self):
"""Returns creator, badged user and badge"""
from adhocracy import model
creator = tt_make_user('creator')
badged_user = tt_make_user('badged_user')
badge = model.UserBadge.create(u'testbadge', u'#ccc', u'description')
badge.assign(badged_user, creator)
return creator, badged_user, badge
def test_render_no_xss_substitutions(self):
from adhocracy.lib.text import render
tt_make_user('<foo>')
source = '@<foo>'
result = render(source, substitutions=True)
self.assertEquals(result[:3], '<p>')
self.assertEquals(result[-4:], '</p>')
core_result = result[3:-4]
self.assertTrue(u'<' not in core_result)
def test_render_no_xss_substitutions(self):
from adhocracy.lib.text import render
tt_make_user('<foo>')
source = '@<foo>'
result = render(source, substitutions=True)
self.assertEquals(result[:3], '<p>')
self.assertEquals(result[-4:], '</p>')
core_result = result[3:-4]
self.assertTrue(u'<' not in core_result)
def _make_one(self):
"""Returns creator, badged user and badge"""
from adhocracy import model
creator = tt_make_user('creator')
badged_user = tt_make_user('badged_user')
badge = model.UserBadge.create(u'testbadge', u'#ccc', u'description')
badge.assign(badged_user, creator)
return creator, badged_user, badge
def test_can_delegate_via_forward_on_user(self):
proposal = tt_make_proposal(voting=True)
voter_group = Group.by_code(Group.CODE_VOTER)
me = tt_make_user(instance_group=voter_group)
delegate = tt_make_user(instance_group=voter_group)
Delegation.create(me, delegate, proposal)
self.assertEqual(delegate.number_of_votes_in_scope(proposal), 2)
def test_valid_badge(self):
from adhocracy.forms import ValidBadge
from adhocracy.model import Badge, UserBadge
creator = tt_make_user('creator')
badged_user = tt_make_user('badged_user')
badge = Badge.create('testbadge', '#ccc', 'description')
UserBadge.create(badged_user, badge, creator)
value = ValidBadge.to_python(badge.id, None)
self.assertEqual(value, badge)
def _make_one(self):
"""Returns creator, badged user and badge"""
from adhocracy.model import Badge, UserBadge
creator = tt_make_user('creator')
badged_user = tt_make_user('badged_user')
badge = Badge.create(u'testbadge', u'#ccc', u'description')
UserBadge.create(badged_user, badge, creator)
return creator, badged_user, badge
def test_can_delegate_via_forward_on_user(self):
proposal = tt_make_proposal(voting=True)
voter_group = Group.by_code(Group.CODE_VOTER)
me = tt_make_user(instance_group=voter_group)
delegate = tt_make_user(instance_group=voter_group)
Delegation.create(me, delegate, proposal)
self.assertEqual(delegate.number_of_votes_in_scope(proposal), 2)
def setUp(self):
self.me = tt_make_user(name='me')
self.high_delegate = tt_make_user(name='high_delegate')
self.low_delegate = tt_make_user(name='low_delegate')
self.proposal = tt_make_proposal(creator=self.me, voting=True)
self.poll = Poll.create(self.proposal, self.proposal.creator,
Poll.ADOPT)
self.decision = Decision(self.me, self.poll)
self.instance = tt_get_instance()
def test_valid_badge(self):
from adhocracy.forms import ValidBadge
from adhocracy.model import Badge, UserBadge
creator = tt_make_user('creator')
badged_user = tt_make_user('badged_user')
badge = Badge.create('testbadge', '#ccc', 'description')
UserBadge.create(badged_user, badge, creator)
value = ValidBadge.to_python(badge.id, None)
self.assertEqual(value, badge)
def test_invalid_badge(self):
from formencode import Invalid
from adhocracy.forms import ValidBadge
from adhocracy.model import Badge, UserBadge
creator = tt_make_user('creator')
badged_user = tt_make_user('badged_user')
badge = Badge.create('testbadge', '#ccc', 'description')
UserBadge.create(badged_user, badge, creator)
self.assertRaises(Invalid, ValidBadge.to_python,
badge.id + 1, state=None)
def _make_one(self):
"""Returns creator, badged user and badge"""
from adhocracy.model import Badge, UserBadge
creator = tt_make_user("creator")
badged_user = tt_make_user("badged_user")
badge = Badge.create(u"testbadge", u"#ccc", u"description")
UserBadge.create(badged_user, badge, creator)
return creator, badged_user, badge
def setUp(self):
super(TestDecisionWithDelegation, self).setUp()
self.me = tt_make_user(name='me')
self.high_delegate = tt_make_user(name='high_delegate')
self.low_delegate = tt_make_user(name='low_delegate')
self.proposal = tt_make_proposal(creator=self.me, voting=True)
self.poll = Poll.create(self.proposal, self.proposal.creator,
Poll.ADOPT)
self.decision = Decision(self.me, self.poll)
self.instance = tt_get_instance()
def test_invalid_badge(self):
from formencode import Invalid
from adhocracy.forms import ValidBadge
from adhocracy.model import Badge, UserBadge
creator = tt_make_user('creator')
badged_user = tt_make_user('badged_user')
badge = Badge.create('testbadge', '#ccc', 'description')
UserBadge.create(badged_user, badge, creator)
self.assertRaises(Invalid,
ValidBadge.to_python,
badge.id + 1,
state=None)
def test_members(self):
from adhocracy.model import Instance, Group
test_instance = Instance.find('test')
members = test_instance.members()
self.assertEqual(len(members), 1)
self.assertEqual(members[0].user_name, u'admin')
voters = Group.find(u'Voter')
tt_make_user(u'second', voters)
members = test_instance.members()
self.assertEqual(len(members), 2)
self.assertEqual(sorted([member.user_name for member in
test_instance.members()]),
['admin', 'second'])
def test_members(self):
from adhocracy.model import Instance, Group
test_instance = Instance.find('test')
members = test_instance.members()
self.assertEqual(len(members), 1)
self.assertEqual(members[0].user_name, u'admin')
voters = Group.find(u'Voter')
tt_make_user(u'second', voters)
members = test_instance.members()
self.assertEqual(len(members), 2)
self.assertEqual(
sorted([member.user_name for member in test_instance.members()]),
['admin', 'second'])
def _make_one(title, text, creator=None, time=None):
from adhocracy.model import Instance, Milestone
if creator is None:
creator = tt_make_user()
instance = Instance.find('test')
now = datetime.now()
milestone = Milestone.create(instance, creator, title, text, now)
return (milestone, creator)
def _make_one(title, text, creator=None, time=None):
from adhocracy.model import Instance, Milestone
if creator is None:
creator = tt_make_user()
instance = Instance.find('test')
now = datetime.now()
milestone = Milestone.create(instance, creator, title, text, now)
return (milestone, creator)
def test_delete_user_deletes_watches(self):
from adhocracy.model import Watch
voter_group = Group.by_code(Group.CODE_VOTER)
user = tt_make_user(instance_group=voter_group)
instance = tt_get_instance()
watch = Watch.create(user, instance)
self.assertFalse(watch.is_deleted())
user.delete()
self.assertTrue(watch.is_deleted())
def _make_content(self):
"""Returns creator, delegateable and badge"""
from adhocracy.model import InstanceBadge, Instance
creator = tt_make_user('creator')
instance = Instance.create("instance2", u"instance2", creator)
badge = InstanceBadge.create(u'testbadge', u'#ccc2', 'description')
return creator, instance, badge
def test_delete_user_deletes_watches(self):
from adhocracy.model import Watch
voter_group = Group.by_code(Group.CODE_VOTER)
user = tt_make_user(instance_group=voter_group)
instance = tt_get_instance()
watch = Watch.create(user, instance)
self.assertFalse(watch.is_deleted())
user.delete()
self.assertTrue(watch.is_deleted())
def test_existing_user_is_matched_by_email(self):
# his email is [email protected]
user = tt_make_user("Jonny")
user2, velruse_user = VelruseController._create(
self, "test_user", "*****@*****.**", "facebook", "392833324324")
self.assertEqual(user, user2)
def test_filter(self):
# FIXME: refactor this test. we don't have issues anymore
return
proposal = tt_make_proposal(voting=True)
user1 = tt_make_user()
user2 = tt_make_user()
user3 = tt_make_user()
small = Delegation(user1, user2, proposal)
model.meta.Session.add(small)
large = Delegation(user1, user3, proposal.issue)
model.meta.Session.add(large)
model.meta.Session.flush()
res = DelegationNode.filter_less_specific_delegations([small, large])
assert small in res
assert large not in res
def test_filter(self):
# FIXME: refactor this test. we don't have issues anymore
return
proposal = tt_make_proposal(voting=True)
user1 = tt_make_user()
user2 = tt_make_user()
user3 = tt_make_user()
small = Delegation(user1, user2, proposal)
model.meta.Session.add(small)
large = Delegation(user1, user3, proposal.issue)
model.meta.Session.add(large)
model.meta.Session.flush()
res = DelegationNode.filter_less_specific_delegations([small, large])
assert small in res
assert large not in res
def _make_content(self):
"""Returns creator, delegateable and badge"""
from adhocracy.model import InstanceBadge, Instance
creator = tt_make_user('creator')
instance = Instance.create("instance2", u"instance2", creator)
badge = InstanceBadge.create(u'testbadge', u'#ccc2', 'description')
return creator, instance, badge
def _make_content(self):
"""Returns creator, delegateable and badge"""
from adhocracy.model import Badge, Proposal, Instance
instance = Instance.find('test')
creator = tt_make_user('creator')
delegateable = Proposal.create(instance, u"labeld", creator)
badge = Badge.create(u'testbadge', u'#ccc', 'description')
return creator, delegateable, badge
def _make_content(self):
"""Returns creator, delegateable and badge"""
from adhocracy.model import DelegateableBadge, Proposal, Instance
instance = Instance.find('test')
creator = tt_make_user('creator')
delegateable = Proposal.create(instance, u"labeld", creator)
badge = DelegateableBadge.create(u'testbadge', u'#ccc', 'description')
return creator, delegateable, badge
def test_create_milestone(self):
from adhocracy.model import Instance, Milestone
now = datetime.now()
creator = tt_make_user()
instance = Instance.find('test')
milestone = Milestone.create(instance, creator, u'Titleü', u'Textü',
now)
self.assertEqual(milestone.instance, instance)
self.assertEqual(milestone.creator, creator)
self.assertEqual(len(Milestone.all()), 1)
def test_create_milestone(self):
from adhocracy.model import Instance, Milestone
now = datetime.now()
creator = tt_make_user()
instance = Instance.find('test')
milestone = Milestone.create(instance, creator, u'Titleü', u'Textü',
now)
self.assertEqual(milestone.instance, instance)
self.assertEqual(milestone.creator, creator)
self.assertEqual(len(Milestone.all()), 1)
def setUp(self):
super(ImportExportTest, self).setUp()
self.u1 = testtools.tt_make_user()
self.u1.gender = u'f'
self.badge = model.UserBadge.create(
title=u'importexport_badge"\'/\\ä↭𝕐',
color=u'#ff00ff',
visible=True,
description=u'This badge tests',
)
self.u2 = testtools.tt_make_user()
self.badge.assign(user=self.u1, creator=self.u2)
self.instance = testtools.tt_make_instance(u'export_test',
label=u'export_test',
creator=self.u2)
self.instance.label = u'test"\'/\\ä↭𝕐'
self.instance.description = u'test"\'/\\ä↭𝕐'
self.instance.required_majority = 0.42
self.instance.activation_delay = 5
self.instance.create_time = datetime.datetime.now()
self.instance.access_time = datetime.datetime.now()
self.instance.delete_time = None
self.instance.default_group_id = 42
self.instance.allow_adopt = False
self.instance.allow_delegate = False
self.instance.allow_propose = False
self.instance.allow_index = False
self.instance.hidden = False
self.instance.locale = u'fr_FR'
self.instance.css = u'test"\'/\\ä↭𝕐'
self.instance.frozen = True
self.instance.milestones = True
self.instance.use_norms = False
self.instance.require_selection = True
self.instance.is_authenticated = True
self.instance.hide_global_categories = True
self.instance.editable_comments_default = False
self.instance.editable_proposals_default = False
self.instance.require_valid_email = False
self.instance.allow_thumbnailbadges = True
self.instance.thumbnailbadges_height = 42
self.instance.thumbnailbadges_width = 42
def _make_content(self):
"""Returns creator, delegateable and badge"""
from adhocracy.model import Badge, Proposal, Instance
instance = Instance.find("test")
creator = tt_make_user("creator")
delegateable = Proposal.create(instance, u"labeld", creator)
badge = Badge.create(u"testbadge", u"#ccc", "description")
return creator, delegateable, badge
def test_detach(self):
proposal = tt_make_proposal(voting=True)
user1 = tt_make_user()
user2 = tt_make_user()
user3 = tt_make_user()
d2to1 = Delegation(user2, user1, proposal)
model.meta.Session.add(d2to1)
d3to1 = Delegation(user3, user1, proposal)
model.meta.Session.add(d3to1)
model.meta.Session.flush()
dn = DelegationNode(user1, proposal)
assert len(dn.inbound()) == 2
user1.revoke_delegations(tt_get_instance())
dn = DelegationNode(user1, proposal)
assert len(dn.inbound()) == 0
def test_detach(self):
proposal = tt_make_proposal(voting=True)
user1 = tt_make_user()
user2 = tt_make_user()
user3 = tt_make_user()
d2to1 = Delegation(user2, user1, proposal)
model.meta.Session.add(d2to1)
d3to1 = Delegation(user3, user1, proposal)
model.meta.Session.add(d3to1)
model.meta.Session.flush()
dn = DelegationNode(user1, proposal)
assert len(dn.inbound()) == 2
user1.revoke_delegations(tt_get_instance())
dn = DelegationNode(user1, proposal)
assert len(dn.inbound()) == 0
def _make_content(self):
"""Returns creator, delegateable and badge"""
from adhocracy.model import ThumbnailBadge, Proposal, Instance
instance = Instance.find(u'test')
creator = tt_make_user(u'creator')
delegateable = Proposal.create(instance, u"labeld", creator)
thumbnail = b'binary'
badge = ThumbnailBadge.create(u'testbadge', u'#ccc', True,
u'description', thumbnail=thumbnail)
return creator, delegateable, badge
def test_existing_user_is_matched_by_email(self):
# his email is [email protected]
user = tt_make_user("Jonny")
user2, velruse_user = VelruseController._create(self,
"test_user",
"*****@*****.**",
"facebook",
"392833324324")
self.assertEqual(user, user2)
def prepare_app(self, anonymous=False, group_code=None, instance=True):
self.app.extra_environ = dict()
self.user = None
if not anonymous:
group = None
if group_code:
group = Group.by_code(group_code)
self.user = tt_make_user(instance_group=group)
self.app.extra_environ['REMOTE_USER'] = str(self.user.user_name)
if instance:
self.app.extra_environ['HTTP_HOST'] = "test.test.lan"
else:
self.app.extra_environ['HTTP_HOST'] = "test.lan"
def test_connect_existing_user_different_email(self):
user = tt_make_user("Jonny")
# his email is [email protected]
velruse_user = VelruseModel.connect(user, "facebook", "328957239052",
"*****@*****.**", True)
meta.Session.commit()
self.assertNotEqual(velruse_user, None)
self.assertEqual(user.id, velruse_user.user_id)
self.assertNotEqual(user.activation_code, None)
def test_connect_existing_user_same_email(self):
user = tt_make_user("Jonny")
# his email is [email protected]
velruse_user = VelruseModel.connect(user, "facebook", "239857329847",
"*****@*****.**", True)
meta.Session.commit()
self.assertNotEqual(velruse_user, None)
self.assertEqual(user.id, velruse_user.user_id)
self.assertEqual(user.activation_code, None)
def prepare_app(self, anonymous=False, group_code=None, instance=True):
self.app.extra_environ = dict()
self.user = None
if not anonymous:
group = None
if group_code:
group = Group.by_code(group_code)
self.user = tt_make_user(instance_group=group)
self.app.extra_environ['REMOTE_USER'] = str(self.user.user_name)
if instance:
self.app.extra_environ['HTTP_HOST'] = "test.test.lan"
else:
self.app.extra_environ['HTTP_HOST'] = "test.lan"
def test_vote_by_other_user(self):
from adhocracy.lib.democracy import Decision
proposal = tt_make_proposal(voting=True)
poll = proposal.polls[0]
self.assertEqual(0, len(list(poll.votes)))
# make a new user and let him vote
new_user = tt_make_user()
decision = Decision(new_user, poll)
votes = decision.make(Vote.YES)
self.assertEqual(len(votes), 1)
self.assertEqual(len(decision.votes), 1)
self.assertEqual(len(poll.votes), 1)
self.assertEqual(votes[0].orientation, Vote.YES)
def test_vote_by_other_user(self):
from adhocracy.lib.democracy import Decision
proposal = tt_make_proposal(voting=True)
poll = proposal.polls[0]
self.assertEqual(0, len(list(poll.votes)))
# make a new user and let him vote
new_user = tt_make_user()
decision = Decision(new_user, poll)
votes = decision.make(Vote.YES)
self.assertEqual(len(votes), 1)
self.assertEqual(len(decision.votes), 1)
self.assertEqual(len(poll.votes), 1)
self.assertEqual(votes[0].orientation, Vote.YES)
def setUp(self):
super(ImportExportTest, self).setUp()
self.u1 = testtools.tt_make_user()
self.u1.gender = u"f"
self.badge = model.UserBadge.create(
title=u"importexport_badge\"'/\\ä↭𝕐", color=u"#ff00ff", visible=True, description=u"This badge tests"
)
self.u2 = testtools.tt_make_user()
self.badge.assign(user=self.u1, creator=self.u2)
self.instance = testtools.tt_make_instance(u"export_test", label=u"export_test", creator=self.u2)
self.instance.label = u"test\"'/\\ä↭𝕐"
self.instance.description = u"test\"'/\\ä↭𝕐"
self.instance.required_majority = 0.42
self.instance.activation_delay = 5
self.instance.create_time = datetime.datetime.now()
self.instance.access_time = datetime.datetime.now()
self.instance.delete_time = None
self.instance.default_group_id = 42
self.instance.allow_adopt = False
self.instance.allow_delegate = False
self.instance.allow_propose = False
self.instance.allow_index = False
self.instance.hidden = False
self.instance.locale = u"fr_FR"
self.instance.css = u"test\"'/\\ä↭𝕐"
self.instance.frozen = True
self.instance.milestones = True
self.instance.use_norms = False
self.instance.require_selection = True
self.instance.is_authenticated = True
self.instance.hide_global_categories = True
self.instance.editable_comments_default = False
self.instance.editable_proposals_default = False
self.instance.require_valid_email = False
self.instance.allow_thumbnailbadges = True
self.instance.thumbnailbadges_height = 42
self.instance.thumbnailbadges_width = 42
def test_connect_existing_user_different_email(self):
user = tt_make_user("Jonny")
# his email is [email protected]
velruse_user = VelruseModel.connect(user,
"facebook",
"328957239052",
"*****@*****.**",
True)
meta.Session.commit()
self.assertNotEqual(velruse_user, None)
self.assertEqual(user.id, velruse_user.user_id)
self.assertNotEqual(user.activation_code, None)
def test_connect_existing_user_same_email(self):
user = tt_make_user("Jonny")
# his email is [email protected]
velruse_user = VelruseModel.connect(user,
"facebook",
"239857329847",
"*****@*****.**",
True)
meta.Session.commit()
self.assertNotEqual(velruse_user, None)
self.assertEqual(user.id, velruse_user.user_id)
self.assertEqual(user.activation_code, None)
def setUp(self):
voter_group = Group.by_code(Group.CODE_VOTER)
self.me = tt_make_user(instance_group=voter_group)
self.first = tt_make_user(instance_group=voter_group)
self.second = tt_make_user(instance_group=voter_group)
self.proposal = tt_make_proposal(voting=True)
def test_render_no_substitution(self):
from adhocracy.lib.text import render
tt_make_user('pudo')
source = '@pudo'
result = render(source, substitutions=False)
self.assertEqual(result, u'<p>@pudo</p>')
def test_render_user_substitution(self):
from adhocracy.lib.text import render
tt_make_user('pudo')
source = '@pudo'
result = render(source, substitutions=True)
self.assertTrue(u'/user/pudo"' in result)
def test_render_user_substitution(self):
from adhocracy.lib.text import render
tt_make_user('pudo')
source = '@pudo'
result = render(source, substitutions=True)
self.assertTrue(u'http://test.lan/user/pudo"' in result)
def test_render_no_substitution(self):
from adhocracy.lib.text import render
tt_make_user('pudo')
source = '@pudo'
result = render(source, substitutions=False)
self.assertEqual(result, u'<p>@pudo</p>\n')
