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_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_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_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_mutual_delegation_gives_two_votes_each(self):
self._do_delegate(self.first, self.second, self.proposal)
self._do_delegate(self.second, self.first, self.proposal)
delegations = DelegationNode(self.first, self.proposal)
self.assertEqual(len(delegations.transitive_inbound()), 1)
delegations = DelegationNode(self.second, self.proposal)
self.assertEqual(len(delegations.transitive_inbound()), 1)
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_mutual_delegation_gives_two_votes_each(self):
self._do_delegate(self.first, self.second, self.proposal)
self._do_delegate(self.second, self.first, self.proposal)
delegations = DelegationNode(self.first, self.proposal)
self.assertEqual(len(delegations.transitive_inbound()), 1)
delegations = DelegationNode(self.second, self.proposal)
self.assertEqual(len(delegations.transitive_inbound()), 1)
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 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_knows_to_whom_a_delegation_went(self):
self._do_delegate(self.me, self.first, self.proposal)
delegations = DelegationNode(self.me, self.proposal)
self.assertEqual(len(delegations.outbound()), 1)
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_delegation_node_ads_indirect_delegation_to_number_of_delegations(
self):
self._do_delegate(self.first, self.me, self.proposal)
self._do_delegate(self.second, self.first, self.proposal)
node = DelegationNode(self.me, self.proposal)
self.assertEqual(node.number_of_delegations(), 2)
def test_delegation_node_ads_indirect_delegation_to_number_of_delegations(
self):
self._do_delegate(self.first, self.me, self.proposal)
self._do_delegate(self.second, self.first, self.proposal)
node = DelegationNode(self.me, self.proposal)
self.assertEqual(node.number_of_delegations(), 2)
def test_delegation_node_with_no_delegations_has_no_delegations(self):
node = DelegationNode(self.me, self.proposal)
self.assertEqual(node.number_of_delegations(), 0)
def test_mutual_delegation_is_not_counted_as_direct_delegation(self):
self._do_delegate(self.first, self.second, self.proposal)
self._do_delegate(self.second, self.first, self.proposal)
delegations = DelegationNode(self.first, self.proposal)
self.assertEqual(len(delegations.inbound()), 1)
def test_can_get_indirect_delegations(self):
self._do_delegate(self.me, self.first, self.proposal)
self._do_delegate(self.first, self.second, self.proposal)
delegations = DelegationNode(self.second, self.proposal)
self.assertEqual(len(delegations.inbound()), 1)
self.assertEqual(len(delegations.transitive_inbound()), 2)
def test_knows_to_whom_a_delegation_went(self):
self._do_delegate(self.me, self.first, self.proposal)
delegations = DelegationNode(self.me, self.proposal)
self.assertEqual(len(delegations.outbound()), 1)
def test_can_get_indirect_delegations(self):
self._do_delegate(self.me, self.first, self.proposal)
self._do_delegate(self.first, self.second, self.proposal)
delegations = DelegationNode(self.second, self.proposal)
self.assertEqual(len(delegations.inbound()), 1)
self.assertEqual(len(delegations.transitive_inbound()), 2)
def test_mutual_delegation_is_not_counted_as_direct_delegation(self):
self._do_delegate(self.first, self.second, self.proposal)
self._do_delegate(self.second, self.first, self.proposal)
delegations = DelegationNode(self.first, self.proposal)
self.assertEqual(len(delegations.inbound()), 1)
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_delegation_node_with_no_delegations_has_no_delegations(self):
node = DelegationNode(self.me, self.proposal)
self.assertEqual(node.number_of_delegations(), 0)
def test_if_proposal_has_no_poll_no_direct_vote_overides_delegations(self):
proposal_without_poll = tt_make_proposal()
self._do_delegate(self.first, self.second,
proposal_without_poll)
node = DelegationNode(self.second, proposal_without_poll)
self.assertEqual(node.number_of_delegations(), 1)
def test_if_proposal_has_no_poll_no_direct_vote_overides_delegations(self):
proposal_without_poll = tt_make_proposal()
self._do_delegate(self.first, self.second, proposal_without_poll)
node = DelegationNode(self.second, proposal_without_poll)
self.assertEqual(node.number_of_delegations(), 1)
def delegation_node(self, scope):
from adhocracy.lib.democracy import DelegationNode
return DelegationNode(self, scope)
