512 lines
19 KiB
Python
512 lines
19 KiB
Python
#!/usr/bin/env python3
|
|
"""Tests for habits API endpoints (GET and POST)."""
|
|
|
|
import json
|
|
import sys
|
|
import tempfile
|
|
import shutil
|
|
from pathlib import Path
|
|
from datetime import datetime, timedelta
|
|
from http.server import HTTPServer
|
|
import threading
|
|
import time
|
|
import urllib.request
|
|
import urllib.error
|
|
|
|
# Add parent directory to path so we can import api module
|
|
sys.path.insert(0, str(Path(__file__).parent.parent))
|
|
|
|
# Mock the habits file to a temp location for testing
|
|
import api
|
|
original_habits_file = api.HABITS_FILE
|
|
|
|
def setup_test_env():
|
|
"""Set up temporary test environment."""
|
|
temp_dir = Path(tempfile.mkdtemp())
|
|
api.HABITS_FILE = temp_dir / 'habits.json'
|
|
|
|
# Create empty habits file
|
|
api.HABITS_FILE.write_text(json.dumps({
|
|
'lastUpdated': '',
|
|
'habits': []
|
|
}))
|
|
|
|
return temp_dir
|
|
|
|
def cleanup_test_env(temp_dir):
|
|
"""Clean up temporary test environment."""
|
|
api.HABITS_FILE = original_habits_file
|
|
shutil.rmtree(temp_dir)
|
|
|
|
def start_test_server(port=8765):
|
|
"""Start test server in background thread."""
|
|
server = HTTPServer(('localhost', port), api.TaskBoardHandler)
|
|
thread = threading.Thread(target=server.serve_forever)
|
|
thread.daemon = True
|
|
thread.start()
|
|
time.sleep(0.5) # Give server time to start
|
|
return server
|
|
|
|
def http_get(path, port=8765):
|
|
"""Make HTTP GET request."""
|
|
url = f'http://localhost:{port}{path}'
|
|
try:
|
|
with urllib.request.urlopen(url) as response:
|
|
return response.status, json.loads(response.read().decode())
|
|
except urllib.error.HTTPError as e:
|
|
return e.code, json.loads(e.read().decode()) if e.headers.get('Content-Type') == 'application/json' else {}
|
|
|
|
def http_post(path, data, port=8765):
|
|
"""Make HTTP POST request."""
|
|
url = f'http://localhost:{port}{path}'
|
|
req = urllib.request.Request(
|
|
url,
|
|
data=json.dumps(data).encode(),
|
|
headers={'Content-Type': 'application/json'}
|
|
)
|
|
try:
|
|
with urllib.request.urlopen(req) as response:
|
|
return response.status, json.loads(response.read().decode())
|
|
except urllib.error.HTTPError as e:
|
|
return e.code, json.loads(e.read().decode()) if e.headers.get('Content-Type') == 'application/json' else {}
|
|
|
|
def http_put(path, data, port=8765):
|
|
"""Make HTTP PUT request."""
|
|
url = f'http://localhost:{port}{path}'
|
|
req = urllib.request.Request(
|
|
url,
|
|
data=json.dumps(data).encode(),
|
|
headers={'Content-Type': 'application/json'},
|
|
method='PUT'
|
|
)
|
|
try:
|
|
with urllib.request.urlopen(req) as response:
|
|
return response.status, json.loads(response.read().decode())
|
|
except urllib.error.HTTPError as e:
|
|
return e.code, json.loads(e.read().decode()) if e.headers.get('Content-Type') == 'application/json' else {}
|
|
|
|
def http_delete(path, port=8765):
|
|
"""Make HTTP DELETE request."""
|
|
url = f'http://localhost:{port}{path}'
|
|
req = urllib.request.Request(url, method='DELETE')
|
|
try:
|
|
with urllib.request.urlopen(req) as response:
|
|
return response.status, None
|
|
except urllib.error.HTTPError as e:
|
|
return e.code, json.loads(e.read().decode()) if e.headers.get('Content-Type') == 'application/json' else {}
|
|
|
|
# Test 1: GET /api/habits returns empty array when no habits
|
|
def test_get_habits_empty():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
status, data = http_get('/api/habits')
|
|
assert status == 200, f"Expected 200, got {status}"
|
|
assert data == [], f"Expected empty array, got {data}"
|
|
print("✓ Test 1: GET /api/habits returns empty array")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 2: POST /api/habits creates new habit with valid input
|
|
def test_post_habit_valid():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
habit_data = {
|
|
'name': 'Morning Exercise',
|
|
'category': 'health',
|
|
'color': '#10b981',
|
|
'icon': 'dumbbell',
|
|
'priority': 1,
|
|
'notes': 'Start with 10 push-ups',
|
|
'reminderTime': '07:00',
|
|
'frequency': {
|
|
'type': 'daily'
|
|
}
|
|
}
|
|
|
|
status, data = http_post('/api/habits', habit_data)
|
|
assert status == 201, f"Expected 201, got {status}"
|
|
assert 'id' in data, "Response should include habit id"
|
|
assert data['name'] == 'Morning Exercise', f"Name mismatch: {data['name']}"
|
|
assert data['category'] == 'health', f"Category mismatch: {data['category']}"
|
|
assert data['streak']['current'] == 0, "Initial streak should be 0"
|
|
assert data['lives'] == 3, "Initial lives should be 3"
|
|
assert data['completions'] == [], "Initial completions should be empty"
|
|
print("✓ Test 2: POST /api/habits creates habit with 201")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 3: POST validates name is required
|
|
def test_post_habit_missing_name():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
status, data = http_post('/api/habits', {})
|
|
assert status == 400, f"Expected 400, got {status}"
|
|
assert 'error' in data, "Response should include error"
|
|
assert 'name' in data['error'].lower(), f"Error should mention name: {data['error']}"
|
|
print("✓ Test 3: POST validates name is required")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 4: POST validates name max 100 chars
|
|
def test_post_habit_name_too_long():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
status, data = http_post('/api/habits', {'name': 'x' * 101})
|
|
assert status == 400, f"Expected 400, got {status}"
|
|
assert 'error' in data, "Response should include error"
|
|
assert '100' in data['error'], f"Error should mention max length: {data['error']}"
|
|
print("✓ Test 4: POST validates name max 100 chars")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 5: POST validates color hex format
|
|
def test_post_habit_invalid_color():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
status, data = http_post('/api/habits', {
|
|
'name': 'Test',
|
|
'color': 'not-a-hex-color'
|
|
})
|
|
assert status == 400, f"Expected 400, got {status}"
|
|
assert 'error' in data, "Response should include error"
|
|
assert 'color' in data['error'].lower(), f"Error should mention color: {data['error']}"
|
|
print("✓ Test 5: POST validates color hex format")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 6: POST validates frequency type
|
|
def test_post_habit_invalid_frequency():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
status, data = http_post('/api/habits', {
|
|
'name': 'Test',
|
|
'frequency': {'type': 'invalid_type'}
|
|
})
|
|
assert status == 400, f"Expected 400, got {status}"
|
|
assert 'error' in data, "Response should include error"
|
|
assert 'frequency' in data['error'].lower(), f"Error should mention frequency: {data['error']}"
|
|
print("✓ Test 6: POST validates frequency type")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 7: GET /api/habits returns habits with stats enriched
|
|
def test_get_habits_with_stats():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
# Create a habit first
|
|
habit_data = {'name': 'Daily Reading', 'frequency': {'type': 'daily'}}
|
|
http_post('/api/habits', habit_data)
|
|
|
|
# Get habits
|
|
status, data = http_get('/api/habits')
|
|
assert status == 200, f"Expected 200, got {status}"
|
|
assert len(data) == 1, f"Expected 1 habit, got {len(data)}"
|
|
|
|
habit = data[0]
|
|
assert 'current_streak' in habit, "Should include current_streak"
|
|
assert 'best_streak' in habit, "Should include best_streak"
|
|
assert 'completion_rate_30d' in habit, "Should include completion_rate_30d"
|
|
assert 'weekly_summary' in habit, "Should include weekly_summary"
|
|
print("✓ Test 7: GET returns habits with stats enriched")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 8: GET /api/habits sorts by priority ascending
|
|
def test_get_habits_sorted_by_priority():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
# Create habits with different priorities
|
|
http_post('/api/habits', {'name': 'Low Priority', 'priority': 10})
|
|
http_post('/api/habits', {'name': 'High Priority', 'priority': 1})
|
|
http_post('/api/habits', {'name': 'Medium Priority', 'priority': 5})
|
|
|
|
# Get habits
|
|
status, data = http_get('/api/habits')
|
|
assert status == 200, f"Expected 200, got {status}"
|
|
assert len(data) == 3, f"Expected 3 habits, got {len(data)}"
|
|
|
|
# Check sorting
|
|
assert data[0]['priority'] == 1, "First should be priority 1"
|
|
assert data[1]['priority'] == 5, "Second should be priority 5"
|
|
assert data[2]['priority'] == 10, "Third should be priority 10"
|
|
print("✓ Test 8: GET sorts habits by priority ascending")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 9: POST returns 400 for invalid JSON
|
|
def test_post_habit_invalid_json():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
url = f'http://localhost:8765/api/habits'
|
|
req = urllib.request.Request(
|
|
url,
|
|
data=b'invalid json{',
|
|
headers={'Content-Type': 'application/json'}
|
|
)
|
|
try:
|
|
urllib.request.urlopen(req)
|
|
assert False, "Should have raised HTTPError"
|
|
except urllib.error.HTTPError as e:
|
|
assert e.code == 400, f"Expected 400, got {e.code}"
|
|
print("✓ Test 9: POST returns 400 for invalid JSON")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 10: POST initializes streak.current=0
|
|
def test_post_habit_initial_streak():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
status, data = http_post('/api/habits', {'name': 'Test Habit'})
|
|
assert status == 201, f"Expected 201, got {status}"
|
|
assert data['streak']['current'] == 0, "Initial streak.current should be 0"
|
|
assert data['streak']['best'] == 0, "Initial streak.best should be 0"
|
|
assert data['streak']['lastCheckIn'] is None, "Initial lastCheckIn should be None"
|
|
print("✓ Test 10: POST initializes streak correctly")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 12: PUT /api/habits/{id} updates habit successfully
|
|
def test_put_habit_valid():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
# Create a habit first
|
|
habit_data = {
|
|
'name': 'Original Name',
|
|
'category': 'health',
|
|
'color': '#10b981',
|
|
'priority': 3
|
|
}
|
|
status, created_habit = http_post('/api/habits', habit_data)
|
|
habit_id = created_habit['id']
|
|
|
|
# Update the habit
|
|
update_data = {
|
|
'name': 'Updated Name',
|
|
'category': 'productivity',
|
|
'color': '#ef4444',
|
|
'priority': 1,
|
|
'notes': 'New notes'
|
|
}
|
|
status, updated_habit = http_put(f'/api/habits/{habit_id}', update_data)
|
|
|
|
assert status == 200, f"Expected 200, got {status}"
|
|
assert updated_habit['name'] == 'Updated Name', "Name not updated"
|
|
assert updated_habit['category'] == 'productivity', "Category not updated"
|
|
assert updated_habit['color'] == '#ef4444', "Color not updated"
|
|
assert updated_habit['priority'] == 1, "Priority not updated"
|
|
assert updated_habit['notes'] == 'New notes', "Notes not updated"
|
|
assert updated_habit['id'] == habit_id, "ID should not change"
|
|
print("✓ Test 12: PUT /api/habits/{id} updates habit successfully")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 13: PUT /api/habits/{id} does not allow editing protected fields
|
|
def test_put_habit_protected_fields():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
# Create a habit first
|
|
habit_data = {'name': 'Test Habit'}
|
|
status, created_habit = http_post('/api/habits', habit_data)
|
|
habit_id = created_habit['id']
|
|
original_created_at = created_habit['createdAt']
|
|
|
|
# Try to update protected fields
|
|
update_data = {
|
|
'name': 'Updated Name',
|
|
'id': 'new-id',
|
|
'createdAt': '2020-01-01T00:00:00',
|
|
'streak': {'current': 100, 'best': 200},
|
|
'lives': 10,
|
|
'completions': [{'date': '2025-01-01'}]
|
|
}
|
|
status, updated_habit = http_put(f'/api/habits/{habit_id}', update_data)
|
|
|
|
assert status == 200, f"Expected 200, got {status}"
|
|
assert updated_habit['name'] == 'Updated Name', "Name should be updated"
|
|
assert updated_habit['id'] == habit_id, "ID should not change"
|
|
assert updated_habit['createdAt'] == original_created_at, "createdAt should not change"
|
|
assert updated_habit['streak']['current'] == 0, "streak should not change"
|
|
assert updated_habit['lives'] == 3, "lives should not change"
|
|
assert updated_habit['completions'] == [], "completions should not change"
|
|
print("✓ Test 13: PUT /api/habits/{id} does not allow editing protected fields")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 14: PUT /api/habits/{id} returns 404 for non-existent habit
|
|
def test_put_habit_not_found():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
update_data = {'name': 'Updated Name'}
|
|
status, response = http_put('/api/habits/non-existent-id', update_data)
|
|
|
|
assert status == 404, f"Expected 404, got {status}"
|
|
assert 'error' in response, "Expected error message"
|
|
print("✓ Test 14: PUT /api/habits/{id} returns 404 for non-existent habit")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 15: PUT /api/habits/{id} validates input
|
|
def test_put_habit_invalid_input():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
# Create a habit first
|
|
habit_data = {'name': 'Test Habit'}
|
|
status, created_habit = http_post('/api/habits', habit_data)
|
|
habit_id = created_habit['id']
|
|
|
|
# Test invalid color
|
|
update_data = {'color': 'not-a-hex-color'}
|
|
status, response = http_put(f'/api/habits/{habit_id}', update_data)
|
|
assert status == 400, f"Expected 400 for invalid color, got {status}"
|
|
|
|
# Test empty name
|
|
update_data = {'name': ''}
|
|
status, response = http_put(f'/api/habits/{habit_id}', update_data)
|
|
assert status == 400, f"Expected 400 for empty name, got {status}"
|
|
|
|
# Test name too long
|
|
update_data = {'name': 'x' * 101}
|
|
status, response = http_put(f'/api/habits/{habit_id}', update_data)
|
|
assert status == 400, f"Expected 400 for long name, got {status}"
|
|
|
|
print("✓ Test 15: PUT /api/habits/{id} validates input")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 16: DELETE /api/habits/{id} removes habit successfully
|
|
def test_delete_habit_success():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
# Create a habit first
|
|
habit_data = {'name': 'Habit to Delete'}
|
|
status, created_habit = http_post('/api/habits', habit_data)
|
|
habit_id = created_habit['id']
|
|
|
|
# Verify habit exists
|
|
status, habits = http_get('/api/habits')
|
|
assert len(habits) == 1, "Should have 1 habit"
|
|
|
|
# Delete the habit
|
|
status, _ = http_delete(f'/api/habits/{habit_id}')
|
|
assert status == 204, f"Expected 204, got {status}"
|
|
|
|
# Verify habit is deleted
|
|
status, habits = http_get('/api/habits')
|
|
assert len(habits) == 0, "Should have 0 habits after deletion"
|
|
print("✓ Test 16: DELETE /api/habits/{id} removes habit successfully")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 17: DELETE /api/habits/{id} returns 404 for non-existent habit
|
|
def test_delete_habit_not_found():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
status, response = http_delete('/api/habits/non-existent-id')
|
|
|
|
assert status == 404, f"Expected 404, got {status}"
|
|
assert 'error' in response, "Expected error message"
|
|
print("✓ Test 17: DELETE /api/habits/{id} returns 404 for non-existent habit")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 18: do_OPTIONS includes PUT and DELETE methods
|
|
def test_options_includes_put_delete():
|
|
temp_dir = setup_test_env()
|
|
server = start_test_server()
|
|
|
|
try:
|
|
# Make OPTIONS request
|
|
url = 'http://localhost:8765/api/habits'
|
|
req = urllib.request.Request(url, method='OPTIONS')
|
|
with urllib.request.urlopen(req) as response:
|
|
allowed_methods = response.headers.get('Access-Control-Allow-Methods', '')
|
|
assert 'PUT' in allowed_methods, f"PUT not in allowed methods: {allowed_methods}"
|
|
assert 'DELETE' in allowed_methods, f"DELETE not in allowed methods: {allowed_methods}"
|
|
print("✓ Test 18: do_OPTIONS includes PUT and DELETE methods")
|
|
finally:
|
|
server.shutdown()
|
|
cleanup_test_env(temp_dir)
|
|
|
|
# Test 19: Typecheck passes
|
|
def test_typecheck():
|
|
result = subprocess.run(
|
|
['python3', '-m', 'py_compile', str(Path(__file__).parent.parent / 'api.py')],
|
|
capture_output=True
|
|
)
|
|
assert result.returncode == 0, f"Typecheck failed: {result.stderr.decode()}"
|
|
print("✓ Test 11: Typecheck passes")
|
|
|
|
if __name__ == '__main__':
|
|
import subprocess
|
|
|
|
print("\n=== Running Habits API Tests ===\n")
|
|
|
|
test_get_habits_empty()
|
|
test_post_habit_valid()
|
|
test_post_habit_missing_name()
|
|
test_post_habit_name_too_long()
|
|
test_post_habit_invalid_color()
|
|
test_post_habit_invalid_frequency()
|
|
test_get_habits_with_stats()
|
|
test_get_habits_sorted_by_priority()
|
|
test_post_habit_invalid_json()
|
|
test_post_habit_initial_streak()
|
|
test_put_habit_valid()
|
|
test_put_habit_protected_fields()
|
|
test_put_habit_not_found()
|
|
test_put_habit_invalid_input()
|
|
test_delete_habit_success()
|
|
test_delete_habit_not_found()
|
|
test_options_includes_put_delete()
|
|
test_typecheck()
|
|
|
|
print("\n✅ All 19 tests passed!\n")
|