clubber/tests/integration/test_member_queries.py

"""Integration tests for GraphQL query resolvers."""

import pytest
from sqlalchemy import select

from src.models.member import Member, MemberType
from src.resolvers.member import Query


class TestMemberQueries:
    """Tests for GraphQL query resolvers."""

    async def test_query_single_member_by_id(self, async_session, patched_session_maker):
        """Test querying a single member by ID."""
        # Create a member
        member = Member(
            first_name="Alice",
            last_name="Smith",
            email="alice@example.com"
        )
        async_session.add(member)
        await async_session.commit()
        await async_session.refresh(member)

        # Query the member
        query = Query()
        result = await query.member(id=member.id)

        assert result is not None
        assert result.id == member.id
        assert result.first_name == "Alice"
        assert result.last_name == "Smith"
        assert result.email == "alice@example.com"

    async def test_query_member_with_nonexistent_id(self, patched_session_maker):
        """Test querying a member with non-existent ID returns None."""
        query = Query()
        result = await query.member(id=999)

        assert result is None

    async def test_query_all_members(self, async_session, patched_session_maker):
        """Test querying all members."""
        # Create multiple members
        members = [
            Member(first_name="Alice", last_name="Smith"),
            Member(first_name="Bob", last_name="Johnson"),
            Member(first_name="Charlie", last_name="Brown"),
        ]
        for m in members:
            async_session.add(m)
        await async_session.commit()

        # Query all members
        query = Query()
        results = await query.members()

        assert len(results) == 3
        assert results[0].first_name == "Charlie"  # Brown comes first
        assert results[1].first_name == "Bob"  # Johnson
        assert results[2].first_name == "Alice"  # Smith

    async def test_query_members_empty_database(self, patched_session_maker):
        """Test querying members when database is empty returns empty array."""
        query = Query()
        results = await query.members()

        assert results == []

    async def test_members_sorting_nulls_last(self, async_session, patched_session_maker):
        """Test that members query sorts by last_name (nulls last), then first_name."""
        # Create members with some having null last names
        members = [
            Member(first_name="Zoe", last_name="Anderson"),
            Member(first_name="Alice", last_name=None),
            Member(first_name="Bob", last_name=None),
            Member(first_name="Charlie", last_name="Baker"),
        ]
        for m in members:
            async_session.add(m)
        await async_session.commit()

        # Query all members
        query = Query()
        results = await query.members()

        # Expected order: Anderson, Baker, then nulls (Alice, Bob)
        assert len(results) == 4
        assert results[0].last_name == "Anderson"
        assert results[1].last_name == "Baker"
        assert results[2].first_name == "Alice"
        assert results[2].last_name is None
        assert results[3].first_name == "Bob"
        assert results[3].last_name is None

    async def test_query_mixed_member_types(self, async_session, patched_session_maker):
        """Test querying returns both individual and organization members."""
        # Create individual member
        individual = Member(
            member_type=MemberType.INDIVIDUAL,
            first_name="Alice",
            last_name="Smith"
        )
        async_session.add(individual)

        # Create organization member
        organization = Member(
            member_type=MemberType.ORGANIZATION,
            company_name="Acme Corp",
            email="info@acme.com"
        )
        async_session.add(organization)
        await async_session.commit()

        # Query all members
        query = Query()
        result = await query.members()

        assert len(result) == 2
        types = {m.member_type for m in result}
        assert MemberType.INDIVIDUAL in types
        assert MemberType.ORGANIZATION in types

        # Verify individual member data
        individual_result = next(m for m in result if m.member_type == MemberType.INDIVIDUAL)
        assert individual_result.first_name == "Alice"
        assert individual_result.last_name == "Smith"

        # Verify organization member data
        org_result = next(m for m in result if m.member_type == MemberType.ORGANIZATION)
        assert org_result.company_name == "Acme Corp"