nanoClaw/tests/test_models.py

import pytest
from backend.models import User, Conversation, Message, TokenUsage, Project
from datetime import datetime, timezone


def test_user_create(session):
    """Test creating a user."""
    user = User(username='testuser', email='test@example.com')
    session.add(user)
    session.commit()
    
    assert user.id is not None
    assert user.username == 'testuser'
    assert user.email == 'test@example.com'
    assert user.role == 'user'
    assert user.is_active is True
    assert user.created_at is not None
    assert user.last_login_at is None


def test_user_password_hashing(session):
    """Test password hashing and verification."""
    user = User(username='testuser')
    user.password = 'securepassword'
    session.add(user)
    session.commit()
    
    # Password hash should be set
    assert user.password_hash is not None
    assert user.password_hash != 'securepassword'
    
    # Check password
    assert user.check_password('securepassword') is True
    assert user.check_password('wrongpassword') is False
    
    # Setting password to None clears hash
    user.password = None
    assert user.password_hash is None


def test_user_to_dict(session):
    """Test user serialization."""
    user = User(username='testuser', email='test@example.com', role='admin')
    session.add(user)
    session.commit()
    
    data = user.to_dict()
    assert data['username'] == 'testuser'
    assert data['email'] == 'test@example.com'
    assert data['role'] == 'admin'
    assert 'password_hash' not in data
    assert 'created_at' in data


def test_conversation_create(session):
    """Test creating a conversation."""
    user = User(username='user1')
    session.add(user)
    session.commit()
    
    conv = Conversation(
        id='conv-123',
        user_id=user.id,
        title='Test Conversation',
        model='deepseek-chat',
        system_prompt='You are a helpful assistant.',
        temperature=0.8,
        max_tokens=2048,
        thinking_enabled=True,
    )
    session.add(conv)
    session.commit()
    
    assert conv.id == 'conv-123'
    assert conv.user_id == user.id
    assert conv.title == 'Test Conversation'
    assert conv.model == 'deepseek-chat'
    assert conv.system_prompt == 'You are a helpful assistant.'
    assert conv.temperature == 0.8
    assert conv.max_tokens == 2048
    assert conv.thinking_enabled is True
    assert conv.created_at is not None
    assert conv.updated_at is not None
    assert conv.user == user


def test_conversation_relationships(session):
    """Test conversation relationships with messages."""
    user = User(username='user1')
    session.add(user)
    session.commit()
    
    conv = Conversation(id='conv-123', user_id=user.id, title='Test')
    session.add(conv)
    session.commit()
    
    # Create messages
    msg1 = Message(id='msg-1', conversation_id=conv.id, role='user', content='Hello')
    msg2 = Message(id='msg-2', conversation_id=conv.id, role='assistant', content='Hi')
    session.add_all([msg1, msg2])
    session.commit()
    
    # Test relationship
    assert conv.messages.count() == 2
    assert list(conv.messages) == [msg1, msg2]
    assert msg1.conversation == conv


def test_message_create(session):
    """Test creating a message."""
    user = User(username='user1')
    session.add(user)
    session.commit()
    
    conv = Conversation(id='conv-123', user_id=user.id, title='Test')
    session.add(conv)
    session.commit()
    
    msg = Message(
        id='msg-1',
        conversation_id=conv.id,
        role='user',
        content='{"text": "Hello world"}',
    )
    session.add(msg)
    session.commit()
    
    assert msg.id == 'msg-1'
    assert msg.conversation_id == conv.id
    assert msg.role == 'user'
    assert msg.content == '{"text": "Hello world"}'
    assert msg.created_at is not None
    assert msg.conversation == conv


def test_message_to_dict(session):
    """Test message serialization."""
    from backend.utils.helpers import message_to_dict
    
    msg = Message(
        id='msg-1',
        conversation_id='conv-123',
        role='user',
        content='{"text": "Hello", "attachments": [{"name": "file.txt"}]}',
    )
    session.add(msg)
    session.commit()
    
    data = message_to_dict(msg)
    assert data['id'] == 'msg-1'
    assert data['role'] == 'user'
    assert data['text'] == 'Hello'
    assert 'attachments' in data
    assert data['attachments'][0]['name'] == 'file.txt'


def test_token_usage_create(session):
    """Test token usage recording."""
    user = User(username='user1')
    session.add(user)
    session.commit()
    
    usage = TokenUsage(
        user_id=user.id,
        model='deepseek-chat',
        date=datetime.now(timezone.utc).date(),
        prompt_tokens=100,
        completion_tokens=200,
        total_tokens=300,
    )
    session.add(usage)
    session.commit()
    
    assert usage.id is not None
    assert usage.user_id == user.id
    assert usage.model == 'deepseek-chat'
    assert usage.prompt_tokens == 100
    assert usage.total_tokens == 300


def test_project_create(session):
    """Test project creation."""
    user = User(username='user1')
    session.add(user)
    session.commit()
    
    project = Project(
        id='proj-123',
        user_id=user.id,
        name='My Project',
        path='user_1/my_project',
        description='A test project',
    )
    session.add(project)
    session.commit()
    
    assert project.id == 'proj-123'
    assert project.user_id == user.id
    assert project.name == 'My Project'
    assert project.path == 'user_1/my_project'
    assert project.description == 'A test project'
    assert project.created_at is not None
    assert project.updated_at is not None
    assert project.user == user
    assert project.conversations.count() == 0


if __name__ == '__main__':
    pytest.main(['-v', __file__])