def test_two_delegations_at_the_same_level_that_agree_reinforce_each_other(
self):
self._do_delegate(self.me, self.high_delegate, self.proposal)
self._do_delegate(self.me, self.low_delegate, self.proposal)
Decision(self.high_delegate, self.poll).make(Vote.YES)
Decision(self.low_delegate, self.poll).make(Vote.YES)
self.assertEqual(self.decision.reload().result, Vote.YES)
def test_delegation_is_not_used_if_user_has_voted_directly(self):
self._do_delegate(self.first, self.second, self.proposal)
self._do_delegate(self.second, self.first, self.proposal)
Decision(self.second, self.poll).make(Vote.NO)
Decision(self.first, self.poll).make(Vote.YES)
self.assertEqual(
Decision(self.second, self.poll).is_self_decided(), True)
self.assertEqual(Decision(self.second, self.poll).result, Vote.NO)
def test_two_delegations_at_the_same_level_that_disagree_cancel_each_other(
self):
# This is meant as a safeguard: if I don't fully trust my delegates
# I can delegate to n delegates, and my vote will only be autocast
# if they all agree
# If not, I need to decide myself
self._do_delegate(self.me, self.high_delegate, self.proposal)
self._do_delegate(self.me, self.low_delegate, self.proposal)
Decision(self.high_delegate, self.poll).make(Vote.YES)
Decision(self.low_delegate, self.poll).make(Vote.NO)
self.assertEqual(self.decision.reload().result, None,
"needs to cast his own vote")
def test_if_mutual_delegation_is_broken_breaker_gets_one_delegation(self):
self._do_delegate(self.first, self.second, self.proposal)
self._do_delegate(self.second, self.first, self.proposal)
Decision(self.first, self.poll).make(Vote.YES)
node = DelegationNode(self.first, self.proposal)
self.assertEqual(node.number_of_delegations(), 1)
def test_second_identical_vote(self):
from adhocracy.lib.democracy import Decision
proposal = tt_make_proposal(voting=True)
poll = proposal.polls[0]
self.assertEqual(0, len(list(poll.votes)))
decision = Decision(proposal.creator, poll)
votes = decision.make(Vote.YES)
self.assertEqual(len(votes), 1)
self.assertEqual(len(decision.votes), 1)
self.assertEqual(len(poll.votes), 1)
# a second, identical vote by the same user
decision = Decision(proposal.creator, poll)
votes = decision.make(Vote.YES)
self.assertEqual(len(votes), 1)
self.assertEqual(len(decision.votes), 2)
self.assertEqual(len(poll.votes), 2)
def num_principals(self):
if self.__num_principals is None:
principals = set(map(lambda d: d.principal,
self.dnode.transitive_inbound()))
if self.poll:
principals = filter(
lambda p: not Decision(p, self.poll).is_self_decided(),
principals)
self.__num_principals = len(principals)
return self.__num_principals
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_vote_by_creator(self):
from adhocracy.lib.democracy import Decision
proposal = tt_make_proposal(voting=True)
poll = proposal.polls[0]
self.assertEqual(0, len(list(poll.votes)))
decision = Decision(proposal.creator, poll)
votes = decision.make(Vote.YES)
self.assertEqual(len(votes), 1)
self.assertEqual(len(decision.votes), 1)
self.assertEqual(votes[0].orientation, Vote.YES)
self.assertEqual(votes[0].user, proposal.creator)
def create(cls, scope, user, action, subject=None, with_vote=False):
from tally import Tally
from vote import Vote
from adhocracy.lib.democracy import Decision
poll = Poll(scope, user, action, subject=subject)
meta.Session.add(poll)
meta.Session.flush()
if with_vote:
decision = Decision(user, poll)
decision.make(Vote.YES)
Tally.create_from_poll(poll)
meta.Session.flush()
return poll
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_two_delegations_at_the_same_level_are_both_relevant_votes(self):
self._do_delegate(self.me, self.high_delegate, self.proposal)
self._do_delegate(self.me, self.low_delegate, self.proposal)
Decision(self.high_delegate, self.poll).make(Vote.YES)
Decision(self.low_delegate, self.poll).make(Vote.YES)
self.assertEqual(len(self.decision.reload().relevant_votes), 2)
def test_delegation_can_decide_a_decision(self):
self._do_delegate(self.me, self.high_delegate, self.proposal)
Decision(self.high_delegate, self.poll).make(Vote.YES)
self.decision.reload()
self.assertTrue(self.decision.is_decided())
def test_can_do_general_delegate_to_other_user(self):
self._do_delegate(self.me, self.high_delegate, self.proposal)
Decision(self.high_delegate, self.poll).make(Vote.YES)
self.assertEqual(self.decision.reload().result, Vote.YES)
def setUp(self):
super(TestDecisionWithoutDelegation, self).setUp()
self.proposal = tt_make_proposal(voting=True)
self.poll = Poll.create(self.proposal, self.proposal.creator,
Poll.ADOPT)
self.decision = Decision(self.proposal.creator, self.poll)
def test_delegation_is_transitive_across_delegation_levels(self):
self._do_delegate(self.me, self.low_delegate, self.proposal)
self._do_delegate(self.low_delegate, self.high_delegate, self.proposal)
Decision(self.high_delegate, self.poll).make(Vote.YES)
self.assertEqual(self.decision.reload().result, Vote.YES)
def test_delegation_is_recorded_as_just_another_vote(self):
self._do_delegate(self.me, self.high_delegate, self.proposal)
self.assertEqual(len(self.decision.reload().votes), 0)
Decision(self.high_delegate, self.poll).make(Vote.YES)
self.assertEqual(len(self.decision.reload().votes), 1)
def test_own_vote_overrides_delegations(self):
self._do_delegate(self.me, self.high_delegate, self.proposal)
Decision(self.high_delegate, self.poll).make(Vote.YES)
self.decision.make(Vote.NO)
self.assertEqual(self.decision.reload().result, Vote.NO)
def test_delegated_decisions_are_not_self_decided(self):
self._do_delegate(self.me, self.high_delegate, self.proposal)
Decision(self.high_delegate, self.poll).make(Vote.YES)
self.decision.reload()
self.assertFalse(self.decision.is_self_decided())
