dc0d72c896
Implement Phase 3 improvements: intelligent caching and batch operations
to significantly enhance SDK performance and usability.
**1. Caching Layer Implementation**
Added complete caching infrastructure with LRU eviction and TTL support:
- `wikijs/cache/base.py`: Abstract BaseCache interface with CacheKey structure
- `wikijs/cache/memory.py`: MemoryCache implementation with:
* LRU (Least Recently Used) eviction policy
* Configurable TTL (time-to-live) expiration
* Cache statistics (hits, misses, hit rate)
* Resource-specific invalidation
* Automatic cleanup of expired entries
**Cache Integration:**
- Modified `WikiJSClient` to accept optional `cache` parameter
- Integrated caching into `PagesEndpoint.get()`:
* Check cache before API request
* Store successful responses in cache
* Invalidate cache on write operations (update, delete)
**2. Batch Operations**
Added efficient batch methods to Pages API:
- `create_many(pages_data)`: Batch create multiple pages
- `update_many(updates)`: Batch update pages with partial success handling
- `delete_many(page_ids)`: Batch delete with detailed error reporting
All batch methods include:
- Partial success support (continue on errors)
- Detailed error tracking with indices
- Comprehensive error messages
**3. Comprehensive Testing**
Added 27 new tests (all passing):
- `tests/test_cache.py`: 17 tests for caching (99% coverage)
* CacheKey string generation
* TTL expiration
* LRU eviction policy
* Cache invalidation (specific & all resources)
* Statistics tracking
- `tests/endpoints/test_pages_batch.py`: 10 tests for batch operations
* Successful batch creates/updates/deletes
* Partial failure handling
* Empty list edge cases
* Validation error handling
**Performance Benefits:**
- Caching reduces API calls for frequently accessed pages
- Batch operations reduce network overhead for bulk actions
- Configurable cache size and TTL for optimization
**Example Usage:**
```python
from wikijs import WikiJSClient
from wikijs.cache import MemoryCache
# Enable caching
cache = MemoryCache(ttl=300, max_size=1000)
client = WikiJSClient('https://wiki.example.com', auth='key', cache=cache)
# Cached GET requests
page = client.pages.get(123) # Fetches from API
page = client.pages.get(123) # Returns from cache
# Batch operations
pages = client.pages.create_many([
PageCreate(title="Page 1", path="page-1", content="Content 1"),
PageCreate(title="Page 2", path="page-2", content="Content 2"),
])
updates = client.pages.update_many([
{"id": 1, "content": "Updated content"},
{"id": 2, "is_published": False},
])
result = client.pages.delete_many([1, 2, 3])
print(f"Deleted {result['successful']} pages")
```
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
300 lines
10 KiB
Python
300 lines
10 KiB
Python
"""Tests for Pages API batch operations."""
|
|
|
|
import pytest
|
|
import responses
|
|
|
|
from wikijs import WikiJSClient
|
|
from wikijs.exceptions import APIError, ValidationError
|
|
from wikijs.models import Page, PageCreate, PageUpdate
|
|
|
|
|
|
@pytest.fixture
|
|
def client():
|
|
"""Create a test client."""
|
|
return WikiJSClient("https://wiki.example.com", auth="test-api-key")
|
|
|
|
|
|
class TestPagesCreateMany:
|
|
"""Tests for pages.create_many() method."""
|
|
|
|
@responses.activate
|
|
def test_create_many_success(self, client):
|
|
"""Test successful batch page creation."""
|
|
# Mock API responses for each create
|
|
for i in range(1, 4):
|
|
responses.add(
|
|
responses.POST,
|
|
"https://wiki.example.com/graphql",
|
|
json={
|
|
"data": {
|
|
"pages": {
|
|
"create": {
|
|
"responseResult": {"succeeded": True},
|
|
"page": {
|
|
"id": i,
|
|
"title": f"Page {i}",
|
|
"path": f"page-{i}",
|
|
"content": f"Content {i}",
|
|
"description": "",
|
|
"isPublished": True,
|
|
"isPrivate": False,
|
|
"tags": [],
|
|
"locale": "en",
|
|
"authorId": 1,
|
|
"authorName": "Admin",
|
|
"authorEmail": "admin@example.com",
|
|
"editor": "markdown",
|
|
"createdAt": "2025-01-01T00:00:00.000Z",
|
|
"updatedAt": "2025-01-01T00:00:00.000Z",
|
|
},
|
|
}
|
|
}
|
|
}
|
|
},
|
|
status=200,
|
|
)
|
|
|
|
pages_data = [
|
|
PageCreate(title=f"Page {i}", path=f"page-{i}", content=f"Content {i}")
|
|
for i in range(1, 4)
|
|
]
|
|
|
|
created_pages = client.pages.create_many(pages_data)
|
|
|
|
assert len(created_pages) == 3
|
|
for i, page in enumerate(created_pages, 1):
|
|
assert page.id == i
|
|
assert page.title == f"Page {i}"
|
|
|
|
def test_create_many_empty_list(self, client):
|
|
"""Test create_many with empty list."""
|
|
result = client.pages.create_many([])
|
|
assert result == []
|
|
|
|
@responses.activate
|
|
def test_create_many_partial_failure(self, client):
|
|
"""Test create_many with some failures."""
|
|
# Mock successful creation for first page
|
|
responses.add(
|
|
responses.POST,
|
|
"https://wiki.example.com/graphql",
|
|
json={
|
|
"data": {
|
|
"pages": {
|
|
"create": {
|
|
"responseResult": {"succeeded": True},
|
|
"page": {
|
|
"id": 1,
|
|
"title": "Page 1",
|
|
"path": "page-1",
|
|
"content": "Content 1",
|
|
"description": "",
|
|
"isPublished": True,
|
|
"isPrivate": False,
|
|
"tags": [],
|
|
"locale": "en",
|
|
"authorId": 1,
|
|
"authorName": "Admin",
|
|
"authorEmail": "admin@example.com",
|
|
"editor": "markdown",
|
|
"createdAt": "2025-01-01T00:00:00.000Z",
|
|
"updatedAt": "2025-01-01T00:00:00.000Z",
|
|
},
|
|
}
|
|
}
|
|
}
|
|
},
|
|
status=200,
|
|
)
|
|
|
|
# Mock failure for second page
|
|
responses.add(
|
|
responses.POST,
|
|
"https://wiki.example.com/graphql",
|
|
json={"errors": [{"message": "Page already exists"}]},
|
|
status=200,
|
|
)
|
|
|
|
pages_data = [
|
|
PageCreate(title="Page 1", path="page-1", content="Content 1"),
|
|
PageCreate(title="Page 2", path="page-2", content="Content 2"),
|
|
]
|
|
|
|
with pytest.raises(APIError) as exc_info:
|
|
client.pages.create_many(pages_data)
|
|
|
|
assert "Failed to create 1/2 pages" in str(exc_info.value)
|
|
assert "Successfully created: 1" in str(exc_info.value)
|
|
|
|
|
|
class TestPagesUpdateMany:
|
|
"""Tests for pages.update_many() method."""
|
|
|
|
@responses.activate
|
|
def test_update_many_success(self, client):
|
|
"""Test successful batch page updates."""
|
|
# Mock API responses for each update
|
|
for i in range(1, 4):
|
|
responses.add(
|
|
responses.POST,
|
|
"https://wiki.example.com/graphql",
|
|
json={
|
|
"data": {
|
|
"updatePage": {
|
|
"id": i,
|
|
"title": f"Updated Page {i}",
|
|
"path": f"page-{i}",
|
|
"content": f"Updated Content {i}",
|
|
"description": "",
|
|
"isPublished": True,
|
|
"isPrivate": False,
|
|
"tags": [],
|
|
"locale": "en",
|
|
"authorId": 1,
|
|
"authorName": "Admin",
|
|
"authorEmail": "admin@example.com",
|
|
"editor": "markdown",
|
|
"createdAt": "2025-01-01T00:00:00.000Z",
|
|
"updatedAt": "2025-01-01T00:10:00.000Z",
|
|
}
|
|
}
|
|
},
|
|
status=200,
|
|
)
|
|
|
|
updates = [
|
|
{"id": i, "content": f"Updated Content {i}", "title": f"Updated Page {i}"}
|
|
for i in range(1, 4)
|
|
]
|
|
|
|
updated_pages = client.pages.update_many(updates)
|
|
|
|
assert len(updated_pages) == 3
|
|
for i, page in enumerate(updated_pages, 1):
|
|
assert page.id == i
|
|
assert page.title == f"Updated Page {i}"
|
|
assert page.content == f"Updated Content {i}"
|
|
|
|
def test_update_many_empty_list(self, client):
|
|
"""Test update_many with empty list."""
|
|
result = client.pages.update_many([])
|
|
assert result == []
|
|
|
|
def test_update_many_missing_id(self, client):
|
|
"""Test update_many with missing id field."""
|
|
updates = [{"content": "New content"}] # Missing 'id'
|
|
|
|
with pytest.raises(APIError) as exc_info:
|
|
client.pages.update_many(updates)
|
|
|
|
assert "must have an 'id' field" in str(exc_info.value)
|
|
|
|
@responses.activate
|
|
def test_update_many_partial_failure(self, client):
|
|
"""Test update_many with some failures."""
|
|
# Mock successful update for first page
|
|
responses.add(
|
|
responses.POST,
|
|
"https://wiki.example.com/graphql",
|
|
json={
|
|
"data": {
|
|
"updatePage": {
|
|
"id": 1,
|
|
"title": "Updated Page 1",
|
|
"path": "page-1",
|
|
"content": "Updated Content 1",
|
|
"description": "",
|
|
"isPublished": True,
|
|
"isPrivate": False,
|
|
"tags": [],
|
|
"locale": "en",
|
|
"authorId": 1,
|
|
"authorName": "Admin",
|
|
"authorEmail": "admin@example.com",
|
|
"editor": "markdown",
|
|
"createdAt": "2025-01-01T00:00:00.000Z",
|
|
"updatedAt": "2025-01-01T00:10:00.000Z",
|
|
}
|
|
}
|
|
},
|
|
status=200,
|
|
)
|
|
|
|
# Mock failure for second page
|
|
responses.add(
|
|
responses.POST,
|
|
"https://wiki.example.com/graphql",
|
|
json={"errors": [{"message": "Page not found"}]},
|
|
status=200,
|
|
)
|
|
|
|
updates = [
|
|
{"id": 1, "content": "Updated Content 1"},
|
|
{"id": 999, "content": "Updated Content 999"},
|
|
]
|
|
|
|
with pytest.raises(APIError) as exc_info:
|
|
client.pages.update_many(updates)
|
|
|
|
assert "Failed to update 1/2 pages" in str(exc_info.value)
|
|
|
|
|
|
class TestPagesDeleteMany:
|
|
"""Tests for pages.delete_many() method."""
|
|
|
|
@responses.activate
|
|
def test_delete_many_success(self, client):
|
|
"""Test successful batch page deletions."""
|
|
# Mock API responses for each delete
|
|
for i in range(1, 4):
|
|
responses.add(
|
|
responses.POST,
|
|
"https://wiki.example.com/graphql",
|
|
json={"data": {"deletePage": {"success": True}}},
|
|
status=200,
|
|
)
|
|
|
|
result = client.pages.delete_many([1, 2, 3])
|
|
|
|
assert result["successful"] == 3
|
|
assert result["failed"] == 0
|
|
assert result["errors"] == []
|
|
|
|
def test_delete_many_empty_list(self, client):
|
|
"""Test delete_many with empty list."""
|
|
result = client.pages.delete_many([])
|
|
assert result["successful"] == 0
|
|
assert result["failed"] == 0
|
|
assert result["errors"] == []
|
|
|
|
@responses.activate
|
|
def test_delete_many_partial_failure(self, client):
|
|
"""Test delete_many with some failures."""
|
|
# Mock successful deletion for first two pages
|
|
responses.add(
|
|
responses.POST,
|
|
"https://wiki.example.com/graphql",
|
|
json={"data": {"deletePage": {"success": True}}},
|
|
status=200,
|
|
)
|
|
responses.add(
|
|
responses.POST,
|
|
"https://wiki.example.com/graphql",
|
|
json={"data": {"deletePage": {"success": True}}},
|
|
status=200,
|
|
)
|
|
|
|
# Mock failure for third page
|
|
responses.add(
|
|
responses.POST,
|
|
"https://wiki.example.com/graphql",
|
|
json={"errors": [{"message": "Page not found"}]},
|
|
status=200,
|
|
)
|
|
|
|
with pytest.raises(APIError) as exc_info:
|
|
client.pages.delete_many([1, 2, 999])
|
|
|
|
assert "Failed to delete 1/3 pages" in str(exc_info.value)
|
|
assert "Successfully deleted: 2" in str(exc_info.value)
|