arbret/backend/tests/test_counter.py

"""Tests for counter endpoints.

Note: Registration now requires an invite code.
"""
import pytest

from auth import COOKIE_NAME
from models import ROLE_REGULAR
from tests.helpers import unique_email, create_invite_for_godfather
from tests.conftest import create_user_with_roles


# Protected endpoint tests - without auth
@pytest.mark.asyncio
async def test_get_counter_requires_auth(client):
    response = await client.get("/api/counter")
    assert response.status_code == 401


@pytest.mark.asyncio
async def test_increment_counter_requires_auth(client):
    response = await client.post("/api/counter/increment")
    assert response.status_code == 401


@pytest.mark.asyncio
async def test_get_counter_invalid_cookie(client_factory):
    async with client_factory.create(cookies={COOKIE_NAME: "invalidtoken"}) as authed:
        response = await authed.get("/api/counter")
    assert response.status_code == 401


@pytest.mark.asyncio
async def test_increment_counter_invalid_cookie(client_factory):
    async with client_factory.create(cookies={COOKIE_NAME: "invalidtoken"}) as authed:
        response = await authed.post("/api/counter/increment")
    assert response.status_code == 401


# Authenticated counter tests
@pytest.mark.asyncio
async def test_get_counter_authenticated(client_factory):
    async with client_factory.get_db_session() as db:
        godfather = await create_user_with_roles(db, unique_email("gf"), "pass123", [ROLE_REGULAR])
        invite_code = await create_invite_for_godfather(db, godfather.id)
    
    reg = await client_factory.post(
        "/api/auth/register",
        json={
            "email": unique_email(),
            "password": "testpass123",
            "invite_identifier": invite_code,
        },
    )
    cookies = dict(reg.cookies)
    
    async with client_factory.create(cookies=cookies) as authed:
        response = await authed.get("/api/counter")
    
    assert response.status_code == 200
    assert "value" in response.json()


@pytest.mark.asyncio
async def test_increment_counter(client_factory):
    async with client_factory.get_db_session() as db:
        godfather = await create_user_with_roles(db, unique_email("gf"), "pass123", [ROLE_REGULAR])
        invite_code = await create_invite_for_godfather(db, godfather.id)
    
    reg = await client_factory.post(
        "/api/auth/register",
        json={
            "email": unique_email(),
            "password": "testpass123",
            "invite_identifier": invite_code,
        },
    )
    cookies = dict(reg.cookies)
    
    async with client_factory.create(cookies=cookies) as authed:
        # Get current value
        before = await authed.get("/api/counter")
        before_value = before.json()["value"]
        
        # Increment
        response = await authed.post("/api/counter/increment")
        assert response.status_code == 200
        assert response.json()["value"] == before_value + 1


@pytest.mark.asyncio
async def test_increment_counter_multiple(client_factory):
    async with client_factory.get_db_session() as db:
        godfather = await create_user_with_roles(db, unique_email("gf"), "pass123", [ROLE_REGULAR])
        invite_code = await create_invite_for_godfather(db, godfather.id)
    
    reg = await client_factory.post(
        "/api/auth/register",
        json={
            "email": unique_email(),
            "password": "testpass123",
            "invite_identifier": invite_code,
        },
    )
    cookies = dict(reg.cookies)
    
    async with client_factory.create(cookies=cookies) as authed:
        # Get starting value
        before = await authed.get("/api/counter")
        start = before.json()["value"]
        
        # Increment 3 times
        await authed.post("/api/counter/increment")
        await authed.post("/api/counter/increment")
        response = await authed.post("/api/counter/increment")
        
        assert response.json()["value"] == start + 3


@pytest.mark.asyncio
async def test_get_counter_after_increment(client_factory):
    async with client_factory.get_db_session() as db:
        godfather = await create_user_with_roles(db, unique_email("gf"), "pass123", [ROLE_REGULAR])
        invite_code = await create_invite_for_godfather(db, godfather.id)
    
    reg = await client_factory.post(
        "/api/auth/register",
        json={
            "email": unique_email(),
            "password": "testpass123",
            "invite_identifier": invite_code,
        },
    )
    cookies = dict(reg.cookies)
    
    async with client_factory.create(cookies=cookies) as authed:
        before = await authed.get("/api/counter")
        start = before.json()["value"]
        
        await authed.post("/api/counter/increment")
        await authed.post("/api/counter/increment")
        
        response = await authed.get("/api/counter")
        assert response.json()["value"] == start + 2


# Counter is shared between users
@pytest.mark.asyncio
async def test_counter_shared_between_users(client_factory):
    # Create godfather and invites for two users
    async with client_factory.get_db_session() as db:
        godfather = await create_user_with_roles(db, unique_email("gf"), "pass123", [ROLE_REGULAR])
        invite1 = await create_invite_for_godfather(db, godfather.id)
        invite2 = await create_invite_for_godfather(db, godfather.id)
    
    # Create first user
    reg1 = await client_factory.post(
        "/api/auth/register",
        json={
            "email": unique_email("share1"),
            "password": "testpass123",
            "invite_identifier": invite1,
        },
    )
    cookies1 = dict(reg1.cookies)
    
    async with client_factory.create(cookies=cookies1) as user1:
        # Get starting value
        before = await user1.get("/api/counter")
        start = before.json()["value"]
        
        await user1.post("/api/counter/increment")
        await user1.post("/api/counter/increment")
    
    # Create second user - should see the increments
    reg2 = await client_factory.post(
        "/api/auth/register",
        json={
            "email": unique_email("share2"),
            "password": "testpass123",
            "invite_identifier": invite2,
        },
    )
    cookies2 = dict(reg2.cookies)
    
    async with client_factory.create(cookies=cookies2) as user2:
        response = await user2.get("/api/counter")
        assert response.json()["value"] == start + 2
        
        # Second user increments
        await user2.post("/api/counter/increment")
    
    # First user sees the increment
    async with client_factory.create(cookies=cookies1) as user1:
        response = await user1.get("/api/counter")
        assert response.json()["value"] == start + 3