aboutsummaryrefslogtreecommitdiff
path: root/tests/http/test_wallet.py
blob: 4ba5ba65717b02026859655b48e8b8b08434cb32 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
from urllib.parse import parse_qs, urlparse
from uuid import uuid4

import pytest
from generalresearch.redis_helper import RedisConfig
from httpx import AsyncClient

from jb.api.auth import SESSION_COOKIE_NAME, create_session
from jb.api.cashout_token import CASHOUT_TOKEN_PREFIX
from jb.api.magic_token import redis_token_key
from jb.dependencies import get_gr_api_manager
from jb.main import app
from jb.models.auth import User
from jb.models.wallet import PendingCashout


class FakeGRApiManager:
    def __init__(self, user: User):
        self.user = user

    def get_user(self, product_user_id: str) -> User:
        assert product_user_id == self.user.product_user_id
        return self.user


@pytest.fixture
def authenticated_client(httpxclient: AsyncClient, email: str):
    user = User(email=email)
    app.dependency_overrides[get_gr_api_manager] = lambda: FakeGRApiManager(user)
    httpxclient.cookies.set(
        SESSION_COOKIE_NAME, create_session(user.product_user_id), path="/"
    )
    yield httpxclient, user
    httpxclient.cookies.delete(SESSION_COOKIE_NAME, path="/")
    app.dependency_overrides.pop(get_gr_api_manager, None)


class TestCashout:
    @pytest.mark.anyio
    async def test_request_requires_authentication(self, httpxclient: AsyncClient):
        httpxclient.cookies.delete(SESSION_COOKIE_NAME, path="/")

        response = await httpxclient.post(
            "/wallet/cashout/request/", json={"amount": 500}
        )

        assert response.status_code == 401

    @pytest.mark.anyio
    @pytest.mark.skip("needs a cashout method mocked. this wont work")
    async def test_request_binds_user_and_amount_to_single_use_token(
        self,
        authenticated_client: tuple[AsyncClient, User],
        redis_config: RedisConfig,
    ):
        client, user = authenticated_client
        cashout_method_id = uuid4().hex

        response = await client.post(
            "/wallet/cashout/request/",
            json={"amount": 500, "cashout_method_id": cashout_method_id},
        )

        assert response.status_code == 200, response.text
        token = parse_qs(urlparse(response.json()["confirmation_link"]).query)["token"][
            0
        ]
        stored = redis_config.create_redis_client().get(
            redis_token_key(token, CASHOUT_TOKEN_PREFIX)
        )
        assert PendingCashout.model_validate_json(stored) == PendingCashout(
            product_user_id=user.product_user_id,
            amount=500,
            cashout_method_id=cashout_method_id,
        )

        response = await client.post("/wallet/cashout/confirm/", json={"token": token})
        assert response.status_code == 204

        response = await client.post("/wallet/cashout/confirm/", json={"token": token})
        assert response.status_code == 401

    @pytest.mark.anyio
    @pytest.mark.parametrize("amount", [0, -1, 1000])
    async def test_request_rejects_invalid_amount(
        self,
        authenticated_client: tuple[AsyncClient, User],
        amount: int,
    ):
        client, _ = authenticated_client

        response = await client.post(
            "/wallet/cashout/request/", json={"amount": amount}
        )

        assert response.status_code == 422