# user_handler.py
from spikard import GrpcRequest, GrpcResponse
import user_pb2  # Generated from your .proto file

class UserServiceHandler:
    async def handle_request(self, request: GrpcRequest) -> GrpcResponse:
        if request.method_name == "GetUser":
            # Deserialize
            req = user_pb2.GetUserRequest()
            req.ParseFromString(request.payload)

            # Process
            user = user_pb2.User(id=req.user_id, name="Alice", email="alice@example.com")

            # Serialize and return
            return GrpcResponse(payload=user.SerializeToString())

from spikard.grpc import GrpcHandler, GrpcRequest, GrpcResponse
import userservice_pb2  # Generated from proto
from datetime import datetime


class UserServiceHandler(GrpcHandler):
    """UserService gRPC handler implementation."""

    def __init__(self, user_repository):
        """Initialize handler with dependencies."""
        self.user_repository = user_repository

    async def handle_request(self, request: GrpcRequest) -> GrpcResponse:
        """
        Handle incoming gRPC requests.

        Routes to appropriate method based on request.method_name.
        """
        if request.method_name == "GetUser":
            return await self._get_user(request)
        elif request.method_name == "CreateUser":
            return await self._create_user(request)
        else:
            raise NotImplementedError(f"Unknown method: {request.method_name}")

    async def _get_user(self, request: GrpcRequest) -> GrpcResponse:
        """Handle GetUser RPC."""
        # 1. Deserialize request
        req = userservice_pb2.GetUserRequest()
        req.ParseFromString(request.payload)

        # 2. Validate input
        if req.id <= 0:
            raise ValueError("User ID must be positive")

        # 3. Business logic
        user = await self.user_repository.find_by_id(req.id)
        if not user:
            raise ValueError(f"User {req.id} not found")

        # 4. Build response
        response_user = userservice_pb2.User()
        response_user.id = user.id
        response_user.name = user.name
        response_user.email = user.email
        response_user.created_at = user.created_at.isoformat()

        # 5. Serialize and return
        return GrpcResponse(
            payload=response_user.SerializeToString(),
            metadata={"x-user-found": "true"}
        )

    async def _create_user(self, request: GrpcRequest) -> GrpcResponse:
        """Handle CreateUser RPC."""
        # 1. Deserialize request
        req = userservice_pb2.CreateUserRequest()
        req.ParseFromString(request.payload)

        # 2. Validate input
        if not req.name or not req.email:
            raise ValueError("Name and email are required")

        # 3. Check authorization from metadata
        auth_token = request.get_metadata("authorization")
        if not auth_token:
            raise PermissionError("Authentication required")

        # 4. Business logic
        user = await self.user_repository.create(
            name=req.name,
            email=req.email
        )

        # 5. Build response
        response_user = userservice_pb2.User()
        response_user.id = user.id
        response_user.name = user.name
        response_user.email = user.email
        response_user.created_at = datetime.utcnow().isoformat()

        # 6. Serialize with metadata
        return GrpcResponse(
            payload=response_user.SerializeToString(),
            metadata={
                "x-user-id": str(user.id),
                "x-created": "true"
            }
        )

from spikard import create_app
from spikard.grpc import GrpcService

# Create app
app = create_app()

# Create service registry
grpc_service = GrpcService()

# Register handler
handler = UserServiceHandler(user_repository=UserRepository())
grpc_service.register_handler("userservice.UserService", handler)

# App is now ready to serve gRPC requests

from spikard import create_app
from spikard.grpc import GrpcService

# Create app
app = create_app()

# Create service registry
grpc_service = GrpcService()

# Register handler
handler = UserServiceHandler(user_repository=UserRepository())
grpc_service.register_handler("userservice.UserService", handler)

# App is now ready to serve gRPC requests

# test_user_handler.py
import pytest
from user_handler import UserServiceHandler
from spikard import GrpcRequest
import user_service_pb2 as pb


@pytest.mark.asyncio
async def test_get_user_success():
    """Test getting an existing user."""
    handler = UserServiceHandler()

    # Create request
    req = pb.GetUserRequest(user_id=1)
    grpc_request = GrpcRequest(
        service_name="userservice.v1.UserService",
        method_name="GetUser",
        payload=req.SerializeToString(),
    )

    # Call handler
    response = await handler.handle_request(grpc_request)

    # Deserialize response
    user_response = pb.UserResponse()
    user_response.ParseFromString(response.payload)

    # Assertions
    assert user_response.success is True
    assert user_response.user.id == 1
    assert user_response.user.name == "Alice"
    assert user_response.user.email == "alice@example.com"


@pytest.mark.asyncio
async def test_get_user_not_found():
    """Test getting a non-existent user."""
    handler = UserServiceHandler()

    # Create request for non-existent user
    req = pb.GetUserRequest(user_id=999)
    grpc_request = GrpcRequest(
        service_name="userservice.v1.UserService",
        method_name="GetUser",
        payload=req.SerializeToString(),
    )

    # Call handler
    response = await handler.handle_request(grpc_request)

    # Deserialize response
    user_response = pb.UserResponse()
    user_response.ParseFromString(response.payload)

    # Assertions
    assert user_response.success is False
    assert "not found" in user_response.error_message


@pytest.mark.asyncio
async def test_create_user_success():
    """Test creating a new user."""
    handler = UserServiceHandler()

    # Create request
    req = pb.CreateUserRequest(
        name="Charlie",
        email="charlie@example.com",
        phone="555-1234",
        tags=["developer", "remote"],
    )
    grpc_request = GrpcRequest(
        service_name="userservice.v1.UserService",
        method_name="CreateUser",
        payload=req.SerializeToString(),
    )

    # Call handler
    response = await handler.handle_request(grpc_request)

    # Deserialize response
    user_response = pb.UserResponse()
    user_response.ParseFromString(response.payload)

    # Assertions
    assert user_response.success is True
    assert user_response.user.id == 3  # Next available ID
    assert user_response.user.name == "Charlie"
    assert user_response.user.email == "charlie@example.com"
    assert user_response.user.phone == "555-1234"
    assert list(user_response.user.tags) == ["developer", "remote"]


@pytest.mark.asyncio
async def test_create_user_validation_error():
    """Test creating a user with missing required fields."""
    handler = UserServiceHandler()

    # Create request with missing email
    req = pb.CreateUserRequest(name="Invalid")
    grpc_request = GrpcRequest(
        service_name="userservice.v1.UserService",
        method_name="CreateUser",
        payload=req.SerializeToString(),
    )

    # Call handler
    response = await handler.handle_request(grpc_request)

    # Deserialize response
    user_response = pb.UserResponse()
    user_response.ParseFromString(response.payload)

    # Assertions
    assert user_response.success is False
    assert "required" in user_response.error_message


@pytest.mark.asyncio
async def test_unknown_method():
    """Test calling an unknown method."""
    handler = UserServiceHandler()

    grpc_request = GrpcRequest(
        service_name="userservice.v1.UserService",
        method_name="DeleteUser",  # Not implemented
        payload=b"",
    )

    # Should raise NotImplementedError
    with pytest.raises(NotImplementedError, match="Unknown method"):
        await handler.handle_request(grpc_request)


# Run tests
if __name__ == "__main__":
    pytest.main([__file__, "-v"])

import pytest
from user_handler import UserServiceHandler

@pytest.fixture
def handler():
    """Create handler with test data."""
    return UserServiceHandler()

@pytest.fixture
def sample_user():
    """Create sample user for tests."""
    return pb.User(
        id=1,
        name="Test User",
        email="test@example.com",
    )

@pytest.mark.asyncio
async def test_with_fixtures(handler, sample_user):
    # Test using fixtures
    pass

@pytest.mark.asyncio
async def test_handles_malformed_payload():
    """Test handler with malformed protobuf."""
    handler = UserServiceHandler()

    # Create request with invalid protobuf
    grpc_request = GrpcRequest(
        service_name="userservice.v1.UserService",
        method_name="GetUser",
        payload=b"invalid protobuf data",
    )

    # Should handle deserialization error gracefully
    with pytest.raises(Exception):  # Or specific protobuf exception
        await handler.handle_request(grpc_request)