import httpx
# ============================================================================
# Mock Response Helpers for Unit Tests
# ============================================================================
def create_mock_response(
status_code: int = 200,
json_data: dict | list | None = None,
headers: dict | None = None,
content: bytes | None = None,
) -> httpx.Response:
"""Create a mock httpx.Response for testing.
Args:
status_code: HTTP status code
json_data: JSON data to return from response.json()
headers: Response headers
content: Raw response content (if not using json_data)
Returns:
Mock httpx.Response object
"""
import json as json_module
if headers is None:
headers = {}
# If json_data is provided, serialize it to content
if json_data is not None:
content = json_module.dumps(json_data).encode("utf-8")
headers.setdefault("content-type", "application/json")
if content is None:
content = b""
# Create a mock request
request = httpx.Request("GET", "http://test.local/api")
# Create the response
return httpx.Response(
status_code=status_code,
headers=headers,
content=content,
request=request,
)
def create_mock_note_response(
note_id: int = 1,
title: str = "Test Note",
content: str = "Test content",
category: str = "Test",
etag: str = "abc123",
**kwargs,
) -> httpx.Response:
"""Create a mock response for a Nextcloud note.
Args:
note_id: Note ID
title: Note title
content: Note content
category: Note category
etag: ETag header value
**kwargs: Additional note fields
Returns:
Mock httpx.Response with note data
"""
note_data = {
"id": note_id,
"title": title,
"content": content,
"category": category,
"etag": etag,
"modified": 1234567890,
"favorite": False,
**kwargs,
}
return create_mock_response(
status_code=200,
json_data=note_data,
headers={"etag": f'"{etag}"'},
)
def create_mock_error_response(
status_code: int,
message: str = "Error",
) -> httpx.Response:
"""Create a mock error response.
Args:
status_code: HTTP error status code (e.g., 404, 412)
message: Error message
Returns:
Mock httpx.Response with error
"""
return create_mock_response(
status_code=status_code,
json_data={"message": message},
)
def create_mock_recipe_response(
recipe_id: int = 1,
name: str = "Test Recipe",
description: str = "Test description",
recipe_category: str = "Test",
keywords: str = "test",
recipe_yield: int = 4,
**kwargs,
) -> httpx.Response:
"""Create a mock response for a Nextcloud Cookbook recipe.
Args:
recipe_id: Recipe ID
name: Recipe name
description: Recipe description
recipe_category: Recipe category
keywords: Recipe keywords (comma-separated)
recipe_yield: Recipe yield (number of servings)
**kwargs: Additional recipe fields (recipeIngredient, recipeInstructions, etc.)
Returns:
Mock httpx.Response with recipe data
"""
recipe_data = {
"id": recipe_id,
"name": name,
"description": description,
"recipeCategory": recipe_category,
"keywords": keywords,
"recipeYield": recipe_yield,
"recipeIngredient": kwargs.get("recipeIngredient", []),
"recipeInstructions": kwargs.get("recipeInstructions", []),
"prepTime": kwargs.get("prepTime", "PT15M"),
"cookTime": kwargs.get("cookTime", "PT30M"),
"totalTime": kwargs.get("totalTime", "PT45M"),
"url": kwargs.get("url", ""),
**{
k: v
for k, v in kwargs.items()
if k
not in [
"recipeIngredient",
"recipeInstructions",
"prepTime",
"cookTime",
"totalTime",
"url",
]
},
}
return create_mock_response(
status_code=200,
json_data=recipe_data,
)
def create_mock_recipe_list_response(
recipes: list[dict] = None,
) -> httpx.Response:
"""Create a mock response for a list of recipe stubs.
Args:
recipes: List of recipe stub dictionaries. If None, returns empty list.
Returns:
Mock httpx.Response with recipe list data
"""
if recipes is None:
recipes = []
return create_mock_response(
status_code=200,
json_data=recipes,
)
def create_mock_deck_board_response(
board_id: int = 1,
title: str = "Test Board",
color: str = "0000FF",
**kwargs,
) -> httpx.Response:
"""Create a mock response for a Nextcloud Deck board.
Args:
board_id: Board ID
title: Board title
color: Board color (hex without #)
**kwargs: Additional board fields
Returns:
Mock httpx.Response with board data
"""
board_data = {
"id": board_id,
"title": title,
"color": color,
"owner": {
"primaryKey": "testuser",
"uid": "testuser",
"displayname": "Test User",
},
"archived": False,
"labels": [],
"acl": [],
"permissions": {
"PERMISSION_READ": True,
"PERMISSION_EDIT": True,
"PERMISSION_MANAGE": True,
"PERMISSION_SHARE": True,
},
"users": [],
"deletedAt": 0,
**kwargs,
}
return create_mock_response(status_code=200, json_data=board_data)
def create_mock_deck_stack_response(
stack_id: int = 1,
title: str = "Test Stack",
board_id: int = 1,
order: int = 1,
**kwargs,
) -> httpx.Response:
"""Create a mock response for a Nextcloud Deck stack.
Args:
stack_id: Stack ID
title: Stack title
board_id: Parent board ID
order: Stack order
**kwargs: Additional stack fields
Returns:
Mock httpx.Response with stack data
"""
stack_data = {
"id": stack_id,
"title": title,
"boardId": board_id,
"order": order,
"deletedAt": 0,
**kwargs,
}
return create_mock_response(status_code=200, json_data=stack_data)
def create_mock_deck_card_response(
card_id: int = 1,
title: str = "Test Card",
stack_id: int = 1,
description: str = "Test description",
**kwargs,
) -> httpx.Response:
"""Create a mock response for a Nextcloud Deck card.
Args:
card_id: Card ID
title: Card title
stack_id: Parent stack ID
description: Card description
**kwargs: Additional card fields
Returns:
Mock httpx.Response with card data
"""
card_data = {
"id": card_id,
"title": title,
"stackId": stack_id,
"type": "plain",
"order": 999,
"archived": False,
"owner": "testuser",
"description": description,
"labels": [],
"assignedUsers": [],
**kwargs,
}
return create_mock_response(status_code=200, json_data=card_data)
def create_mock_deck_label_response(
label_id: int = 1,
title: str = "Test Label",
color: str = "FF0000",
board_id: int = 1,
**kwargs,
) -> httpx.Response:
"""Create a mock response for a Nextcloud Deck label.
Args:
label_id: Label ID
title: Label title
color: Label color (hex without #)
board_id: Parent board ID
**kwargs: Additional label fields
Returns:
Mock httpx.Response with label data
"""
label_data = {
"id": label_id,
"title": title,
"color": color,
"boardId": board_id,
**kwargs,
}
return create_mock_response(status_code=200, json_data=label_data)
def create_mock_deck_comment_response(
comment_id: int = 1,
message: str = "Test comment",
card_id: int = 1,
**kwargs,
) -> httpx.Response:
"""Create a mock response for a Nextcloud Deck comment (OCS format).
Args:
comment_id: Comment ID
message: Comment message
card_id: Parent card ID
**kwargs: Additional comment fields
Returns:
Mock httpx.Response with comment data in OCS format
"""
comment_data = {
"id": comment_id,
"objectId": card_id,
"message": message,
"actorId": "testuser",
"actorDisplayName": "Test User",
"actorType": "users",
"creationDateTime": "2024-01-01T00:00:00+00:00",
"mentions": [], # Required field
**kwargs,
}
# Wrap in OCS format
ocs_response = {"ocs": {"meta": {"status": "ok"}, "data": comment_data}}
return create_mock_response(status_code=200, json_data=ocs_response)
def create_mock_tables_list_response(
tables: list[dict] = None,
) -> httpx.Response:
"""Create a mock response for list of Nextcloud Tables (OCS format).
Args:
tables: List of table dictionaries. If None, returns empty list.
Returns:
Mock httpx.Response with tables list data in OCS format
"""
if tables is None:
tables = []
ocs_response = {"ocs": {"meta": {"status": "ok"}, "data": tables}}
return create_mock_response(status_code=200, json_data=ocs_response)
def create_mock_table_schema_response(
table_id: int = 1,
columns: list[dict] = None,
**kwargs,
) -> httpx.Response:
"""Create a mock response for Nextcloud Tables schema.
Args:
table_id: Table ID
columns: List of column definitions. If None, creates sample columns.
**kwargs: Additional schema fields
Returns:
Mock httpx.Response with table schema data
"""
if columns is None:
columns = [
{"id": 1, "title": "Column 1", "type": "text"},
{"id": 2, "title": "Column 2", "type": "number"},
]
schema_data = {
"id": table_id,
"columns": columns,
**kwargs,
}
return create_mock_response(status_code=200, json_data=schema_data)
def create_mock_table_row_response(
row_id: int = 1,
table_id: int = 1,
data: list[dict] = None,
**kwargs,
) -> httpx.Response:
"""Create a mock response for Nextcloud Tables row.
Args:
row_id: Row ID
table_id: Table ID
data: List of column data dicts. If None, creates sample data.
**kwargs: Additional row fields
Returns:
Mock httpx.Response with row data
"""
if data is None:
data = [
{"columnId": 1, "value": "Test value"},
{"columnId": 2, "value": 42},
]
row_data = {
"id": row_id,
"tableId": table_id,
"createdBy": "testuser",
"createdAt": "2024-01-01T00:00:00+00:00",
"lastEditBy": "testuser",
"lastEditAt": "2024-01-01T00:00:00+00:00",
"data": data,
**kwargs,
}
return create_mock_response(status_code=200, json_data=row_data)
def create_mock_table_row_ocs_response(
row_id: int = 1,
table_id: int = 1,
data: list[dict] = None,
**kwargs,
) -> httpx.Response:
"""Create a mock OCS response for Nextcloud Tables row (used by create_row).
Args:
row_id: Row ID
table_id: Table ID
data: List of column data dicts. If None, creates sample data.
**kwargs: Additional row fields
Returns:
Mock httpx.Response with row data in OCS format
"""
if data is None:
data = [
{"columnId": 1, "value": "Test value"},
{"columnId": 2, "value": 42},
]
row_data = {
"id": row_id,
"tableId": table_id,
"createdBy": "testuser",
"createdAt": "2024-01-01T00:00:00+00:00",
"lastEditBy": "testuser",
"lastEditAt": "2024-01-01T00:00:00+00:00",
"data": data,
**kwargs,
}
ocs_response = {"ocs": {"meta": {"status": "ok"}, "data": row_data}}
return create_mock_response(status_code=200, json_data=ocs_response)
