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 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 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_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 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_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_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 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_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 _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 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 _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 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 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')