"""Comprehensive tests for note creation functionality."""
import json
import time
from datetime import datetime
from unittest.mock import MagicMock, patch
import pytest
from simplenote_mcp.server.cache import NoteCache
from simplenote_mcp.tests.test_helpers import helper_handle_call_tool
@pytest.fixture
def mock_simplenote_client():
"""Create a mock Simplenote client for note creation tests."""
mock_client = MagicMock()
# Mock successful note creation
def mock_add_note(note_data):
created_note = {
"key": f"test_note_{int(time.time() * 1000)}_{id(note_data)}_{time.perf_counter_ns()}",
"content": note_data.get("content", ""),
"tags": note_data.get("tags", []),
"createdate": datetime.now().isoformat(),
"modifydate": datetime.now().isoformat(),
"version": 1,
"syncnum": 1,
"systemtags": [],
"deleted": False,
}
return created_note, 0
mock_client.add_note.side_effect = mock_add_note
# Mock get_note_list for cache initialization
mock_client.get_note_list.return_value = ([], 0)
return mock_client
@pytest.mark.asyncio
async def test_create_simple_note(mock_simplenote_client):
"""Test creating a simple note with just content."""
cache = NoteCache(mock_simplenote_client)
cache._initialized = True
with (
patch("simplenote_mcp.server.server.note_cache", cache),
patch(
"simplenote_mcp.server.server.get_simplenote_client",
return_value=mock_simplenote_client,
),
):
# Create a simple note
result = await helper_handle_call_tool(
"create_note", {"content": "This is a simple test note"}
)
result_data = json.loads(result[0].text)
assert "key" in result_data or "note_id" in result_data
assert "message" in result_data
assert result_data["message"] == "Note created successfully"
assert "first_line" in result_data
assert result_data["first_line"] == "This is a simple test note"
@pytest.mark.asyncio
async def test_create_note_with_tags(mock_simplenote_client):
"""Test creating a note with tags."""
cache = NoteCache(mock_simplenote_client)
cache._initialized = True
with (
patch("simplenote_mcp.server.server.note_cache", cache),
patch(
"simplenote_mcp.server.server.get_simplenote_client",
return_value=mock_simplenote_client,
),
):
# Create a note with tags
result = await helper_handle_call_tool(
"create_note",
{"content": "Note with tags", "tags": ["important", "project", "todo"]},
)
result_data = json.loads(result[0].text)
assert "key" in result_data or "note_id" in result_data
assert "message" in result_data
assert result_data["message"] == "Note created successfully"
@pytest.mark.asyncio
async def test_create_note_with_multiline_content(mock_simplenote_client):
"""Test creating a note with multiline content."""
cache = NoteCache(mock_simplenote_client)
cache._initialized = True
multiline_content = """Meeting Notes: Project Kickoff
Date: 2025-01-15
Attendees: Alice, Bob, Charlie
Agenda:
1. Project overview
2. Timeline discussion
3. Resource allocation
Action items:
- Alice: Create project repository
- Bob: Set up CI/CD pipeline
- Charlie: Draft initial documentation"""
with (
patch("simplenote_mcp.server.server.note_cache", cache),
patch(
"simplenote_mcp.server.server.get_simplenote_client",
return_value=mock_simplenote_client,
),
):
result = await helper_handle_call_tool(
"create_note", {"content": multiline_content}
)
result_data = json.loads(result[0].text)
assert "first_line" in result_data
assert result_data["first_line"] == "Meeting Notes: Project Kickoff"
assert "message" in result_data
@pytest.mark.asyncio
async def test_create_note_with_special_characters(mock_simplenote_client):
"""Test creating notes with special characters and unicode."""
cache = NoteCache(mock_simplenote_client)
cache._initialized = True
special_content = """Special Characters Test
Symbols: !@#$%^&*()_+-={}[]|\\:";'<>?,./
Unicode: émojis 🎉 🚀 ✨
Languages: 日本語 中文 한국어 العربية
Math: ∫∑∏√∞≠≤≥±"""
with (
patch("simplenote_mcp.server.server.note_cache", cache),
patch(
"simplenote_mcp.server.server.get_simplenote_client",
return_value=mock_simplenote_client,
),
):
result = await helper_handle_call_tool(
"create_note", {"content": special_content, "tags": ["test", "unicode"]}
)
result_data = json.loads(result[0].text)
assert "key" in result_data or "note_id" in result_data
assert "first_line" in result_data
assert result_data["first_line"] == "Special Characters Test"
@pytest.mark.asyncio
async def test_create_empty_note(mock_simplenote_client):
"""Test creating an empty note."""
cache = NoteCache(mock_simplenote_client)
cache._initialized = True
with (
patch("simplenote_mcp.server.server.note_cache", cache),
patch(
"simplenote_mcp.server.server.get_simplenote_client",
return_value=mock_simplenote_client,
),
):
result = await helper_handle_call_tool("create_note", {"content": ""})
result_data = json.loads(result[0].text)
assert "key" in result_data or "note_id" in result_data
assert "first_line" in result_data
@pytest.mark.asyncio
async def test_create_note_with_markdown(mock_simplenote_client):
"""Test creating a note with markdown content."""
cache = NoteCache(mock_simplenote_client)
cache._initialized = True
markdown_content = """# Project Documentation
## Overview
This is a **test project** with *markdown* formatting.
### Features
- Feature 1
- Feature 2
- Feature 3
### Code Example
```python
def hello_world():
print("Hello, World!")
```
### Links
- [Project Website](https://example.com)
- [Documentation](https://docs.example.com)
> This is a blockquote with important information.
---
**Bold text** and *italic text* and `inline code`."""
with (
patch("simplenote_mcp.server.server.note_cache", cache),
patch(
"simplenote_mcp.server.server.get_simplenote_client",
return_value=mock_simplenote_client,
),
):
result = await helper_handle_call_tool(
"create_note",
{"content": markdown_content, "tags": ["documentation", "markdown"]},
)
result_data = json.loads(result[0].text)
assert "key" in result_data or "note_id" in result_data
assert "first_line" in result_data
assert result_data["first_line"] == "# Project Documentation"
@pytest.mark.asyncio
async def test_create_note_error_handling(mock_simplenote_client):
"""Test error handling during note creation."""
cache = NoteCache(mock_simplenote_client)
cache._initialized = True
# Mock a failure
mock_simplenote_client.add_note.side_effect = lambda _note: (None, -1)
with (
patch("simplenote_mcp.server.server.note_cache", cache),
patch(
"simplenote_mcp.server.server.get_simplenote_client",
return_value=mock_simplenote_client,
),
):
result = await helper_handle_call_tool(
"create_note", {"content": "This should fail"}
)
result_data = json.loads(result[0].text)
assert "error" in result_data
assert result_data["error"]["type"] == "network"
@pytest.mark.asyncio
async def test_create_note_with_duplicate_tags(mock_simplenote_client):
"""Test creating a note with duplicate tags."""
cache = NoteCache(mock_simplenote_client)
cache._initialized = True
with (
patch("simplenote_mcp.server.server.note_cache", cache),
patch(
"simplenote_mcp.server.server.get_simplenote_client",
return_value=mock_simplenote_client,
),
):
result = await helper_handle_call_tool(
"create_note",
{
"content": "Note with duplicate tags",
"tags": ["test", "important", "test", "important", "unique"],
},
)
result_data = json.loads(result[0].text)
# Just verify the note was created successfully
assert "key" in result_data or "note_id" in result_data
assert "message" in result_data
@pytest.mark.asyncio
async def test_create_note_with_very_long_content(mock_simplenote_client):
"""Test creating a note with very long content."""
cache = NoteCache(mock_simplenote_client)
cache._initialized = True
# Create a very long note (10KB)
long_content = "This is a very long note. " * 500
with (
patch("simplenote_mcp.server.server.note_cache", cache),
patch(
"simplenote_mcp.server.server.get_simplenote_client",
return_value=mock_simplenote_client,
),
):
result = await helper_handle_call_tool("create_note", {"content": long_content})
result_data = json.loads(result[0].text)
assert "key" in result_data or "note_id" in result_data
assert "message" in result_data
@pytest.mark.asyncio
async def test_create_note_cache_update(mock_simplenote_client):
"""Test that creating a note updates the cache."""
cache = NoteCache(mock_simplenote_client)
cache._initialized = True
initial_note_count = len(cache._notes)
with (
patch("simplenote_mcp.server.server.note_cache", cache),
patch(
"simplenote_mcp.server.server.get_simplenote_client",
return_value=mock_simplenote_client,
),
):
result = await helper_handle_call_tool(
"create_note", {"content": "Test cache update", "tags": ["cache-test"]}
)
result_data = json.loads(result[0].text)
note_id = result_data.get("key") or result_data.get("note_id")
# Check if note was added to cache
assert note_id in cache._notes
assert len(cache._notes) == initial_note_count + 1
# Check if tags were added to cache
assert "cache-test" in cache._tags
@pytest.mark.asyncio
async def test_create_note_with_tags_string(mock_simplenote_client):
"""Test creating a note with tags as a comma-separated string."""
cache = NoteCache(mock_simplenote_client)
cache._initialized = True
with (
patch("simplenote_mcp.server.server.note_cache", cache),
patch(
"simplenote_mcp.server.server.get_simplenote_client",
return_value=mock_simplenote_client,
),
):
# Some users might pass tags as a string
result = await helper_handle_call_tool(
"create_note",
{"content": "Note with string tags", "tags": "tag1,tag2,tag3"},
)
result_data = json.loads(result[0].text)
# Just verify the note was created successfully
assert "key" in result_data or "note_id" in result_data
assert "message" in result_data
@pytest.mark.asyncio
async def test_create_multiple_notes_sequentially(mock_simplenote_client):
"""Test creating multiple notes in sequence."""
cache = NoteCache(mock_simplenote_client)
cache._initialized = True
created_notes = []
# Override the add_note method to ensure unique keys for this test
note_counter = 0
def mock_sequential_add_note(note_data):
nonlocal note_counter
note_counter += 1
created_note = {
"key": f"unique_test_note_{note_counter}_{int(time.time() * 1000)}",
"content": note_data.get("content", ""),
"tags": note_data.get("tags", []),
"createdate": datetime.now().isoformat(),
"modifydate": datetime.now().isoformat(),
"version": 1,
"syncnum": 1,
"systemtags": [],
"deleted": False,
}
return created_note, 0
mock_simplenote_client.add_note.side_effect = mock_sequential_add_note
with (
patch("simplenote_mcp.server.server.note_cache", cache),
patch(
"simplenote_mcp.server.server.get_simplenote_client",
return_value=mock_simplenote_client,
),
):
# Create multiple notes
for i in range(5):
result = await helper_handle_call_tool(
"create_note",
{
"content": f"Sequential note #{i + 1}",
"tags": [f"batch-{i + 1}", "sequential"],
},
)
result_data = json.loads(result[0].text)
created_notes.append(result_data)
# Verify all notes were created
assert len(created_notes) == 5
# Verify each note has unique ID
note_ids = [note.get("key") or note.get("note_id") for note in created_notes]
assert len(set(note_ids)) == 5
# Verify first line
for i, note in enumerate(created_notes):
assert note["first_line"] == f"Sequential note #{i + 1}"
@pytest.mark.asyncio
async def test_create_note_with_line_breaks(mock_simplenote_client):
"""Test creating notes with various line break styles."""
cache = NoteCache(mock_simplenote_client)
cache._initialized = True
# Test different line break styles
content_unix = "Line 1\nLine 2\nLine 3"
content_windows = "Line 1\r\nLine 2\r\nLine 3"
content_mixed = "Line 1\nLine 2\r\nLine 3"
with (
patch("simplenote_mcp.server.server.note_cache", cache),
patch(
"simplenote_mcp.server.server.get_simplenote_client",
return_value=mock_simplenote_client,
),
):
for content in [content_unix, content_windows, content_mixed]:
result = await helper_handle_call_tool("create_note", {"content": content})
result_data = json.loads(result[0].text)
# Should create successfully
assert "key" in result_data or "note_id" in result_data
assert "message" in result_data
