def test_increase_is_based_on_nominal_take_last_week(self):
team, alice, bob = self.make_team_of_two()
self.warbucks.set_tip_to(team, EUR('15.03'))
self.take_last_week(team, alice, EUR('20.00'), actual_amount=EUR('15.03'))
team.set_take_for(alice, EUR('35.00'), team, check_max=False)
assert team.set_take_for(alice, EUR('42.00'), alice) == 40
def test_receiving_includes_taking_when_updated_from_set_tip_to(self):
alice = self.make_participant('alice', balance=EUR(100))
bob = self.make_participant('bob', taking=EUR('42.00'))
alice.set_tip_to(bob, EUR('3.00'))
assert Participant.from_username(
'bob').receiving == bob.receiving == EUR('45.00')
def test_pledging_isnt_giving(self):
alice = self.make_participant('alice', balance=EUR(100))
bob = self.make_elsewhere('github', 58946, 'bob').participant
alice.set_tip_to(bob, EUR('3.00'))
assert alice.giving == EUR('0.00')
def test_stt_doesnt_allow_self_tipping(self):
alice = self.make_participant('alice', balance=EUR(100))
with pytest.raises(NoSelfTipping):
alice.set_tip_to(alice, EUR('10.00'))
def test_stt_fails_to_tip_unknown_people(self):
alice = self.make_participant('alice', balance=EUR(100))
with pytest.raises(NoTippee):
alice.set_tip_to('bob', EUR('1.00'))
def test_get_end_of_year_balances(self):
make_history(self)
balances = get_end_of_year_balances(self.db, self.alice, self.past_year, datetime.now().year)
assert list(balances) == [EUR('10.00'), USD('0.00')]
def test_getting_tips_not_made(self):
expected = EUR('0.00')
user2 = self.make_participant('user2')
actual = self.stub.get_tip_to(user2)['amount']
assert actual == expected
def test_stt_sets_tip_to(self):
alice = self.make_participant('alice')
bob = self.make_stub()
alice.set_tip_to(bob, EUR('1.00'))
actual = alice.get_tip_to(bob).amount
assert actual == EUR('1.00')
def test_only_funded_tips_count(self):
alice = self.make_participant('alice')
bob = self.make_participant('bob')
carl = self.make_participant('carl')
dana = self.make_participant('dana')
alice_card = self.upsert_route(alice, 'stripe-card')
alice.set_tip_to(dana, EUR('3.00'))
self.make_payin_and_transfer(alice_card, dana, EUR('15.00'))
alice.set_tip_to(bob, EUR('6.00'))
self.make_payin_and_transfer(alice_card, bob, EUR('30.00'))
bob.set_tip_to(alice, EUR('5.00'))
bob.set_tip_to(dana, EUR('2.00'))
carl.set_tip_to(dana, EUR('2.08'))
assert alice.giving == EUR('9.00')
assert alice.receiving == EUR('0.00')
assert bob.giving == EUR('0.00')
assert bob.receiving == EUR('6.00')
assert carl.giving == EUR('0.00')
assert carl.receiving == EUR('0.00')
assert dana.receiving == EUR('3.00')
assert dana.npatrons == 1
funded_tips = self.db.all("SELECT amount FROM tips WHERE is_funded ORDER BY id")
assert funded_tips == [3, 6]
def test_set_tip_to_patron(self):
self.make_participant("alice", goal=EUR(-1))
bob = self.make_participant("bob")
response = self.tip(bob, "alice", "10.00", raise_immediately=False)
assert response.code == 200
def test_resolve_destination(self):
alice = self.make_participant('alice')
bob = self.make_participant('bob')
carl = self.make_participant('carl')
team = self.make_participant('team', kind='group')
alice.set_tip_to(team, EUR('10'))
# Test without payment account
team.add_member(bob)
with self.assertRaises(MissingPaymentAccount):
resolve_destination(self.db, team, 'stripe', alice, 'FR',
EUR('10'))
# Test without payment account at the requested provider
stripe_account_bob = self.add_payment_account(bob, 'stripe')
with self.assertRaises(MissingPaymentAccount):
resolve_destination(self.db, team, 'paypal', alice, 'US',
EUR('10'))
# Test with a single member and the take at zero
account = resolve_destination(self.db, team, 'stripe', alice, 'GB',
EUR('7'))
assert account == stripe_account_bob
# Test with two members but only one payment account
team.add_member(carl)
account = resolve_destination(self.db, team, 'stripe', alice, 'CH',
EUR('8'))
assert account == stripe_account_bob
# Test with two members but only one payment account at the requested provider
paypal_account_carl = self.add_payment_account(carl, 'paypal')
account = resolve_destination(self.db, team, 'stripe', alice, 'BE',
EUR('42'))
assert account == stripe_account_bob
# Test with two members and both takes at zero
stripe_account_carl = self.add_payment_account(carl, 'stripe')
account = resolve_destination(self.db, team, 'stripe', alice, 'PL',
EUR('5.46'))
assert account == stripe_account_bob
account = resolve_destination(self.db, team, 'paypal', alice, 'PL',
EUR('99.9'))
assert account == paypal_account_carl
# Test with two members and one non-zero take
team.set_take_for(bob, EUR('1'), bob)
account = resolve_destination(self.db, team, 'stripe', alice, 'RU',
EUR('50.02'))
assert account == stripe_account_bob
account = resolve_destination(self.db, team, 'paypal', alice, 'RU',
EUR('33'))
assert account == paypal_account_carl
# Test with two members and two different non-zero takes
team.set_take_for(carl, EUR('2'), carl)
account = resolve_destination(self.db, team, 'stripe', alice, 'BR',
EUR('10'))
assert account == stripe_account_carl
account = resolve_destination(self.db, team, 'stripe', alice, 'BR',
EUR('1'))
assert account == stripe_account_carl
account = resolve_destination(self.db, team, 'paypal', alice, 'BR',
EUR('5'))
assert account == paypal_account_carl
# Check that members are cycled through
alice_card = ExchangeRoute.insert(alice,
'stripe-card',
'x',
'chargeable',
remote_user_id='x')
payin, pt = self.make_payin_and_transfer(alice_card, team, EUR('2'))
assert pt.destination == stripe_account_carl.pk
payin, pt = self.make_payin_and_transfer(alice_card, team, EUR('1'))
assert pt.destination == stripe_account_bob.pk
payin, pt = self.make_payin_and_transfer(alice_card, team, EUR('4'))
assert pt.destination == stripe_account_carl.pk
payin, pt = self.make_payin_and_transfer(alice_card, team, EUR('10'))
assert pt.destination == stripe_account_carl.pk
payin, pt = self.make_payin_and_transfer(alice_card, team, EUR('2'))
assert pt.destination == stripe_account_bob.pk
def test_can_take_leftover(self):
team, alice, bob = self.make_team_of_two()
self.take_last_week(team, alice, EUR('0.01'))
actual = team.set_take_for(alice, EUR('200.00'), team)
assert actual == 100
def test_can_take_any_amount_when_takes_were_all_zero_last_week(self):
team, alice, bob = self.make_team_of_two()
self.take_last_week(team, alice, EUR('0.00'))
self.take_last_week(team, bob, EUR('0.00'))
actual = team.set_take_for(alice, EUR('222.00'), team)
assert actual == 222
def test_if_last_week_is_less_than_one_can_increase_to_one(self):
team, alice, bob = self.make_team_of_two()
self.warbucks.set_tip_to(team, EUR('0.50'))
self.take_last_week(team, alice, EUR('0.01'))
actual = team.set_take_for(alice, EUR('42.00'), team)
assert actual == 1
def test_update_cached_amounts(self):
team = self.make_participant('team', kind='group')
alice = self.make_participant('alice')
alice_card = self.upsert_route(alice, 'stripe-card')
bob = self.make_participant('bob')
carl = self.make_participant('carl')
carl_card = self.upsert_route(carl, 'stripe-card')
dana = self.make_participant('dana')
emma = Participant.make_stub(username='******')
team2 = self.make_participant('team2', kind='group')
team2.add_member(dana)
alice.set_tip_to(dana, EUR('3.00'))
self.make_payin_and_transfer(alice_card, dana, EUR('30.00'))
alice.set_tip_to(bob, EUR('6.00'))
self.make_payin_and_transfer(alice_card, bob, EUR('60.00'))
alice.set_tip_to(emma, EUR('0.50'))
alice.set_tip_to(team, EUR('1.20'))
alice.set_tip_to(team2, EUR('0.49'))
self.make_payin_and_transfer(alice_card, team2, EUR('4.90'))
bob.set_tip_to(alice, EUR('5.00'))
team.set_take_for(bob, EUR('1.00'), team)
self.make_payin_and_transfer(alice_card, team, EUR('12.00'))
bob.set_tip_to(dana, EUR('2.00')) # funded by bob's take
bob.set_tip_to(emma, EUR('7.00')) # not funded, insufficient receiving
carl.set_tip_to(dana, EUR('2.08')) # not funded, insufficient balance
self.make_payin_and_transfer(carl_card, dana, EUR('1.56'))
def check():
alice = Participant.from_username('alice')
bob = Participant.from_username('bob')
carl = Participant.from_username('carl')
dana = Participant.from_username('dana')
emma = Participant.from_username('emma')
assert alice.giving == EUR('10.69')
assert alice.receiving == EUR('0.00')
assert alice.npatrons == 0
assert alice.nteampatrons == 0
assert bob.giving == EUR('0.00')
assert bob.taking == EUR('1.00')
assert bob.receiving == EUR('7.00')
assert bob.npatrons == 1
assert bob.nteampatrons == 1
assert carl.giving == EUR('0.00')
assert carl.receiving == EUR('0.00')
assert carl.npatrons == 0
assert carl.nteampatrons == 0
assert dana.receiving == EUR('3.49')
assert dana.npatrons == 1
assert dana.nteampatrons == 1
assert emma.receiving == EUR('0.50')
assert emma.npatrons == 1
assert emma.nteampatrons == 0
funded_tips = self.db.all(
"SELECT amount FROM tips WHERE is_funded ORDER BY id")
assert funded_tips == [3, 6, 0.5, EUR('1.20'), EUR('0.49')]
team = Participant.from_username('team')
assert team.receiving == EUR('1.20')
assert team.npatrons == 1
assert team.leftover == EUR('0.20')
team2 = Participant.from_username('team2')
assert team2.receiving == EUR('0.49')
assert team2.npatrons == 1
assert team2.leftover == EUR('0.00')
janet = self.janet.refetch()
assert janet.giving == 0
assert janet.receiving == 0
assert janet.taking == 0
assert janet.npatrons == 0
assert janet.nteampatrons == 0
# Pre-test check
check()
# Check that update_cached_amounts doesn't mess anything up
Payday.start().update_cached_amounts()
check()
# Check that update_cached_amounts actually updates amounts
self.db.run("""
UPDATE tips t
SET is_funded = true
FROM participants p
WHERE p.id = t.tippee
AND p.mangopay_user_id IS NOT NULL;
UPDATE participants
SET giving = (10000,'EUR')
, taking = (10000,'EUR')
WHERE mangopay_user_id IS NOT NULL;
UPDATE participants
SET npatrons = 10000
, receiving = (10000,'EUR')
WHERE status = 'active';
""")
Payday.start().update_cached_amounts()
check()
# Check that the update methods of Participant concur
for p in self.db.all("SELECT p.*::participants FROM participants p"):
p.update_receiving()
p.update_giving()
check()
def test_close_raises_for_unknown_disbursement_strategy(self):
alice = self.make_participant('alice', balance=EUR('0.00'))
with pytest.raises(alice.UnknownDisbursementStrategy):
alice.close('cheese')
def test_get_end_of_period_balances(self):
make_history(self)
today = get_start_of_current_utc_day()
period_end = today.replace(month=1, day=1)
balances = get_end_of_period_balances(self.db, self.alice, period_end, today)
assert balances == EUR('10.00')
def check():
alice = Participant.from_username('alice')
bob = Participant.from_username('bob')
carl = Participant.from_username('carl')
dana = Participant.from_username('dana')
emma = Participant.from_username('emma')
assert alice.giving == EUR('10.69')
assert alice.receiving == EUR('0.00')
assert alice.npatrons == 0
assert alice.nteampatrons == 0
assert bob.giving == EUR('0.00')
assert bob.taking == EUR('1.00')
assert bob.receiving == EUR('7.00')
assert bob.npatrons == 1
assert bob.nteampatrons == 1
assert carl.giving == EUR('0.00')
assert carl.receiving == EUR('0.00')
assert carl.npatrons == 0
assert carl.nteampatrons == 0
assert dana.receiving == EUR('3.49')
assert dana.npatrons == 1
assert dana.nteampatrons == 1
assert emma.receiving == EUR('0.50')
assert emma.npatrons == 1
assert emma.nteampatrons == 0
funded_tips = self.db.all(
"SELECT amount FROM tips WHERE is_funded ORDER BY id")
assert funded_tips == [3, 6, 0.5, EUR('1.20'), EUR('0.49')]
team = Participant.from_username('team')
assert team.receiving == EUR('1.20')
assert team.npatrons == 1
assert team.leftover == EUR('0.20')
team2 = Participant.from_username('team2')
assert team2.receiving == EUR('0.49')
assert team2.npatrons == 1
assert team2.leftover == EUR('0.00')
janet = self.janet.refetch()
assert janet.giving == 0
assert janet.receiving == 0
assert janet.taking == 0
assert janet.npatrons == 0
assert janet.nteampatrons == 0
def test_iter_payday_events(self):
now = datetime.now()
Payday.start().run()
team = self.make_participant('team', kind='group')
alice = self.make_participant('alice')
self.make_exchange('mango-cc', 10000, 0, alice)
self.make_exchange('mango-cc', -5000, 0, alice)
self.db.run("""
UPDATE exchanges
SET timestamp = "timestamp" - interval '1 week'
""")
bob = self.make_participant('bob')
carl = self.make_participant('carl')
david = self.make_participant('david')
self.make_exchange('mango-cc', 10000, 0, david)
david.set_tip_to(team, EUR('1.00'))
team.set_take_for(bob, EUR('1.00'), team)
alice.set_tip_to(bob, EUR('5.00'))
assert bob.balance == 0
for i in range(2):
Payday.start().run()
self.db.run("""
UPDATE exchanges
SET timestamp = "timestamp" - interval '1 week';
UPDATE paydays
SET ts_start = ts_start - interval '1 week'
, ts_end = ts_end - interval '1 week';
UPDATE transfers
SET timestamp = "timestamp" - interval '1 week';
""")
bob = Participant.from_id(bob.id)
assert bob.balance == 12
Payday().start()
# Make sure events are all in the same year
delta = '%s days' % (364 - (now - datetime(now.year, 1, 1)).days)
self.db.run("""
UPDATE exchanges
SET timestamp = "timestamp" + interval %(delta)s;
UPDATE paydays
SET ts_start = ts_start + interval %(delta)s;
UPDATE paydays
SET ts_end = ts_end + interval %(delta)s
WHERE ts_end >= ts_start;
UPDATE transfers
SET timestamp = "timestamp" + interval %(delta)s;
""", dict(delta=delta))
events = list(iter_payday_events(self.db, bob, now.year))
assert len(events) == 9
assert events[0]['kind'] == 'totals'
assert not events[0]['regular_donations']['sent']
assert events[0]['regular_donations']['received'].eur == 12
assert events[1]['kind'] == 'day-open'
assert events[1]['payday_number'] == 3
assert events[2]['balances'].eur == 12
assert events[-1]['kind'] == 'day-close'
assert events[-1]['balances'].eur == 0
alice = Participant.from_id(alice.id)
assert alice.balance == 4990
events = list(iter_payday_events(self.db, alice, now.year))
assert events[0]['regular_donations']['sent'].eur == 10
assert len(events) == 11
carl = Participant.from_id(carl.id)
assert carl.balance == 0
events = list(iter_payday_events(self.db, carl, now.year))
assert len(events) == 0
def test_payday_handles_paid_in_advance(self):
self.make_exchange('mango-cc', EUR('2.00'), 0, self.janet)
self.janet.set_tip_to(self.david, EUR('0.60'))
team = self.make_participant('team', kind='group')
team.set_take_for(self.homer, EUR('0.40'), team)
self.janet.set_tip_to(team, EUR('0.40'))
self.janet.distribute_balances_to_donees()
self.db.run(
"UPDATE participants SET payment_providers = 1") # dirty trick
# Preliminary checks
janet = self.janet.refetch()
assert janet.balance == 0
tips = self.db.all(
"""
SELECT *
FROM current_tips
WHERE tipper = %s
ORDER BY id
""", (janet.id, ))
assert len(tips) == 2
assert tips[0].paid_in_advance == EUR('1.20')
assert tips[1].paid_in_advance == EUR('0.80')
transfers = self.db.all("SELECT * FROM transfers ORDER BY id")
assert len(transfers) == 2
assert transfers[0].amount == EUR('1.20')
assert transfers[0].context == 'tip-in-advance'
assert transfers[1].amount == EUR('0.80')
assert transfers[1].context == 'take-in-advance'
# Now run a payday and check the results
Payday.start().run()
tips = self.db.all(
"""
SELECT *
FROM current_tips
WHERE tipper = %s
ORDER BY id
""", (janet.id, ))
assert len(tips) == 2
assert tips[0].paid_in_advance == EUR('0.60')
assert tips[1].paid_in_advance == EUR('0.40')
transfers = self.db.all("SELECT * FROM transfers ORDER BY id")
assert len(transfers) == 4
emails = self.get_emails()
assert len(emails) == 2
assert emails[0]['to'][0] == 'david <%s>' % self.david.email
assert '0.60' in emails[0]['subject']
assert emails[1]['to'][0] == 'homer <%s>' % self.homer.email
assert '0.40' in emails[1]['text']
# Now run a second payday and check the results again
self.db.run("UPDATE notifications SET ts = ts - interval '1 week'")
Payday.start().run()
tips = self.db.all(
"""
SELECT *
FROM current_tips
WHERE tipper = %s
ORDER BY id
""", (janet.id, ))
assert len(tips) == 2
assert not tips[0].paid_in_advance
assert not tips[1].paid_in_advance
transfers = self.db.all("SELECT * FROM transfers ORDER BY id")
assert len(transfers) == 6
emails = self.get_emails()
assert len(emails) == 3
assert emails[0]['to'][0] == 'david <%s>' % self.david.email
assert '0.60' in emails[0]['subject']
assert emails[1]['to'][0] == 'homer <%s>' % self.homer.email
assert '0.40' in emails[1]['text']
assert emails[2]['to'][0] == 'janet <%s>' % self.janet.email
assert 'renew your donation' in emails[2]['subject']
assert '2 donations' in emails[2]['text']
def test_stt_works_for_yearly_donations(self):
alice = self.make_participant('alice', balance=EUR(100))
bob = self.make_participant('bob')
t = alice.set_tip_to(bob, EUR('104'), 'yearly')
assert t['amount'] == 2
def test_wellfunded_team(self):
"""
This tests two properties:
- takes are maximums
- donors all pay their share, the first donor doesn't pay everything
"""
team = self.make_participant('team', kind='group')
alice = self.make_participant('alice')
team.set_take_for(alice, EUR('0.79'), team)
bob = self.make_participant('bob')
team.set_take_for(bob, EUR('0.21'), team)
charlie = self.make_participant('charlie', balance=EUR(10))
charlie.set_tip_to(team, EUR('5.00'))
dan = self.make_participant('dan', balance=EUR(10))
dan.set_tip_to(team, EUR('5.00'))
Payday.start().run()
d = dict(self.db.all("SELECT username, balance FROM participants"))
expected = {
'alice': EUR('0.79'),
'bob': EUR('0.21'),
'charlie': EUR('9.5'),
'dan': EUR('9.5'),
'team': EUR('0.00'),
}
assert d == expected
def test_stt_doesnt_allow_just_any_ole_amount(self):
alice = self.make_participant('alice', balance=EUR(100))
bob = self.make_participant('bob')
with pytest.raises(BadAmount):
alice.set_tip_to(bob, EUR('1000.00'))
def test_wellfunded_team_with_early_donor(self):
team = self.make_participant('team', kind='group')
alice = self.make_participant('alice')
team.set_take_for(alice, EUR('0.79'), team)
bob = self.make_participant('bob')
team.set_take_for(bob, EUR('0.21'), team)
charlie = self.make_participant('charlie', balance=EUR(10))
charlie.set_tip_to(team, EUR('2.00'))
print("> Step 1: three weeks of donations from charlie only")
print()
for i in range(3):
Payday.start().run(recompute_stats=0, update_cached_amounts=False)
print()
d = dict(self.db.all("SELECT username, balance FROM participants"))
expected = {
'alice': EUR('0.79') * 3,
'bob': EUR('0.21') * 3,
'charlie': EUR('7.00'),
'team': EUR('0.00'),
}
assert d == expected
print(
"> Step 2: dan joins the party, charlie's donation is automatically "
"reduced while dan catches up")
print()
dan = self.make_participant('dan', balance=EUR(10))
dan.set_tip_to(team, EUR('2.00'))
for i in range(6):
Payday.start().run(recompute_stats=0, update_cached_amounts=False)
print()
d = dict(self.db.all("SELECT username, balance FROM participants"))
expected = {
'alice': EUR('0.79') * 9,
'bob': EUR('0.21') * 9,
'charlie': EUR('5.50'),
'dan': EUR('5.50'),
'team': EUR('0.00'),
}
assert d == expected
print(
"> Step 3: dan has caught up with charlie, they will now both give 0.50"
)
print()
for i in range(3):
Payday.start().run(recompute_stats=0, update_cached_amounts=False)
print()
d = dict(self.db.all("SELECT username, balance FROM participants"))
expected = {
'alice': EUR('0.79') * 12,
'bob': EUR('0.21') * 12,
'charlie': EUR('4.00'),
'dan': EUR('4.00'),
'team': EUR('0.00'),
}
assert d == expected
def test_only_funded_tips_count(self):
alice = self.make_participant('alice', balance=EUR(100))
bob = self.make_participant('bob')
carl = self.make_participant('carl', last_bill_result="Fail!")
dana = self.make_participant('dana')
alice.set_tip_to(dana, EUR('3.00'))
alice.set_tip_to(bob, EUR('6.00'))
bob.set_tip_to(alice, EUR('5.00'))
bob.set_tip_to(dana, EUR('2.00'))
carl.set_tip_to(dana, EUR('2.08'))
assert alice.giving == EUR('9.00')
assert alice.receiving == EUR('5.00')
assert bob.giving == EUR('5.00')
assert bob.receiving == EUR('6.00')
assert carl.giving == EUR('0.00')
assert carl.receiving == EUR('0.00')
assert dana.receiving == EUR('3.00')
assert dana.npatrons == 1
funded_tips = self.db.all(
"SELECT amount FROM tips WHERE is_funded ORDER BY id")
assert funded_tips == [3, 6, 5]
def test_wellfunded_team_with_two_early_donors_and_low_amounts(self):
team = self.make_participant('team', kind='group')
alice = self.make_participant('alice')
team.set_take_for(alice, EUR('0.01'), team)
bob = self.make_participant('bob')
team.set_take_for(bob, EUR('0.01'), team)
charlie = self.make_participant('charlie', balance=EUR(10))
charlie.set_tip_to(team, EUR('0.02'))
dan = self.make_participant('dan', balance=EUR(10))
dan.set_tip_to(team, EUR('0.02'))
print("> Step 1: three weeks of donations from early donors")
print()
for i in range(3):
Payday.start().run(recompute_stats=0, update_cached_amounts=False)
print()
d = dict(self.db.all("SELECT username, balance FROM participants"))
expected = {
'alice': EUR('0.01') * 3,
'bob': EUR('0.01') * 3,
'charlie': EUR('9.97'),
'dan': EUR('9.97'),
'team': EUR('0.00'),
}
assert d == expected
print("> Step 2: a new donor appears, the contributions of the early "
"donors automatically decrease while the new donor catches up")
print()
emma = self.make_participant('emma', balance=EUR(10))
emma.set_tip_to(team, EUR('0.02'))
for i in range(6):
Payday.start().run(recompute_stats=0, update_cached_amounts=False)
print()
d = dict(self.db.all("SELECT username, balance FROM participants"))
expected = {
'alice': EUR('0.01') * 9,
'bob': EUR('0.01') * 9,
'charlie': EUR('9.94'),
'dan': EUR('9.94'),
'emma': EUR('9.94'),
'team': EUR('0.00'),
}
assert d == expected
def test_cant_pledge_to_locked_accounts(self):
alice = self.make_participant('alice', balance=EUR(100))
bob = self.make_stub(goal=EUR(-1))
with self.assertRaises(UserDoesntAcceptTips):
alice.set_tip_to(bob, EUR('3.00'))
def test_wellfunded_team_with_early_donor_and_small_leftover(self):
team = self.make_participant('team', kind='group')
alice = self.make_participant('alice')
team.set_take_for(alice, EUR('0.50'), team)
bob = self.make_participant('bob')
team.set_take_for(bob, EUR('0.50'), team)
charlie = self.make_participant('charlie', balance=EUR(10))
charlie.set_tip_to(team, EUR('0.52'))
print("> Step 1: three weeks of donations from early donor")
print()
for i in range(3):
Payday.start().run(recompute_stats=0, update_cached_amounts=False)
print()
d = dict(self.db.all("SELECT username, balance FROM participants"))
expected = {
'alice': EUR('0.26') * 3,
'bob': EUR('0.26') * 3,
'charlie': EUR('8.44'),
'team': EUR('0.00'),
}
assert d == expected
print("> Step 2: a new donor appears, the contribution of the early "
"donor automatically decreases while the new donor catches up, "
"but the leftover is small so the adjustments are limited")
print()
dan = self.make_participant('dan', balance=EUR(10))
dan.set_tip_to(team, EUR('0.52'))
for i in range(3):
Payday.start().run(recompute_stats=0, update_cached_amounts=False)
print()
d = dict(self.db.all("SELECT username, balance FROM participants"))
expected = {
'alice': EUR('0.26') * 3 + EUR('0.50') * 3,
'bob': EUR('0.26') * 3 + EUR('0.50') * 3,
'charlie': EUR('7.00'),
'dan': EUR('8.44'),
'team': EUR('0.00'),
}
assert d == expected
def test_cross_tip_doesnt_become_self_tip(self):
alice = self.make_participant('alice', elsewhere='twitter')
bob = self.make_elsewhere('twitter', 2, 'bob')
alice.set_tip_to(bob.participant, EUR('1.00'))
alice.take_over(bob, have_confirmation=True)
self.db.self_check()
def test_take_can_double_but_not_a_penny_more(self):
team, alice, bob = self.make_team_of_two()
self.warbucks.set_tip_to(team, EUR('20'))
self.take_last_week(team, alice, EUR('40.00'))
actual = team.set_take_for(alice, EUR('80.01'), alice)
assert actual == 80
