"""Tests for Pydantic models."""
from datetime import datetime, timezone
from uuid import UUID, uuid4
import pytest
from pydantic import ValidationError
from mcp_mem.models import (
Collection,
CollectionCreate,
MemItRequest,
Note,
NoteCreate,
RequestResponse,
)
class TestRequestResponse:
"""Test RequestResponse model."""
def test_valid_request_response(self):
"""Test creating a valid RequestResponse."""
response = RequestResponse(request_id="api-request-123")
assert response.request_id == "api-request-123"
def test_missing_request_id(self):
"""Test that request_id is required."""
with pytest.raises(ValidationError):
RequestResponse()
class TestMemItRequest:
"""Test MemItRequest model."""
def test_valid_mem_it_request(self):
"""Test creating a valid MemItRequest."""
request = MemItRequest(
input="Test content",
instructions="Save this",
context="Testing",
)
assert request.input == "Test content"
assert request.instructions == "Save this"
assert request.context == "Testing"
assert request.timestamp is None
def test_mem_it_request_with_timestamp(self):
"""Test MemItRequest with timestamp."""
now = datetime.now(timezone.utc)
request = MemItRequest(
input="Test content",
timestamp=now,
)
assert request.timestamp == now
def test_mem_it_request_minimal(self):
"""Test MemItRequest with only required fields."""
request = MemItRequest(input="Test content")
assert request.input == "Test content"
assert request.instructions is None
assert request.context is None
assert request.timestamp is None
def test_mem_it_request_empty_input(self):
"""Test that empty input is invalid."""
with pytest.raises(ValidationError):
MemItRequest(input="")
def test_mem_it_request_no_input(self):
"""Test that input is required."""
with pytest.raises(ValidationError):
MemItRequest()
class TestNoteCreate:
"""Test NoteCreate model."""
def test_valid_note_create(self):
"""Test creating a valid NoteCreate."""
collection_id = uuid4()
request = NoteCreate(
content="# Test Note\n\nContent here",
collection_ids=[collection_id],
collection_titles=["Test Collection"],
)
assert request.content == "# Test Note\n\nContent here"
assert request.collection_ids == [collection_id]
assert request.collection_titles == ["Test Collection"]
def test_note_create_minimal(self):
"""Test NoteCreate with only required fields."""
request = NoteCreate(content="Test content")
assert request.content == "Test content"
assert request.id is None
assert request.collection_ids is None
def test_note_create_empty_content(self):
"""Test that empty content is invalid."""
with pytest.raises(ValidationError):
NoteCreate(content="")
def test_note_create_with_custom_id(self):
"""Test NoteCreate with custom UUID."""
note_id = uuid4()
request = NoteCreate(content="Test", id=note_id)
assert request.id == note_id
class TestNote:
"""Test Note model."""
def test_valid_note(self):
"""Test creating a valid Note."""
note_id = uuid4()
collection_id = uuid4()
now = datetime.now(timezone.utc)
note = Note(
id=note_id,
title="Test Note",
content="# Test\n\nContent",
collection_ids=[collection_id],
created_at=now,
updated_at=now,
request_id="req-123",
)
assert note.id == note_id
assert note.title == "Test Note"
assert note.content == "# Test\n\nContent"
assert note.collection_ids == [collection_id]
assert note.created_at == now
assert note.updated_at == now
assert note.request_id == "req-123"
def test_note_with_empty_collections(self):
"""Test Note with no collections."""
note_id = uuid4()
now = datetime.now(timezone.utc)
note = Note(
id=note_id,
title="Test Note",
content="Content",
created_at=now,
updated_at=now,
)
assert note.collection_ids == []
def test_note_missing_required_fields(self):
"""Test that required fields are validated."""
with pytest.raises(ValidationError):
Note(title="Test")
class TestCollectionCreate:
"""Test CollectionCreate model."""
def test_valid_collection_create(self):
"""Test creating a valid CollectionCreate."""
request = CollectionCreate(
title="Test Collection",
description="A test collection",
)
assert request.title == "Test Collection"
assert request.description == "A test collection"
def test_collection_create_minimal(self):
"""Test CollectionCreate with only required fields."""
request = CollectionCreate(title="Test Collection")
assert request.title == "Test Collection"
assert request.description is None
def test_collection_create_empty_title(self):
"""Test that empty title is invalid."""
with pytest.raises(ValidationError):
CollectionCreate(title="")
def test_collection_create_with_custom_id(self):
"""Test CollectionCreate with custom UUID."""
collection_id = uuid4()
request = CollectionCreate(title="Test", id=collection_id)
assert request.id == collection_id
class TestCollection:
"""Test Collection model."""
def test_valid_collection(self):
"""Test creating a valid Collection."""
collection_id = uuid4()
now = datetime.now(timezone.utc)
collection = Collection(
id=collection_id,
title="Test Collection",
description="A test collection",
created_at=now,
updated_at=now,
)
assert collection.id == collection_id
assert collection.title == "Test Collection"
assert collection.description == "A test collection"
assert collection.created_at == now
assert collection.updated_at == now
def test_collection_without_description(self):
"""Test Collection without description."""
collection_id = uuid4()
now = datetime.now(timezone.utc)
collection = Collection(
id=collection_id,
title="Test Collection",
description=None,
created_at=now,
updated_at=now,
)
assert collection.description is None
def test_collection_missing_required_fields(self):
"""Test that required fields are validated."""
with pytest.raises(ValidationError):
Collection(title="Test")
class TestModelSerialization:
"""Test model serialization."""
def test_note_create_serialization(self):
"""Test NoteCreate JSON serialization."""
collection_id = uuid4()
request = NoteCreate(
content="Test",
collection_ids=[collection_id],
)
data = request.model_dump(exclude_none=True, mode="json")
assert data["content"] == "Test"
assert data["collection_ids"] == [str(collection_id)]
assert "id" not in data
def test_mem_it_request_serialization(self):
"""Test MemItRequest JSON serialization."""
now = datetime.now(timezone.utc)
request = MemItRequest(
input="Test",
instructions="Save",
timestamp=now,
)
data = request.model_dump(exclude_none=True, mode="json")
assert data["input"] == "Test"
assert data["instructions"] == "Save"
assert "timestamp" in data
def test_collection_create_serialization(self):
"""Test CollectionCreate JSON serialization."""
request = CollectionCreate(title="Test Collection")
data = request.model_dump(exclude_none=True, mode="json")
assert data["title"] == "Test Collection"
assert "description" not in data
