2026-11-16 13:23:29 +01:00
|
|
|
"""A3 — simulated ledger with idempotency: WEB-22, WEB-23, ADR-59, ARC-72, DAT-78, RND-21, BET-07, BET-20."""
|
|
|
|
|
|
|
|
|
|
import json
|
|
|
|
|
import os
|
|
|
|
|
import subprocess
|
|
|
|
|
import sys
|
|
|
|
|
from datetime import timedelta
|
|
|
|
|
from pathlib import Path
|
|
|
|
|
from uuid import uuid4
|
|
|
|
|
|
|
|
|
|
import pytest
|
|
|
|
|
from django.contrib.auth import get_user_model
|
|
|
|
|
from django.utils import timezone
|
|
|
|
|
|
|
|
|
|
from apps.lottery import ledger as ledger_module
|
|
|
|
|
from apps.lottery.balances import balance_of
|
|
|
|
|
from apps.lottery.errors import LedgerError
|
|
|
|
|
from apps.lottery.ledger import SimulatedLedger, get_ledger
|
|
|
|
|
from apps.lottery.models import (
|
|
|
|
|
AuditEntry,
|
|
|
|
|
ChainTransaction,
|
|
|
|
|
LotteryConfig,
|
|
|
|
|
Movement,
|
|
|
|
|
Participation,
|
|
|
|
|
Round,
|
|
|
|
|
)
|
|
|
|
|
from apps.lottery.rules import winner_share
|
|
|
|
|
|
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
|
|
|
PLM = 100_000_000
|
|
|
|
|
BET = 10 * PLM
|
|
|
|
|
|
|
|
|
|
pytestmark = pytest.mark.django_db
|
|
|
|
|
ledger = SimulatedLedger()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def make_user(name="mario"):
|
|
|
|
|
return get_user_model().objects.create_user(name, password="x" * 12)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def open_round(**kwargs):
|
|
|
|
|
return Round.objects.create(**kwargs)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def funded(name="mario", amount=BET):
|
|
|
|
|
user = make_user(name)
|
|
|
|
|
ledger.deposit(user, amount)
|
|
|
|
|
return user
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def code_of(call) -> str:
|
|
|
|
|
with pytest.raises(LedgerError) as caught:
|
|
|
|
|
call()
|
|
|
|
|
return caught.value.code
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def audit_actions():
|
|
|
|
|
return list(AuditEntry.objects.order_by("id").values_list("action", flat=True))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# --- deposits ----------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_confirmed_deposit_is_spendable():
|
|
|
|
|
user = make_user()
|
|
|
|
|
result = ledger.deposit(user, 25 * PLM)
|
|
|
|
|
assert not result.replayed
|
|
|
|
|
assert balance_of(user).spendable_sats == 25 * PLM and balance_of(user).incoming_sats == 0
|
|
|
|
|
assert audit_actions() == ["deposit_credited"]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_pending_deposit_is_incoming_not_spendable():
|
|
|
|
|
"""WEB-21: funds in confirmation are shown apart and cannot be spent."""
|
|
|
|
|
user = make_user()
|
|
|
|
|
movement = ledger.deposit(user, BET, confirmed=False).obj
|
|
|
|
|
assert (balance_of(user).spendable_sats, balance_of(user).incoming_sats) == (0, BET)
|
|
|
|
|
ledger.confirm_deposit(movement)
|
|
|
|
|
assert (balance_of(user).spendable_sats, balance_of(user).incoming_sats) == (BET, 0)
|
|
|
|
|
ledger.confirm_deposit(movement) # again: nothing changes
|
|
|
|
|
assert balance_of(user).spendable_sats == BET
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("amount", [0, -5, 1.5, "10", True, None])
|
|
|
|
|
def test_deposit_refuses_a_bad_amount(amount):
|
|
|
|
|
assert code_of(lambda: ledger.deposit(make_user(), amount)) == "invalid_amount"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_the_same_deposit_request_is_one_deposit():
|
|
|
|
|
"""WEB-23."""
|
|
|
|
|
user, key = make_user(), uuid4()
|
|
|
|
|
first = ledger.deposit(user, BET, request_id=key)
|
|
|
|
|
second = ledger.deposit(user, BET, request_id=key)
|
|
|
|
|
assert (first.replayed, second.replayed) == (False, True) and first.obj.pk == second.obj.pk
|
|
|
|
|
assert Movement.objects.count() == 1 and balance_of(user).spendable_sats == BET
|
|
|
|
|
assert audit_actions() == ["deposit_credited"] # the replay left no second trace
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_deposit_key_reused_for_a_different_amount_is_an_error():
|
|
|
|
|
user, key = make_user(), uuid4()
|
|
|
|
|
ledger.deposit(user, BET, request_id=key)
|
|
|
|
|
assert code_of(lambda: ledger.deposit(user, BET + 1, request_id=key)) == "idempotency_conflict"
|
|
|
|
|
assert Movement.objects.count() == 1
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_failed_operation_leaves_nothing_behind():
|
|
|
|
|
"""ARC-72: the write and its audit row commit together or not at all."""
|
|
|
|
|
user = make_user()
|
|
|
|
|
assert code_of(lambda: ledger.deposit(user, 0)) == "invalid_amount"
|
|
|
|
|
assert Movement.objects.count() == 0 and AuditEntry.objects.count() == 0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# --- placing a bet -----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_bet_reserves_the_funds_and_waits_for_confirmation():
|
|
|
|
|
user, round_ = funded(), open_round()
|
|
|
|
|
result = ledger.place_bet(user, round_.pk, request_id=uuid4())
|
|
|
|
|
bet = result.obj
|
|
|
|
|
assert not result.replayed
|
|
|
|
|
assert (bet.status, bet.bet_amount_sats, bet.round_id) == ("pending", BET, round_.pk)
|
|
|
|
|
movement = Movement.objects.get(kind="bet")
|
|
|
|
|
assert (movement.amount_sats, movement.status, movement.participation_id) == (-BET, "pending", bet.pk)
|
|
|
|
|
chain = ChainTransaction.objects.get(kind="bet")
|
|
|
|
|
assert chain.status == "pending" and len(chain.current_txid) == 64 and bet.bet_txid == chain.current_txid
|
|
|
|
|
assert balance_of(user).spendable_sats == 0 # reserved at once
|
|
|
|
|
assert audit_actions() == ["deposit_credited", "bet_placed"]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_the_same_bet_request_is_one_bet():
|
|
|
|
|
"""WEB-23: a double send is one logical operation, charged once."""
|
|
|
|
|
user, round_, key = funded(), open_round(), uuid4()
|
|
|
|
|
first = ledger.place_bet(user, round_.pk, request_id=key)
|
|
|
|
|
second = ledger.place_bet(user, round_.pk, request_id=key)
|
|
|
|
|
assert (first.replayed, second.replayed) == (False, True) and first.obj.pk == second.obj.pk
|
|
|
|
|
assert Participation.objects.count() == 1 and Movement.objects.filter(kind="bet").count() == 1
|
|
|
|
|
assert ChainTransaction.objects.count() == 1
|
|
|
|
|
assert audit_actions().count("bet_placed") == 1
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_replay_still_answers_after_the_round_has_closed_for_bets():
|
|
|
|
|
user, round_, key = funded(), open_round(), uuid4()
|
|
|
|
|
first = ledger.place_bet(user, round_.pk, request_id=key)
|
|
|
|
|
Round.objects.filter(pk=round_.pk).update(status="closing")
|
|
|
|
|
assert ledger.place_bet(user, round_.pk, request_id=key).obj.pk == first.obj.pk
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_bet_key_reused_for_another_round_or_kind_is_an_error():
|
|
|
|
|
user, key = funded(amount=2 * BET), uuid4()
|
|
|
|
|
first = open_round()
|
|
|
|
|
ledger.place_bet(user, first.pk, request_id=key)
|
|
|
|
|
first.status, first.closed_at = "closed", timezone.now()
|
|
|
|
|
first.save()
|
|
|
|
|
second = open_round()
|
|
|
|
|
assert code_of(lambda: ledger.place_bet(user, second.pk, request_id=key)) == "idempotency_conflict"
|
|
|
|
|
deposit_key = uuid4()
|
|
|
|
|
ledger.deposit(user, PLM, request_id=deposit_key)
|
|
|
|
|
assert code_of(lambda: ledger.place_bet(user, second.pk, request_id=deposit_key)) == "idempotency_conflict"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_bet_needs_an_idempotency_key():
|
|
|
|
|
user, round_ = funded(), open_round()
|
|
|
|
|
assert code_of(lambda: ledger.place_bet(user, round_.pk, request_id=None)) == "missing_request_id"
|
|
|
|
|
assert code_of(lambda: ledger.place_bet(user, round_.pk, request_id="not-a-uuid")) == "missing_request_id"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_the_server_charges_the_rounds_own_quota():
|
|
|
|
|
"""ADR-10: an edit of the config after the round opened does not change what it costs."""
|
|
|
|
|
user, round_ = funded(amount=BET), open_round(bet_amount_sats=BET)
|
|
|
|
|
config = LotteryConfig.get()
|
|
|
|
|
config.bet_amount_sats = 20 * PLM
|
|
|
|
|
config.save()
|
|
|
|
|
assert ledger.place_bet(user, round_.pk, request_id=uuid4()).obj.bet_amount_sats == BET
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_insufficient_funds_are_refused_with_the_required_amount():
|
|
|
|
|
user, round_ = funded(amount=BET - 1), open_round()
|
|
|
|
|
with pytest.raises(LedgerError) as caught:
|
|
|
|
|
ledger.place_bet(user, round_.pk, request_id=uuid4())
|
|
|
|
|
assert caught.value.code == "insufficient_balance" and caught.value.params == {"required_sats": BET}
|
|
|
|
|
assert Participation.objects.count() == 0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_funds_still_in_confirmation_ask_to_wait():
|
|
|
|
|
"""BET-07: the balance on screen covers the bet, but it is not confirmed yet."""
|
|
|
|
|
user, round_ = make_user(), open_round()
|
|
|
|
|
ledger.deposit(user, BET, confirmed=False)
|
|
|
|
|
with pytest.raises(LedgerError) as caught:
|
|
|
|
|
ledger.place_bet(user, round_.pk, request_id=uuid4())
|
|
|
|
|
assert caught.value.code == "balance_pending_confirmation" and caught.value.params == {"pending_sats": BET}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_one_bet_per_player_per_round_even_with_another_key():
|
|
|
|
|
user, round_ = funded(amount=2 * BET), open_round()
|
|
|
|
|
ledger.place_bet(user, round_.pk, request_id=uuid4())
|
|
|
|
|
assert code_of(lambda: ledger.place_bet(user, round_.pk, request_id=uuid4())) == "already_betting"
|
|
|
|
|
assert balance_of(user).spendable_sats == BET # charged once
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_bets_are_refused_from_the_rounds_own_deadline():
|
|
|
|
|
"""ADR-23: the deadline decides, not the status the scheduler has not flipped yet."""
|
|
|
|
|
user = funded()
|
|
|
|
|
late = open_round(opened_at=timezone.now() - timedelta(seconds=601), duration_seconds=600)
|
|
|
|
|
assert code_of(lambda: ledger.place_bet(user, late.pk, request_id=uuid4())) == "round_closing"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("status", ["closing", "drawing", "paying_out"])
|
|
|
|
|
def test_bets_are_refused_once_the_round_leaves_open(status):
|
|
|
|
|
user, round_ = funded(), open_round(status=status)
|
|
|
|
|
assert code_of(lambda: ledger.place_bet(user, round_.pk, request_id=uuid4())) == "round_closing"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_no_round_open():
|
|
|
|
|
user = funded()
|
|
|
|
|
closed = open_round(status="closed", closed_at=timezone.now())
|
|
|
|
|
assert code_of(lambda: ledger.place_bet(user, closed.pk, request_id=uuid4())) == "no_round_open"
|
|
|
|
|
assert code_of(lambda: ledger.place_bet(user, 99999, request_id=uuid4())) == "no_round_open"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_suspended_bets_are_refused():
|
|
|
|
|
"""ADR-57: «Sospendi nuove puntate»."""
|
|
|
|
|
user, round_ = funded(), open_round()
|
|
|
|
|
config = LotteryConfig.get()
|
|
|
|
|
config.new_bets_suspended = True
|
|
|
|
|
config.save()
|
|
|
|
|
assert code_of(lambda: ledger.place_bet(user, round_.pk, request_id=uuid4())) == "bets_suspended"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_round_has_a_maximum_of_players(monkeypatch):
|
|
|
|
|
"""B-52, BET-20: refused before any money moves."""
|
|
|
|
|
monkeypatch.setattr(ledger_module, "MAX_PARTICIPANTS_PER_ROUND", 2)
|
|
|
|
|
round_ = open_round()
|
|
|
|
|
for name in ("a", "b"):
|
|
|
|
|
ledger.place_bet(funded(name), round_.pk, request_id=uuid4())
|
|
|
|
|
late = funded("c")
|
|
|
|
|
assert code_of(lambda: ledger.place_bet(late, round_.pk, request_id=uuid4())) == "round_full"
|
|
|
|
|
assert balance_of(late).spendable_sats == BET
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_round_stops_at_its_pool_cap():
|
|
|
|
|
"""BET-20: refused once the pool has reached the cap — it may exceed it by at most one bet."""
|
|
|
|
|
round_ = open_round(max_round_pool_sats=BET + 1)
|
|
|
|
|
ledger.place_bet(funded("a"), round_.pk, request_id=uuid4()) # pool 10 < cap
|
|
|
|
|
ledger.place_bet(funded("b"), round_.pk, request_id=uuid4()) # pool 20 >= cap now
|
|
|
|
|
assert code_of(lambda: ledger.place_bet(funded("c"), round_.pk, request_id=uuid4())) == "round_full"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# --- what happens to a bet afterwards ----------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def placed(name="mario"):
|
|
|
|
|
user, round_ = funded(name), Round.objects.filter(status="open").first() or open_round()
|
|
|
|
|
return user, ledger.place_bet(user, round_.pk, request_id=uuid4()).obj
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_confirming_a_bet_confirms_its_transaction_and_movement():
|
|
|
|
|
user, bet = placed()
|
|
|
|
|
confirmed = ledger.confirm_bet(bet)
|
|
|
|
|
assert confirmed.status == "confirmed" and confirmed.confirmed_at is not None
|
|
|
|
|
assert ChainTransaction.objects.get(kind="bet").status == "confirmed"
|
|
|
|
|
assert Movement.objects.get(kind="bet").status == "confirmed"
|
|
|
|
|
assert balance_of(user).spendable_sats == 0
|
|
|
|
|
ledger.confirm_bet(bet) # idempotent
|
|
|
|
|
assert audit_actions().count("bet_confirmed") == 1
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_rejected_bet_returns_the_funds_and_keeps_the_reason():
|
|
|
|
|
user, bet = placed()
|
|
|
|
|
ledger.reject_bet(bet, "refused by the network")
|
|
|
|
|
assert Participation.objects.get().status == "rejected"
|
|
|
|
|
chain = ChainTransaction.objects.get(kind="bet")
|
|
|
|
|
assert (chain.status, chain.failure_reason) == ("failed", "refused by the network")
|
|
|
|
|
assert balance_of(user).spendable_sats == BET
|
|
|
|
|
assert code_of(lambda: ledger.confirm_bet(bet)) == "invalid_state"
|
|
|
|
|
entry = AuditEntry.objects.get(action="bet_rejected")
|
|
|
|
|
assert entry.reason == "refused by the network"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_rejecting_or_excluding_needs_a_reason():
|
|
|
|
|
_, bet = placed()
|
|
|
|
|
assert code_of(lambda: ledger.reject_bet(bet, " ")) == "reason_required"
|
|
|
|
|
ledger.confirm_bet(bet)
|
|
|
|
|
assert code_of(lambda: ledger.exclude_bet(bet, "")) == "reason_required"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_confirmed_bet_cannot_be_rejected_and_a_pending_one_cannot_be_excluded():
|
|
|
|
|
_, first = placed("a")
|
|
|
|
|
assert code_of(lambda: ledger.exclude_bet(first, "gone")) == "invalid_state"
|
|
|
|
|
ledger.confirm_bet(first)
|
|
|
|
|
assert code_of(lambda: ledger.reject_bet(first, "late")) == "invalid_state"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_an_excluded_bet_is_refunded_once():
|
|
|
|
|
user, bet = placed()
|
|
|
|
|
ledger.confirm_bet(bet)
|
|
|
|
|
Participation.objects.filter(pk=bet.pk).update(draw_position=0)
|
|
|
|
|
ledger.exclude_bet(bet, "the bet is no longer on the chain")
|
|
|
|
|
excluded = Participation.objects.get()
|
|
|
|
|
assert (excluded.status, excluded.draw_position) == ("excluded", None)
|
|
|
|
|
assert balance_of(user).spendable_sats == BET
|
|
|
|
|
ledger.exclude_bet(bet, "again") # idempotent: no second refund
|
|
|
|
|
assert Movement.objects.filter(kind="refund").count() == 1 and balance_of(user).spendable_sats == BET
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# --- the payout --------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def paying_round(bets=3, bet_amount=BET):
|
|
|
|
|
"""A round in `paying_out` with `bets` confirmed participants; the first one won."""
|
|
|
|
|
round_ = open_round(bet_amount_sats=bet_amount)
|
|
|
|
|
users = []
|
|
|
|
|
for i in range(bets):
|
|
|
|
|
user = funded(f"p{i}", bet_amount)
|
|
|
|
|
users.append(user)
|
|
|
|
|
ledger.confirm_bet(ledger.place_bet(user, round_.pk, request_id=uuid4()).obj)
|
|
|
|
|
round_.status, round_.winner = Round.Status.PAYING_OUT, users[0]
|
|
|
|
|
round_.save()
|
|
|
|
|
return round_, users
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_the_pool_is_split_70_30_and_the_winner_is_credited():
|
|
|
|
|
"""RND-21."""
|
|
|
|
|
round_, users = paying_round(bets=3)
|
|
|
|
|
result = ledger.pay_winner(round_.pk)
|
|
|
|
|
round_.refresh_from_db()
|
|
|
|
|
assert (round_.pool_amount_sats, round_.winner_amount_sats, round_.fee_amount_sats) == (3 * BET, 21 * PLM, 9 * PLM)
|
|
|
|
|
assert round_.payout_transaction_id == result.obj.pk and result.obj.kind == "payout"
|
|
|
|
|
win = Movement.objects.get(kind="win")
|
|
|
|
|
assert (win.user, win.amount_sats, win.status) == (users[0], 21 * PLM, "pending")
|
|
|
|
|
assert balance_of(users[0]).incoming_sats == 21 * PLM # in confirmation, not spendable yet
|
|
|
|
|
ledger.confirm_payout(round_.pk)
|
|
|
|
|
assert balance_of(users[0]).spendable_sats == 21 * PLM and balance_of(users[0]).incoming_sats == 0
|
|
|
|
|
assert balance_of(users[1]).spendable_sats == 0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("pool", [1, 3, 10, 11, 99, 1000, 123_456_789])
|
|
|
|
|
def test_the_split_never_loses_or_invents_a_satoshi(pool):
|
|
|
|
|
"""RND-21: the rounding remainder goes to the platform; winner + fee == pool."""
|
|
|
|
|
winner = winner_share(pool)
|
|
|
|
|
assert winner == pool * 70 // 100 and 0 <= winner <= pool
|
|
|
|
|
assert winner + (pool - winner) == pool
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_the_rounding_remainder_goes_to_the_platform():
|
|
|
|
|
round_, _ = paying_round(bets=1, bet_amount=11)
|
|
|
|
|
ledger.pay_winner(round_.pk)
|
|
|
|
|
round_.refresh_from_db()
|
|
|
|
|
assert (round_.winner_amount_sats, round_.fee_amount_sats) == (7, 4) # 70% of 11 = 7.7 -> 7
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_round_is_paid_once():
|
|
|
|
|
round_, users = paying_round()
|
|
|
|
|
first, second = ledger.pay_winner(round_.pk), ledger.pay_winner(round_.pk)
|
|
|
|
|
assert (first.replayed, second.replayed) == (False, True) and first.obj.pk == second.obj.pk
|
|
|
|
|
assert Movement.objects.filter(kind="win").count() == 1
|
|
|
|
|
assert audit_actions().count("payout_created") == 1
|
|
|
|
|
ledger.confirm_payout(round_.pk)
|
|
|
|
|
ledger.confirm_payout(round_.pk)
|
|
|
|
|
assert audit_actions().count("payout_confirmed") == 1
|
|
|
|
|
assert balance_of(users[0]).spendable_sats == 21 * PLM
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_only_a_round_that_is_paying_out_can_be_paid():
|
|
|
|
|
round_, _ = paying_round()
|
|
|
|
|
Round.objects.filter(pk=round_.pk).update(status="drawing")
|
|
|
|
|
assert code_of(lambda: ledger.pay_winner(round_.pk)) == "round_not_paying_out"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_the_winner_must_be_a_confirmed_participant():
|
|
|
|
|
round_, _ = paying_round()
|
|
|
|
|
outsider = make_user("outsider")
|
|
|
|
|
Round.objects.filter(pk=round_.pk).update(winner=outsider)
|
|
|
|
|
assert code_of(lambda: ledger.pay_winner(round_.pk)) == "winner_not_a_participant"
|
|
|
|
|
Round.objects.filter(pk=round_.pk).update(winner=None)
|
|
|
|
|
assert code_of(lambda: ledger.pay_winner(round_.pk)) == "winner_not_a_participant"
|
|
|
|
|
assert Movement.objects.filter(kind="win").count() == 0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_payout_without_a_transaction_cannot_be_confirmed():
|
|
|
|
|
round_, _ = paying_round()
|
|
|
|
|
assert code_of(lambda: ledger.confirm_payout(round_.pk)) == "no_payout"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# --- conservation ------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_a_whole_round_conserves_the_money():
|
|
|
|
|
"""Deposits in == balances + the platform's share, after a full round."""
|
|
|
|
|
round_, users = paying_round(bets=4)
|
|
|
|
|
ledger.pay_winner(round_.pk)
|
|
|
|
|
ledger.confirm_payout(round_.pk)
|
|
|
|
|
round_.refresh_from_db()
|
|
|
|
|
held = sum(balance_of(u).spendable_sats for u in users)
|
|
|
|
|
deposited = sum(Movement.objects.filter(kind="deposit").values_list("amount_sats", flat=True))
|
|
|
|
|
assert held + round_.fee_amount_sats == deposited # nothing lost, nothing invented
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# --- configuration -----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _run_settings(**env):
|
|
|
|
|
clean = {"PATH": os.environ["PATH"], "PYTHONPATH": str(ROOT), "DJANGO_SECRET_KEY": "k" * 60, **env}
|
|
|
|
|
return subprocess.run([sys.executable, "-c", "import config.settings"], cwd=ROOT, env=clean,
|
|
|
|
|
capture_output=True, text=True)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_the_simulated_ledger_cannot_run_on_mainnet():
|
2026-11-16 15:38:29 +01:00
|
|
|
"""ADR-59; a real ledger on mainnet also needs the explicit confirmation (ADR-58, B2)."""
|
|
|
|
|
result = _run_settings(PLM_NETWORK="mainnet", PLM_MAINNET_CONFIRMED="yes")
|
2026-11-16 13:23:29 +01:00
|
|
|
assert result.returncode != 0 and "simulated ledger" in result.stderr
|
2026-11-16 15:38:29 +01:00
|
|
|
assert _run_settings(PLM_NETWORK="mainnet", LEDGER_BACKEND="chain", PLM_MAINNET_CONFIRMED="yes").returncode == 0
|
2026-11-16 13:23:29 +01:00
|
|
|
assert _run_settings().returncode == 0 # the default: regtest + simulated
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.mark.parametrize("env", [{"PLM_NETWORK": "testnet"}, {"LEDGER_BACKEND": "magic"}])
|
|
|
|
|
def test_unknown_network_or_ledger_is_refused(env):
|
|
|
|
|
assert _run_settings(**env).returncode != 0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_get_ledger_follows_the_configuration(settings):
|
|
|
|
|
assert isinstance(get_ledger(), SimulatedLedger)
|
|
|
|
|
settings.LEDGER_BACKEND = "chain"
|
|
|
|
|
with pytest.raises(NotImplementedError):
|
|
|
|
|
get_ledger()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# --- real concurrency: separate processes on one SQLite file -----------------------------------
|
|
|
|
|
|
|
|
|
|
_WORKER = """
|
|
|
|
|
import json, os, sys, uuid
|
|
|
|
|
import django
|
|
|
|
|
django.setup()
|
|
|
|
|
from django.contrib.auth import get_user_model
|
|
|
|
|
from apps.lottery.errors import LedgerError
|
|
|
|
|
from apps.lottery.ledger import get_ledger
|
|
|
|
|
user = get_user_model().objects.get(username=sys.argv[1])
|
|
|
|
|
try:
|
|
|
|
|
result = get_ledger().place_bet(user, int(sys.argv[2]), request_id=uuid.UUID(sys.argv[3]))
|
|
|
|
|
print(json.dumps({"ok": result.obj.pk, "replayed": result.replayed}))
|
|
|
|
|
except LedgerError as exc:
|
|
|
|
|
print(json.dumps({"err": exc.code}))
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
_SETUP = """
|
|
|
|
|
import django
|
|
|
|
|
django.setup()
|
|
|
|
|
from django.contrib.auth import get_user_model
|
|
|
|
|
from apps.lottery.ledger import get_ledger
|
|
|
|
|
from apps.lottery.models import Round
|
|
|
|
|
user = get_user_model().objects.create_user("mario", password="x" * 12)
|
|
|
|
|
get_ledger().deposit(user, 10 * 10**8)
|
|
|
|
|
print(Round.objects.create().pk)
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@pytest.fixture
|
|
|
|
|
def shared_db(tmp_path):
|
|
|
|
|
env = {"PATH": os.environ["PATH"], "PYTHONPATH": str(ROOT), "DJANGO_SECRET_KEY": "k" * 60,
|
|
|
|
|
"DJANGO_DB_PATH": str(tmp_path / "site.sqlite3"), "DJANGO_SETTINGS_MODULE": "config.settings"}
|
|
|
|
|
subprocess.run([sys.executable, "manage.py", "migrate", "--noinput", "-v", "0"], cwd=ROOT, env=env, check=True)
|
|
|
|
|
round_id = subprocess.run([sys.executable, "-c", _SETUP], cwd=ROOT, env=env, check=True,
|
|
|
|
|
capture_output=True, text=True).stdout.strip()
|
|
|
|
|
return env, int(round_id)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _race(env, round_id, keys):
|
|
|
|
|
procs = [subprocess.Popen([sys.executable, "-c", _WORKER, "mario", str(round_id), key], cwd=ROOT, env=env,
|
|
|
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) for key in keys]
|
|
|
|
|
outputs = [p.communicate(timeout=120) for p in procs]
|
|
|
|
|
assert all(p.returncode == 0 for p in procs), [o[1] for o in outputs]
|
|
|
|
|
return [json.loads(o[0].strip().splitlines()[-1]) for o in outputs]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_concurrent_requests_with_the_same_key_make_one_bet(shared_db):
|
|
|
|
|
"""ARC-72, WEB-23: six processes send the same request at once; one bet, one charge."""
|
|
|
|
|
env, round_id = shared_db
|
|
|
|
|
results = _race(env, round_id, ["3f1c6a52-0000-4000-8000-000000000001"] * 6)
|
|
|
|
|
assert all("ok" in r for r in results) and len({r["ok"] for r in results}) == 1
|
|
|
|
|
assert sorted(r["replayed"] for r in results) == [False] + [True] * 5
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_concurrent_requests_with_different_keys_make_one_bet(shared_db):
|
|
|
|
|
"""ARC-72: six different requests from one player race for one place; exactly one wins."""
|
|
|
|
|
env, round_id = shared_db
|
|
|
|
|
results = _race(env, round_id, [str(uuid4()) for _ in range(6)])
|
|
|
|
|
assert sum("ok" in r for r in results) == 1
|
|
|
|
|
assert [r["err"] for r in results if "err" in r] == ["already_betting"] * 5
|